🥮 mooncakes.io

lockwire

Deterministic run-test substrate for MoonBit

deterministic-simulation
fieldbus
moonbit
moon add mokomoking2501/lockwire@0.1.0
Download zip
Version
0.1.0
License
Apache-2.0
Last updated
last month
Downloads
22

Dependencies

README

#Lockwire

Lockwire is the first MoonBit workspace member in the Isochronon framework. It is a deterministic run-test substrate for simulation, replay, fault injection, and future native/wasm differential runs.

#Package Structure

PackageLayerCurrent role
coreCore contractsFrame/Endpoint/Medium/Reactor contracts, event ordering helpers
clockClock layerTyped Instant[D], ClockRelation, and deterministic VirtualClock
driverDriver seamNative link-driver catalog, provider-owned master harness descriptors, and trace evidence
driver/nativeNative driver stubsSplit Lockwire-owned C ABI and MoonBit FFI shim catalog for common state, highres clock, local pcap writer smoke, UDP loopback smoke, local FramePool smoke, Npcap runtime probe, Npcap live adapter ABI surface, and Linux raw socket ABI surface
osOS capability gatesProfile-gated OS descriptors for virtual clocks/timers, native stubs, UDP sockets, raw NIC, pcap writer, and event-loop boundaries
halHAL capability gatesProfile-gated HAL descriptors for virtual link ports, native/embedded FramePool, embedded clock/IRQ/DMA/MAC/CAN-FD/UART boundaries, and ThreadX BSP hook skeletons
hal/embeddedSTM32/ThreadX backendLiveTransportKind::Stm32EthKind extenum backend (open/send/receive/close via @live dispatch), embedded C stub catalog (7 BSP hooks), and cross-compile-plan reference stubs; host mock + board-level deferred
reactorReactor backend gatesDescriptor-only backend profiles for reactor_sim, reactor_epoll, reactor_iocp, and reactor_threadx
simSimulationDeterministic P2P, segment toy, minimal fabric partition/heal runners, offline switched-fabric queue/load/QoS/IRT reports, offline arbitrated-bus medium reports, and local benchmark reports
scenarioScenario layerDeterministic SimEnv/Event/ProcessHandle combinators
traceTrace/replayRecording/Replay/TraceLog digest, benchmark reports, golden text, and pcapng artifact bridge
faultFault injectionFaultPlan/FaultHit for delay/drop/corrupt/dup/reorder, topology-level partition/heal labels, offline buggify/swarm seed-pool reports, and explicit campaign coverage reports
resourceResource modelingResource/Container/Store capacity model plus offline priority/preemptive resource contention reports
observeObservationTraceSink/MetricSink/TimelineProbe hook
wasmWasm/diff runnerPortable trace digest and benchmark comparison for native/wasm
cmd/mainCLISmoke entry point
test/cmd/mainOracle-check dispatchD77 unified oracle-check surface that thin checker ps1 scripts call to apply an already-verified oracle (tshark/pcap/native-evidence/stub-catalog/preflight/threadx-board) to a live artifact; native-only

#Quick Start

Run from the workspace root:

The retained D77 top-level runners are thin execution/collection shells. For Windows native readiness, run-native.ps1 now also collects the no-live provider CLI coverage matrix as an artifact; MoonBit tests own the oracle and policy.

lockwire/test/cmd/main is the D77 oracle-check dispatch surface that thin checker scripts call: moon run lockwire/test/cmd/main -- oracle-check --oracle<name> ... applies an already-verified oracle (tshark-fields, pcap-artifact, native-bundle/session/guarded-run/live-plan/handoff, stub-catalog, preflight-manifest, threadx-board-evidence) to a live artifact and exits 1 on FAIL. Oracle correctness is covered by moon test fixtures in each owner package; the ps1 wrappers keep only external actions (read file, compute SHA256, invoke tshark).

moon check
moon test
moon run lockwire/cmd/main
powershell -ExecutionPolicy Bypass -File scripts/check-package-boundaries.ps1
powershell -ExecutionPolicy Bypass -File scripts/m5-native-wasm-diff.ps1 -Seed 42
moon run lockwire/cmd/main -- m6-segment --seed 42
moon run lockwire/cmd/main -- k1-partition-heal --seed 42
moon run lockwire/cmd/main -- l3f-switched-fabric --seed 704
moon run lockwire/cmd/main -- l3g-switched-fabric-qos-irt --seed 734
moon run lockwire/cmd/main -- d57-link-readiness --seed 757
moon run --target wasm-gc lockwire/cmd/main -- cl7-pcapng-hex --seed 42
moon run --target native lockwire/cmd/main -- udp-loopback-smoke --timeout-ms 100
moon run --target native lockwire/cmd/main -- npcap-list-ifaces
moon run --target native lockwire/cmd/main -- raw-socket-list-ifaces
powershell -ExecutionPolicy Bypass -File scripts/run-native.ps1 -Profile readiness -OutDir "_build\lockwire-run-native"
powershell -ExecutionPolicy Bypass -File scripts/native-live-preflight.ps1 -PlanOnly
powershell -ExecutionPolicy Bypass -File scripts/native-live-evidence-session.ps1 -OutDir "_build\lockwire-live-evidence-session"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-session.ps1 -SessionSummaryPath "_build\lockwire-live-evidence-session\native-live-evidence-session-summary.json" -RequireNoLiveExecution
powershell -ExecutionPolicy Bypass -File scripts/native-live-evidence-handoff-plan.ps1 -SessionSummaryPath "_build\lockwire-live-evidence-session\native-live-evidence-session-summary.json" -OutDir "_build\lockwire-live-evidence-handoff" -LiveOutDir "_build\lockwire-live-evidence-live-run"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-handoff-plan.ps1 -HandoffPlanPath "_build\lockwire-live-evidence-handoff\live-evidence-handoff-plan.json" -RequireNoLiveExecution -RequireReady
powershell -ExecutionPolicy Bypass -File scripts/run-native-live-evidence-handoff.ps1 -HandoffPlanPath "_build\lockwire-live-evidence-handoff\live-evidence-handoff-plan.json"
powershell -ExecutionPolicy Bypass -File scripts/native-live-evidence-bundle.ps1 -OutDir "_build\lockwire-live-evidence-bundle"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-bundle.ps1 -BundleSummaryPath "_build\lockwire-live-evidence-bundle\bundle-summary.json"
powershell -ExecutionPolicy Bypass -File scripts/run-native-live-evidence-bundle.ps1 -BundleSummaryPath "_build\lockwire-live-evidence-bundle\bundle-summary.json"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-guarded-run.ps1 -GuardedRunSummaryPath "_build\lockwire-live-evidence-bundle\guarded-run\guarded-live-run-summary.json" -RequireNoLiveExecution
powershell -ExecutionPolicy Bypass -File scripts/native-live-evidence-bundle.ps1 -Adapter raw-socket -OutDir "_build\lockwire-live-evidence-bundle-raw"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-bundle.ps1 -BundleSummaryPath "_build\lockwire-live-evidence-bundle-raw\bundle-summary.json"
powershell -ExecutionPolicy Bypass -File scripts/run-native-live-evidence-bundle.ps1 -BundleSummaryPath "_build\lockwire-live-evidence-bundle-raw\bundle-summary.json"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-guarded-run.ps1 -GuardedRunSummaryPath "_build\lockwire-live-evidence-bundle-raw\guarded-run\guarded-live-run-summary.json" -RequireNoLiveExecution
powershell -ExecutionPolicy Bypass -File scripts/link-readiness-handoff-target-plan.ps1 -Target windows-npcap -OutDir "_build\lockwire-link-readiness-handoff"
powershell -ExecutionPolicy Bypass -File scripts/check-link-readiness-handoff-target-plan.ps1 -PlanPath "_build\lockwire-link-readiness-handoff\windows-npcap\link-readiness-handoff-target-plan.json" -Target windows-npcap -RequireNoLiveExecution -RequireHostCommands
powershell -ExecutionPolicy Bypass -File scripts/link-readiness-handoff-target-plan.ps1 -Target linux-raw -OutDir "_build\lockwire-link-readiness-handoff"
powershell -ExecutionPolicy Bypass -File scripts/check-link-readiness-handoff-target-plan.ps1 -PlanPath "_build\lockwire-link-readiness-handoff\linux-raw\link-readiness-handoff-target-plan.json" -Target linux-raw -RequireNoLiveExecution -RequireHostCommands
powershell -ExecutionPolicy Bypass -File scripts/link-readiness-handoff-target-plan.ps1 -Target stm32-threadx -OutDir "_build\lockwire-link-readiness-handoff"
powershell -ExecutionPolicy Bypass -File scripts/check-link-readiness-handoff-target-plan.ps1 -PlanPath "_build\lockwire-link-readiness-handoff\stm32-threadx\link-readiness-handoff-target-plan.json" -Target stm32-threadx -RequireNoLiveExecution -RequireBlockedEmbedded
powershell -ExecutionPolicy Bypass -File scripts/threadx-board-evidence-handoff-plan.ps1 -OutDir "_build\lockwire-threadx-board-evidence-handoff" -BoardId "<STM32_THREADX_BOARD_ID>"
powershell -ExecutionPolicy Bypass -File scripts/check-threadx-board-evidence-handoff-plan.ps1 -PlanPath "_build\lockwire-threadx-board-evidence-handoff\threadx-board-evidence-handoff-plan.json" -RequireNoLiveExecution -RequireBlockedTemplate
powershell -ExecutionPolicy Bypass -File scripts/multitarget-link-evidence-handoff-suite.ps1 -OutDir "_build\lockwire-multitarget-link-evidence-handoff-suite" -BoardId "<STM32_THREADX_BOARD_ID>"
powershell -ExecutionPolicy Bypass -File scripts/check-multitarget-link-evidence-handoff-suite.ps1 -SummaryPath "_build\lockwire-multitarget-link-evidence-handoff-suite\multitarget-link-evidence-handoff-suite.json" -RequireNoLiveExecution -RequireHostTargets -RequireEmbeddedBlocked
powershell -ExecutionPolicy Bypass -File scripts/provider-harness-handoff-manifest.ps1 -OutDir "_build\fieldbus-provider-handoff-manifest" -Provider all
powershell -ExecutionPolicy Bypass -File scripts/check-provider-harness-handoff-manifest.ps1 -ManifestPath "_build\fieldbus-provider-handoff-manifest\provider-harness-handoff-manifest.json" -RequireNoLiveExecution -RequireBothProviders -RequireEvidenceSlots
powershell -ExecutionPolicy Bypass -File scripts/bottom-layer-live-verification-kit.ps1 -OutDir "_build\bottom-layer-live-verification-kit" -BoardId "<STM32_THREADX_BOARD_ID>"
powershell -ExecutionPolicy Bypass -File scripts/check-bottom-layer-live-verification-kit.ps1 -KitPath "_build\bottom-layer-live-verification-kit\bottom-layer-live-verification-kit.json" -RequireNoLiveExecution -RequireMultitargetSuite -RequireProviderManifest -RequireBlockedLiveEvidence
powershell -ExecutionPolicy Bypass -File scripts/bottom-layer-live-evidence-completion.ps1 -OutDir "_build\bottom-layer-live-evidence-completion" -KitPath "_build\bottom-layer-live-verification-kit\bottom-layer-live-verification-kit.json"
powershell -ExecutionPolicy Bypass -File scripts/check-bottom-layer-live-evidence-completion.ps1 -SummaryPath "_build\bottom-layer-live-evidence-completion\bottom-layer-live-evidence-completion.json" -RequireNoLiveExecution -RequireBlocked -RequireVerificationKit
powershell -ExecutionPolicy Bypass -File scripts/bottom-layer-live-evidence-request.ps1 -OutDir "_build\bottom-layer-live-evidence-request" -KitPath "_build\bottom-layer-live-verification-kit\bottom-layer-live-verification-kit.json" -WindowsInterfaceName "<NPF_INTERFACE_NAME>" -LinuxInterfaceName "<RAW_SOCKET_INTERFACE_NAME>" -BoardId "<STM32_THREADX_BOARD_ID>"
powershell -ExecutionPolicy Bypass -File scripts/check-bottom-layer-live-evidence-request.ps1 -RequestPath "_build\bottom-layer-live-evidence-request\bottom-layer-live-evidence-request.json" -RequireNoLiveExecution -RequireVerificationKit -RequireAllTargets -RequireCompletionCommand
powershell -ExecutionPolicy Bypass -File scripts/bottom-layer-live-evidence-transcript-template.ps1 -RequestPath "_build\bottom-layer-live-evidence-request\bottom-layer-live-evidence-request.json" -OutDir "_build\bottom-layer-live-evidence-transcript" -Operator "<OPERATOR>" -LabId "<LAB_ID>"
powershell -ExecutionPolicy Bypass -File scripts/check-bottom-layer-live-evidence-transcript.ps1 -TranscriptPath "_build\bottom-layer-live-evidence-transcript\bottom-layer-live-evidence-transcript.json" -RequireNoLiveExecution -RequirePendingTemplate -RequireRequest
powershell -ExecutionPolicy Bypass -File scripts/bottom-layer-live-evidence-intake-closeout.ps1 -TranscriptPath "_build\bottom-layer-live-evidence-transcript\bottom-layer-live-evidence-transcript.json" -CompletionSummaryPath "_build\bottom-layer-live-evidence-intake\completion\bottom-layer-live-evidence-completion.json" -OutDir "_build\bottom-layer-live-evidence-intake-closeout"
powershell -ExecutionPolicy Bypass -File scripts/check-bottom-layer-live-evidence-intake-closeout.ps1 -SummaryPath "_build\bottom-layer-live-evidence-intake-closeout\bottom-layer-live-evidence-intake-closeout.json" -RequireNoLiveExecution -RequireBlocked -RequireTranscript -RequireCompletion
powershell -ExecutionPolicy Bypass -File scripts/native-readiness-gate.ps1 -OutDir "_build\lockwire-native-readiness"
powershell -ExecutionPolicy Bypass -File scripts/native-live-evidence-plan.ps1 -ReadinessOutDir "_build\lockwire-native-readiness" -InterfaceName "\\Device\\NPF_{...}" -LiveOutDir "_build\lockwire-live-preflight"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-plan.ps1 -PlanPath "_build\lockwire-live-preflight\plans\live-evidence-plan.json" -RequireReady -RequirePcapArtifactChecks -RequirePcapTSharkChecks
powershell -ExecutionPolicy Bypass -File scripts/native-readiness-gate.ps1 -Adapter raw-socket -OutDir "_build\lockwire-native-readiness-raw"
powershell -ExecutionPolicy Bypass -File scripts/native-live-evidence-plan.ps1 -Adapter raw-socket -ReadinessOutDir "_build\lockwire-native-readiness-raw" -LiveOutDir "_build\lockwire-live-preflight-raw"
powershell -ExecutionPolicy Bypass -File scripts/check-native-live-evidence-plan.ps1 -PlanPath "_build\lockwire-live-preflight-raw\plans\live-evidence-plan.json"
powershell -ExecutionPolicy Bypass -File scripts/native-live-preflight.ps1 -Adapter npcap -OutDir "_build\lockwire-live-preflight"
powershell -ExecutionPolicy Bypass -File scripts/check-native-preflight-manifest.ps1 -ManifestPath "_build\lockwire-live-preflight\preflight-manifest.json" -RequireNoLiveAttempt -RequireEnvironmentSnapshot -RequireUdpLoopbackSmoke -RequireNpcapInterfaceDiscovery -MinNpcapInterfaceCount 1 -RequireNpcapNoLiveDryRuns
powershell -ExecutionPolicy Bypass -File scripts/check-native-preflight-manifest.ps1 -ManifestPath "_build\lockwire-native-readiness-raw\preflight-manifest.json" -RequireNoLiveAttempt -RequireEnvironmentSnapshot -RequireUdpLoopbackSmoke -RequireRawSocketInterfaceDiscovery -RequireRawSocketNoLiveDryRuns
powershell -ExecutionPolicy Bypass -File scripts/native-live-preflight.ps1 -Adapter npcap -InterfaceName "\\Device\\NPF_{...}" -AllowSend -AllowCapture -CheckPcapArtifacts -CheckPcapWithTShark
powershell -ExecutionPolicy Bypass -File scripts/check-native-preflight-manifest.ps1 -ManifestPath "_build\lockwire-live-preflight\preflight-manifest.json" -RequireLiveAttempt -RequirePcapArtifactChecks -RequirePcapTSharkChecks -RequireEnvironmentSnapshot -RequireLiveEvidenceFields
powershell -ExecutionPolicy Bypass -File scripts/native-live-preflight.ps1 -Adapter raw-socket -InterfaceName "eth0" -AllowSend -AllowCapture -CheckPcapArtifacts -CheckPcapWithTShark
moon run --target native lockwire/cmd/main -- raw-socket-smoke --iface "eth0" --allow-send --allow-capture --timeout-ms 100 --attempts 3 --ethertype 0x88b5 --payload-hex "de ad be ef"
moon run --target native lockwire/cmd/main -- raw-socket-roundtrip-pcap --iface "eth0" --out "_build\\lockwire-raw-socket-roundtrip.pcap" --allow-send --allow-capture --timeout-ms 100 --attempts 3 --ethertype 0x88b5 --payload-hex "de ad be ef"
powershell -ExecutionPolicy Bypass -File scripts/check-native-pcap-artifact.ps1 -PcapPath "_build\lockwire-raw-socket-roundtrip.pcap" -RequireEtherType 0x88b5
powershell -ExecutionPolicy Bypass -File scripts/check-native-pcap-tshark.ps1 -PcapPath "_build\lockwire-raw-socket-roundtrip.pcap" -RequireEtherType 0x88b5
moon run --target native lockwire/cmd/main -- npcap-live-smoke --iface "\\Device\\NPF_{...}" --timeout-ms 100 --filter "ether proto 0x88b5"
moon run --target native lockwire/cmd/main -- npcap-send-smoke --iface "\\Device\\NPF_{...}" --allow-send --timeout-ms 100 --ethertype 0x88b5 --payload-hex "de ad be ef"
moon run --target native lockwire/cmd/main -- npcap-roundtrip-smoke --iface "\\Device\\NPF_{...}" --allow-send --allow-capture --timeout-ms 100 --attempts 3 --filter "ether proto 0x88b5" --ethertype 0x88b5 --payload-hex "de ad be ef"
moon run --target native lockwire/cmd/main -- npcap-roundtrip-pcap --iface "\\Device\\NPF_{...}" --out "_build\\lockwire-roundtrip.pcap" --allow-send --allow-capture --timeout-ms 100 --attempts 3 --filter "ether proto 0x88b5" --ethertype 0x88b5 --payload-hex "de ad be ef"
powershell -ExecutionPolicy Bypass -File scripts/check-native-pcap-artifact.ps1 -PcapPath "_build\lockwire-roundtrip.pcap" -RequireEtherType 0x88b5
powershell -ExecutionPolicy Bypass -File scripts/check-native-pcap-tshark.ps1 -PcapPath "_build\lockwire-roundtrip.pcap" -RequireEtherType 0x88b5
moon run --target native lockwire/cmd/main -- npcap-capture-pcap --iface "\\Device\\NPF_{...}" --out "_build\\lockwire-manual-capture.pcap" --allow-capture --timeout-ms 100 --filter "ether proto 0x88b5"
powershell -ExecutionPolicy Bypass -File scripts/check-native-pcap-artifact.ps1 -PcapPath "_build\lockwire-manual-capture.pcap" -RequireEtherType 0x88b5
powershell -ExecutionPolicy Bypass -File scripts/check-native-pcap-tshark.ps1 -PcapPath "_build\lockwire-manual-capture.pcap" -RequireEtherType 0x88b5
moon run --target native lockwire/cmd/main -- npcap-capture-frame-pool --iface "\\Device\\NPF_{...}" --allow-capture --timeout-ms 100 --filter "ether proto 0x88b5"

///|
test "readme smoke" {
  inspect(project_name, content="Lockwire")
  assert_eq(package_ids().length(), 14)
}

///|
test "p2p digest smoke" {
  let run = run_p2p_demo(seed=42)
  assert_eq(run.events.length(), 2)
  assert_true(same_seed_digest_stable(seed=42))
}

///|
test "clock virtual sequence smoke" {
  let domain = DomainId::new(name="sim")
  let seq : Array[Instant[SimTruth]] = deterministic_sequence(
    domain~,
    seed=42,
    count=3,
    step=Duration::from_ns(5L),
  )
  assert_eq(seq.length(), 3)
  assert_eq(seq[2].ns(), 10L)
  assert_eq(
    ghost_domain_status(),
    "instant-ghost-domain-supported; trait-domainid-fallback",
  )
}

///|
test "native wasm digest smoke" {
  assert_true(p2p_native_wasm_match(seed=42))
  assert_true(p2p_native_wasm_benchmark_match(seed=42))
  let line = p2p_digest_line(seed=42)
  assert_true(line.contains("scenario=p2p|seed=42|trace_digest="))
  assert_true(line.contains("|rng_steps=1|event_count=2"))
}

///|
test "segment toy smoke" {
  let run = run_segment_toy(seed=42)
  assert_eq(run.final_payload, b"ABz")
  assert_eq(run.total_delay.ns(), 10L)
  let timeline = run.timeline_text()
  assert_true(timeline.contains("hop=2|node=drive-3|arrive_ns=5|depart_ns=10"))
}

///|
test "fabric partition heal smoke" {
  let run = run_fabric_partition_heal(seed=42)
  assert_true(run.capabilities.unlocks_partition_faults())
  assert_eq(run.partition_count, 1)
  assert_eq(run.heal_count, 1)
  assert_eq(run.drop_count, 1)
  assert_true(run.trace.to_golden_text().contains("label=fabric.rx.late"))
}

///|
test "scenario event smoke" {
  let env = SimEnv::new(seed=7)
  let slow = timeout(env, Duration::from_ns(10L))
  let fast = spawn(env, name="fast", fn(_env) { () })
  let race = any_of(env, [slow, fast.event()])
  let result = env.run_until_event(race)
  assert_eq(result.winner_id, fast.event().id())
  assert_true(slow.is_pending())
}

///|
test "trace replay smoke" {
  let frame = Frame::acquire(id=1).filled(payload=b"x")
  let tx = TxEvent::make(
    id=1,
    vtime=VTime::from_ns(0L),
    channel_id=ChannelId(1),
    seq=1,
    source=EndpointId(1),
    target=EndpointId(2),
    frame~,
  )
  let recording = Recording::new()
  ignore(
    recording.record_tx(
      tx,
      seed=42,
      rng_step=1,
      clock_domain="sim",
      node_id="n1",
      medium_id="p2p",
      backend=@core.SimNative,
    ),
  )
  let replay = Replay::from_log(recording.get_log())
  assert_eq(replay.remaining(), 1)
  assert_eq(
    replay.digest(seed=42).state_digest,
    recording.digest(seed=42).state_digest,
  )
}

///|
test "fault resource smoke" {
  let plan = FaultPlan::new(seed=7)
  plan.add_rule(FaultRule::new(@fault.Drop, @fault.Once))
  let dropped = plan.apply(b"x")
  assert_true(dropped.dropped)

  let campaign = buggify_swarm_seed_pool_fixture()
  assert_true(campaign.passes())
  assert_true(campaign.to_text().contains("lockwire.fault-campaign-report.v1"))
  let coverage = fault_campaign_coverage_report(campaign)
  assert_true(coverage.passes())
  assert_true(
    coverage.to_text().contains("lockwire.fault-campaign-coverage-report.v1"),
  )

  let env = SimEnv::new(seed=8)
  let resource = Resource::new(name="rt-cpu", capacity=1)
  let lease = env.run_until_event(resource.request(env))
  assert_eq(resource.in_use(), 1)
  resource.release(env, lease)
  assert_eq(resource.in_use(), 0)

  let preemptive = preemptive_resource_contention_fixture(seed=744)
  assert_true(preemptive.passes())
  assert_true(preemptive.to_text().contains("interrupt_count=1"))
}

#Current Boundary

K1 adds a minimal partitionable fabric runner for architecture-level scenario completeness: delay/drop/reorder plus partition/heal trace vocabulary. It does not implement background traffic, netload, PROFINET ART behavior, real I/O, or a complete switched-fabric queueing model.

L3F adds an offline switched-fabric FIFO model on top of that boundary. run_switched_fabric_offline models per-port queue capacity, deterministic serialization delay, background flows, jitter, queue drop, reordering, netload octet accounting, replay exhaustion, and stable digest/report output. L3G adds run_switched_fabric_qos_irt_offline, a strict-priority and IRT phase-table fixture that proves high-priority same-slot scheduling, red-phase hold/drop, green-phase release, replay exhaustion, and stable digest/report output. These are still sim evidence only: they do not open a NIC, do not parse pcap/tshark, do not claim real switch QoS, PROFINET ART/PI certification, or device interoperability, and do not replace the locked live validation rows.

L5A adds an offline ArbitratedBusMedium family model for CAN-like shared buses without importing CANopen semantics. run_arbitrated_bus_offline proves deterministic priority arbitration by arbitration id, frame-slot duration estimation, error-frame plus auto-retransmit vocabulary, TEC-driven error-passive/bus-off/recovery state transitions, replay exhaustion, same-seed digest stability, and explicit rejection of reorder faults. This is still protocol-neutral sim evidence only: it does not implement SocketCAN/vcan, bit-level CAN timing, CiA 301/402 SDO/PDO/NMT, CANopen object dictionaries, real controller registers, pcap/tshark, or device interoperability.

L4C adds FaultCampaignCoverageReport on top of the existing buggify/swarm case matrix. fault_campaign_coverage_report derives scenario count, fault-point coverage, branch-label coverage, seed failure histogram, first-failure digest, and a stable coverage digest from explicit case/point/branch labels. This is report-level evidence only: it does not run moon coverage, does not claim compiler-level code coverage, and does not use external fuzzing or live backends.

D57 adds a multi-target link readiness matrix for the real backend plan. link_readiness_matrix_report ties Windows/Npcap, Linux raw/UDP/pcap, and STM32/ThreadX HAL targets to the existing OS, reactor, HAL, and driver catalogs. The Windows and Linux entries reference existing native driver IDs and no-live handoff readiness; the STM32/ThreadX entry deliberately records an embedded driver/BSP gap while validating reactor_threadx and embedded HAL gates. This is static/readiness evidence only: it does not open a NIC, does not run Linux raw sockets with privileges, does not compile a STM32/ThreadX BSP, and does not provide pcap/tshark or board evidence.

D58 adds a target-specific handoff selector on top of that matrix. scripts/link-readiness-handoff-target-plan.ps1 writes link-readiness-handoff-target-plan.json and link-readiness-handoff-target.commands.txt for windows-npcap, linux-raw, or stm32-threadx, while scripts/check-link-readiness-handoff-target-plan.ps1 recomputes the commands text hash and plan digest before the artifact is copied into a live runbook. Windows/Npcap and Linux raw targets reference the existing no-live readiness gate, evidence bundle, guarded live runner, and guarded summary checker; the generated artifact records executes_live_io=false, and only the copied guarded command can open a NIC when a human later supplies -AllowLiveExecution plus an exact interface confirmation. The STM32/ThreadX target is intentionally blocked and emits no command records until a BSP profile, board selection, ThreadX build, board MAC/DMA/CAN/UART HAL binding, embedded trace artifact, and board smoke oracle exist.

D59 turns that STM32/ThreadX blocker into a local HAL skeleton instead of a fake backend. threadx_hal_skeleton_descriptor() lists the required board hooks for embedded clock, IRQ, DMA, MAC link port, CAN-FD link port, UART link port, and embedded FramePool region, and threadx_hal_skeleton_report() checks that the real-embedded profile excludes lockwire/sim, lockwire/wasm, lockwire/driver/native, heavy pcapng parsing, and protocol-stack runtime by default. The descriptor records the local rs485_tcp STM32F407 + ThreadX/NetX Duo gateway as a reference for future MoonBit adapter binding: defer thread-restricted NetX calls out of tx_application_define, keep Ethernet/NetX DMA buffers in normal SRAM, expose board diagnostics counters, and keep protocol helpers separate from RTOS/NetX plumbing. This is still descriptor evidence only; it does not build a ThreadX project, link a BSP, run a board, or prove MAC/CAN/UART traffic.

D66 adds the matching board evidence plan for that skeleton. threadx_evidence_requirements() lists the required BSP profile, ThreadX build log, clock calibration, IRQ dispatch, DMA region map, MAC smoke, CAN-FD smoke, UART/RS-485 smoke, embedded Lockwire trace artifact, and board evidence summary checker. threadx_evidence_plan_report() verifies that every requirement is still blocked, every hook reference is valid, and no live board evidence is claimed. This is a runbook/checklist API, not an embedded backend: it does not compile an EIDE/ThreadX project, flash a board, run MAC/CAN/UART traffic, or replace the locked D57V / L2D / R1V validation rows.

D67 makes that final checker executable. scripts/check-threadx-board-evidence-summary.ps1 -SummaryPath board.evidence-summary.json -RequireBlockedPlan -RequireNoLiveEvidence validates the blocked/no-live summary shape, and -RequireCompleteEvidence is reserved for a future board-run artifact package where all 10 requirements are present with real artifact paths, SHA256 values, and byte counts. The checker only validates archived JSON/files; it does not compile ThreadX, flash a board, run MAC/CAN/UART traffic, or create live evidence by itself.

D68 adds the matching blocked template generator. scripts/threadx-board-evidence-summary-template.ps1 -OutDir _build\lockwire-threadx-board-evidence -BoardId <ID> -Check writes board.evidence-summary.json, sets all 10 D66 requirements to blocked, records a stable summary_digest, and immediately reuses the D67 checker. This gives a future EIDE/ThreadX board runner a fixed input/output contract without claiming that a board has been built, flashed, or exercised.

D69 packages that template into a checked handoff artifact. scripts/threadx-board-evidence-handoff-plan.ps1 -OutDir _build\lockwire-threadx-board-evidence-handoff -BoardId <ID> writes a source board.evidence-summary.json, checker logs, threadx-board-evidence-handoff.commands.txt, and threadx-board-evidence-handoff-plan.json; scripts/check-threadx-board-evidence-handoff-plan.ps1 -PlanPath ... -RequireNoLiveExecution -RequireBlockedTemplate recomputes hashes, validates command shape, and reruns the D67 blocked/no-live checker. All generated commands have may_open_device_when_run=false; the complete-evidence checker command is only a future board-run package gate and does not make the current template live evidence.

D70 adds a no-live multi-target suite around the same handoff pieces. scripts/multitarget-link-evidence-handoff-suite.ps1 -OutDir _build\lockwire-multitarget-link-evidence-handoff-suite -BoardId <ID> runs the D58 target plan/checker for windows-npcap, linux-raw, and stm32-threadx, then runs the D69 ThreadX board evidence handoff/checker, writing multitarget-link-evidence-handoff-suite.json, multitarget-link-evidence-handoff-suite.commands.txt, and per-command logs. scripts/check-multitarget-link-evidence-handoff-suite.ps1 -SummaryPath ... -RequireNoLiveExecution -RequireHostTargets -RequireEmbeddedBlocked verifies all hashes, target status, and no-live policy. The suite does not execute the guarded host live commands, does not open Npcap/raw sockets, and does not compile or flash STM32/ThreadX.

D71 packages the provider harness command inventory into a checked manifest. scripts/provider-harness-handoff-manifest.ps1 -OutDir _build\fieldbus-provider-handoff-manifest -Provider all runs fieldbus_core/cmd/main harness-handoffs and writes provider-harness-handoff-manifest.json, provider-harness-handoff-manifest.commands.txt, and logs; scripts/check-provider-harness-handoff-manifest.ps1 -ManifestPath ... -RequireNoLiveExecution -RequireBothProviders -RequireEvidenceSlots verifies provider coverage, handoff evidence slots, hash stability, and the no-live provider seam. This is a fieldbus harness ownership artifact only; it does not import provider protocol stacks or open any live adapter.

D72 joins the D70 target suite and D71 provider manifest into one bottom-layer verification kit. scripts/bottom-layer-live-verification-kit.ps1 -OutDir _build\bottom-layer-live-verification-kit -BoardId <ID> writes bottom-layer-live-verification-kit.json, commands text, and command logs; scripts/check-bottom-layer-live-verification-kit.ps1 -KitPath ... -RequireNoLiveExecution -RequireMultitargetSuite -RequireProviderManifest -RequireBlockedLiveEvidence verifies the referenced suite/manifest hashes, no-live policy, fieldbus_core provider seam, blocked live-evidence list, and live CLI migration requirements. The kit is still no-live handoff evidence only; it does not execute MoonECAT or PROFINET live I/O.

D73 adds the top-level completion gate for future real evidence. scripts/bottom-layer-live-evidence-completion.ps1 -KitPath ... -WindowsGuardedRunSummaryPath ... -LinuxGuardedRunSummaryPath ... -ThreadXBoardEvidenceSummaryPath ... checks the D72 kit, Windows/Npcap guarded live run, Linux raw guarded live run, and STM32/ThreadX board evidence summary, then writes bottom-layer-live-evidence-completion.json. Without the three real evidence paths it reports blocked-missing-evidence; scripts/check-bottom-layer-live-evidence-completion.ps1 -SummaryPath ... -RequireComplete -RequireAllTargets is the future final gate once all live artifacts exist. The script is checker-only and does not run live commands by itself.

D74 emits the operator request package for collecting those real artifacts. scripts/bottom-layer-live-evidence-request.ps1 -KitPath ... -WindowsInterfaceName <NPF> -LinuxInterfaceName <IFACE> -BoardId <ID> writes bottom-layer-live-evidence-request.json plus bottom-layer-live-evidence-request.commands.txt with the Windows/Npcap bundle, Linux raw bundle, guarded live runs, ThreadX board evidence template/checker, and D73 completion commands. scripts/check-bottom-layer-live-evidence-request.ps1 -RequestPath ... -RequireNoLiveExecution -RequireVerificationKit -RequireAllTargets -RequireCompletionCommand verifies the request package without running any live command.

D75 turns the D74 request package into an operator execution transcript template. scripts/bottom-layer-live-evidence-transcript-template.ps1 -RequestPath ... -OutDir ... writes bottom-layer-live-evidence-transcript.json plus a command-order text file with pending-operator-evidence slots for stdout/stderr hashes, produced artifacts, and operator notes. scripts/check-bottom-layer-live-evidence-transcript.ps1 -TranscriptPath ... -RequirePendingTemplate -RequireRequest verifies the template; after a lab fills it, -RequireCompleteTranscript requires every request command to be recorded as executed with logs and required artifacts. The transcript checker still does not execute live commands and does not replace the D73 completion gate.

D76 adds the intake closeout package above D75 and D73. scripts/bottom-layer-live-evidence-intake-closeout.ps1 -TranscriptPath ... -CompletionSummaryPath ... runs the transcript checker and completion checker, verifies that the D74 request's completion_summary_path matches the supplied D73 summary, and writes bottom-layer-live-evidence-intake-closeout.json. scripts/check-bottom-layer-live-evidence-intake-closeout.ps1 -SummaryPath ... -RequireBlocked is the expected no-live state until the lab provides complete transcript and complete D73 evidence; -RequireComplete is reserved for the future real-evidence closeout.

D61 adds the first protocol-neutral native link session facade on top of the existing ABI owners. native_link_session_catalog() and native_link_session_catalog_report() register Npcap, Linux raw socket, and UDP sessions with open/send/receive/close capability, fallback mirror files, existing C ABI owner modules, and FramePool routing support. NativeNpcapLinkSession and NativeRawSocketLinkSession keep a mandatory allow_live_open gate before calling live open, while NativeUdpLinkSession supports local loopback smoke without opening a raw NIC. NativeFramePool::stage_link_session_frame and read_link_session_frame provide a common copied-slot path for send/receive staging. This reuses the existing C stubs; it does not add a C-level vtable, does not open Npcap/raw socket adapters by default, and does not claim pcap/tshark, device interoperability, DMA/AF_XDP, or true zero-copy evidence.

The native driver package now includes UDP loopback and FramePool smoke paths. UDP validates local OS socket ABI, send/receive, timeout, and report plumbing. FramePool validates Lockwire-owned preallocated frame slots, borrowed FixedArray[Byte] write/read, copy, lifecycle marks, reuse, and free-count plumbing. Neither path claims raw NIC, Npcap/libpcap raw frame I/O, DMA/AF_XDP, pcap/tshark, or hardware evidence.

Its C stubs are split by capability: stub_common.h is the root shared helper contract, while stub_common_status.c owns last-error state and the common public status ABI, stub_common_handle.c owns generic handle helpers, and stub_common_bytes.c owns u16 byte-order helpers. High-resolution time is split into mutually gated owners: stub_clock_windows.c, stub_clock_posix.c, and stub_clock_unsupported.c. stub_pcap.h and stub_pcap_common.c own classic pcap helper state/serialization while stub_pcap_writer.c owns the public pcap artifact writer ABI. The UDP socket ABI is split into Windows common/adapter/send/receive files (stub_udp_windows_common.c, stub_udp_windows_adapter.c, stub_udp_windows_send.c, stub_udp_windows_recv.c, stub_udp_windows.h), POSIX common/adapter/send/receive files (stub_udp_posix_common.c, stub_udp_posix_adapter.c, stub_udp_posix_send.c, stub_udp_posix_recv.c, stub_udp_posix.h), and stub_udp_unsupported.c. FramePool is split into stub_frame_pool.h, helper-only stub_frame_pool_common.c, lifecycle owner stub_frame_pool_lifecycle.c, state owner stub_frame_pool_state.c, and I/O owner stub_frame_pool_io.c. The Linux raw socket side is split into stub_raw_socket_linux_common.c, stub_raw_socket_linux_adapter.c, stub_raw_socket_linux_list.c, stub_raw_socket_linux_send.c, stub_raw_socket_linux_capture.c, stub_raw_socket_linux.h, and stub_raw_socket_unsupported.c, and the Npcap side is split into loader, listing, shared common, live session/open-close, live send, live filter, live capture, and unsupported fallback files: stub_npcap_windows_loader.c, stub_npcap_windows_listing.c, stub_npcap_windows_common.c, stub_npcap_windows_live.c, stub_npcap_windows_live_send.c, stub_npcap_windows_live_filter.c, stub_npcap_windows_live_capture.c, and stub_npcap_unsupported.c. The MoonBit FFI shim follows the same ability-family split with paired ffi_*_native.mbt and ffi_*_fallback.mbt files for common, clock, pcap, UDP, Npcap, raw socket, and FramePool. native_stub_module_catalog() mirrors those C and MoonBit shim boundaries as a public descriptor/report surface, including target gate, fallback behavior, and live boundary checks. This is still a staged boundary: Npcap and Linux raw socket live adapter symbols and wrappers exist, but live capture/send evidence, pcap/tshark, hardware interoperability, DMA/AF_XDP, and live zero-copy adapter integration remain separate locked work.

The Npcap path has nine local reports. NativeNpcapProbeReport records whether Npcap could be dynamically loaded and how many interfaces were enumerated, while keeping live_capture_evidence=false. NativeNpcapInterfaceListReport wraps the same discovery path as structured name/description entries and backs npcap-list-ifaces, whose output is intended for copying a \Device\NPF_{...} name into the manual runners. NativeNpcapLiveAdapterReport records that the live adapter ABI surface is present on the Windows native backend and that a manual interface is required before opening a NIC, including the pcap_compile/pcap_setfilter/pcap_freecode filter surface. native_npcap_make_ethernet_smoke_frame builds the explicit manual Ethernet frame template used by send/roundtrip runners: the default is the existing 60-byte Lockwire smoke frame, while CLI options can override EtherType, dst/src MAC, and payload hex before any adapter is opened. NativeNpcapManualLiveSmokeReport is the explicit manual capture runner behind npcap-live-smoke --iface NAME --timeout-ms N [--filter EXPR]; without --iface it reports attempted_open=false, and with an interface it attempts optional filter setup before capture/close. NativeNpcapManualSendSmokeReport is the explicit manual send runner behind npcap-send-smoke --iface NAME --allow-send; without --allow-send it does not open the adapter, and with the flag it sends one Lockwire synthetic Ethernet smoke frame. NativeNpcapSendCaptureRoundtripReport is the explicit manual send+capture runner behind npcap-roundtrip-smoke --iface NAME --allow-send --allow-capture [--filter EXPR]; without both allow flags it does not open the adapter, and live_roundtrip_evidence requires a full sent-frame length, exact captured-byte match, and close. NativeNpcapRoundtripPcapArtifactReport is the explicit exact-match roundtrip-to-artifact runner behind npcap-roundtrip-pcap --iface NAME --out PATH --allow-send --allow-capture [--filter EXPR]; without interface, output path, or both allow flags it does not open the adapter and does not create a pcap file, and it writes only after live_roundtrip_evidence=true. NativeNpcapCapturePcapArtifactReport is the explicit manual capture-to-artifact runner behind npcap-capture-pcap --iface NAME --out PATH --allow-capture [--filter EXPR]; without interface, output path, or --allow-capture, it does not open the adapter, does not capture, and does not create a pcap file. NativeNpcapFramePoolCaptureReport is the explicit manual capture-to-FramePool runner behind npcap-capture-frame-pool --iface NAME --allow-capture [--filter EXPR]; without interface or --allow-capture, it does not open the adapter and does not write a FramePool slot. Only a captured frame sets live_capture_evidence=true, only a successful allowed send sets live_send_evidence=true, only an exact send/capture byte match sets live_roundtrip_evidence=true, only an exact send/capture byte match written through the pcap writer sets live_roundtrip_pcap_evidence=true, only a captured frame written through the pcap writer sets pcap_artifact_evidence=true, and only a captured frame written into and read back from a Lockwire FramePool slot sets frame_pool_capture_evidence=true / live_frame_pool_evidence=true. The frame template and filter surfaces only record which frame was prepared and whether a manual filter was attempted/configured; they do not prove capture success by themselves, and a filter configuration failure skips the following send/capture step. The FramePool path is still a copied slot-lifecycle smoke, and the roundtrip pcap path is still a manual artifact smoke rather than tshark proof; device interoperability, Linux raw socket, DMA/AF_XDP/true zero-copy, and certification evidence remain separate locked work.

The Linux raw socket path mirrors the same manual safety boundary. NativeRawSocketAdapterReport records whether the current native target exposes the Linux AF_PACKET/SOCK_RAW ABI surface; Windows and wasm report the surface as unavailable instead of pretending to support it. NativeRawSocketInterfaceListReport backs raw-socket-list-ifaces and returns copyable Linux interface names when run on Linux. NativeRawSocketManualSmokeReport backs raw-socket-smoke --iface NAME [--allow-send] [--allow-capture]; without an interface or at least one allow flag it does not open a socket, and on non-Linux targets it returns the unsupported backend error. On Linux with the required raw socket privileges it can send the same explicit Ethernet smoke frame template and/or attempt bounded capture, but only a successful allowed send sets live_send_evidence=true, only a non-empty capture sets live_capture_evidence=true, and only an exact sent-frame match sets live_roundtrip_evidence=true. NativeRawSocketRoundtripPcapArtifactReport backs raw-socket-roundtrip-pcap --iface NAME --out PATH --allow-send --allow-capture; without interface, output path, or both allow flags it does not open the socket and does not create a pcap file, and it writes only after exact-match live_roundtrip_evidence=true plus close success. This still is not device interoperability, PACKET_MMAP, AF_XDP/DMA, or certification evidence; pcap/TShark only audits the generated artifact after a successful live run.

scripts/native-live-evidence-session.ps1 is the top-level no-live session wrapper for the pre-NIC path. It runs the bundle generator, bundle checker, guarded dry-run, and guarded-run checker in order, then writes native-live-evidence-session-summary.json with command logs, artifact hashes, adapter, bundle status, guarded-run status, selected interface state, and executes_live_io=false; it intentionally has no -AllowLiveExecution switch. scripts/check-native-live-evidence-session.ps1 validates that summary after the session is archived: it checks the session schema/status, four command logs and SHA256 values, adapter propagation, bundle and guarded summaries, ready/no-live policy, -RequireNoLiveExecution, and optional ready/pcap/TShark requirements without rerunning the session or opening a NIC. scripts/native-live-evidence-handoff-plan.ps1 consumes a checked ready session, reruns the session checker with -RequireNoLiveExecution -RequireReady, and writes live-evidence-handoff-plan.json plus live-evidence-handoff.commands.txt with the guarded live execution command and the required live summary checker command; the generator itself records executes_live_io=false and does not run either command, while the first generated command can open the selected NIC only when an operator runs it manually. scripts/check-native-live-evidence-handoff-plan.ps1 validates that handoff artifact before anyone copies the live commands: it checks the handoff schema/status, adapter, source session SHA256, bundle SHA256, session checker stdout/stderr hashes, session_check=PASS, the two structured command records, the commands text file, no-live policy, and optional ready/pcap/TShark policies without executing either generated command. scripts/run-native-live-evidence-handoff.ps1 consumes that checked handoff and writes handoff-run-summary.json; by default it only runs the handoff checker and records both planned commands as executed=false, while live execution requires -AllowLiveExecution plus exact -ConfirmInterfaceName and still runs the generated guarded live command followed by the generated live summary checker. scripts/link-readiness-handoff-target-plan.ps1 selects the same guarded shape by target: Windows/Npcap maps to the Npcap bundle, Linux raw maps to the raw-socket bundle, and STM32/ThreadX emits a blocked no-command plan until board and BSP evidence exist. scripts/check-link-readiness-handoff-target-plan.ps1 validates that target plan, commands text SHA256, digest, host command set, and embedded blocked reasons without executing any generated command. scripts/native-live-evidence-bundle.ps1 is the no-live bundle wrapper for the same path and accepts -Adapter npcap|raw-socket. It runs scripts/native-readiness-gate.ps1, scripts/native-live-evidence-plan.ps1, and scripts/check-native-live-evidence-plan.ps1 in order, then writes bundle-summary.json with command log hashes, readiness/plan artifact hashes, candidate interface count, selected interface status, adapter, and executes_live_io=false. scripts/check-native-live-evidence-bundle.ps1 validates that summary and all referenced artifacts before the bundle is used or archived: it checks schema, adapter, command exit codes, stdout/stderr bytes and SHA256 values, readiness summary, readiness manifest, live evidence plan, command text, plan checker output, selected interface state, adapter-specific interface count policy, and optional ready/pcap/TShark policies. Without -InterfaceName the bundle may pass as needs-interface; -RequireReady forces the selected interface to be known before the bundle passes. scripts/run-native-live-evidence-bundle.ps1 is the guarded consumer for a checked bundle. By default it dry-runs only: it invokes the bundle checker, validates the structured plan commands[].args including adapter, writes guarded-live-run-summary.json, and does not execute live I/O. Live execution requires -AllowLiveExecution plus -ConfirmInterfaceName exactly matching the ready bundle's selected interface; the script still refuses placeholders, unready bundles, unlisted live interfaces, and arbitrary command text. scripts/check-native-live-evidence-guarded-run.ps1 validates that guarded summary after the run: it checks the guarded schema/status/mode, adapter, bundle summary SHA256, logged bundle checker stdout/stderr hashes, planned/live command records, no-live/live policy, refusal reasons, and optional ready/pcap/TShark requirements. scripts/native-readiness-gate.ps1 is the one-command no-live readiness wrapper for these native entry points and accepts -Adapter npcap|raw-socket|auto|both. It runs scripts/native-live-preflight.ps1 with no interface and then runs scripts/check-native-preflight-manifest.ps1 with no-live/environment/UDP policy plus the selected adapter's discovery and no-live dry-run policies, writing a manifest, runner/checker logs, and readiness-summary.json under the selected output directory. scripts/native-live-evidence-plan.ps1 consumes that readiness summary and the selected adapter discovery stdout to write live-evidence-plan.json plus live-evidence-plan.commands.txt; it does not execute live I/O, and if no -InterfaceName is supplied it leaves <NPF_INTERFACE_NAME> for Npcap or <RAW_SOCKET_INTERFACE_NAME> for raw-socket and marks the plan as needs-interface. raw-socket pcap/TShark checks are only planned for send-capture roundtrip because there is no standalone raw-socket capture-only pcap artifact route. scripts/check-native-live-evidence-plan.ps1 validates that plan before anyone copies the commands: it checks adapter, the readiness/manifest/discovery/command-text SHA256 values, the selected interface state, the runner/checker command arguments, adapter-specific placeholder policy, and optional ready/pcap/TShark policies. scripts/native-live-preflight.ps1 remains the manual runner matrix. With -PlanOnly it only prints the command plan. On native target it first runs udp-loopback-smoke --timeout-ms N as a local may_open_nic=false socket smoke and records it in the manifest as udp_loopback_smoke_included=true; non-native targets skip that native-only command. Without an interface it then runs interface discovery and no-live dry-run commands for the selected adapter. With -InterfaceName plus -AllowSend and/or -AllowCapture, it invokes the matching Npcap/raw-socket manual commands and marks each planned command with may_open_nic=true/false. Non-plan runs also write _build\lockwire-live-preflight\preflight-manifest.json plus per-command stdout/stderr logs under _build\lockwire-live-preflight\logs\; -ManifestPath can override the manifest location. The manifest includes an environment snapshot with workspace root, OS, PowerShell, git commit/status hash, and MoonBit version so real-NIC evidence packages can be traced back to the exact local tool state. scripts/check-native-preflight-manifest.ps1 validates that manifest, its command counts, log file bytes, log SHA256 values, optional no-live/live-attempt policy (-RequireNoLiveAttempt or -RequireLiveAttempt), optional native UDP loopback policy (-RequireUdpLoopbackSmoke), optional native Npcap interface discovery policy (-RequireNpcapInterfaceDiscovery -MinNpcapInterfaceCount N), optional Npcap no-live dry-run safety policy (-RequireNpcapNoLiveDryRuns), optional native raw-socket interface discovery policy (-RequireRawSocketInterfaceDiscovery -MinRawSocketInterfaceCount N), optional raw-socket no-live dry-run safety policy (-RequireRawSocketNoLiveDryRuns), optional environment snapshot policy (-RequireEnvironmentSnapshot), optional live evidence stdout field policy (-RequireLiveEvidenceFields), optional built-in pcap checker gate (-RequirePcapArtifactChecks), and optional TShark checker gate (-RequirePcapTSharkChecks). The Npcap discovery policy requires the logged npcap interface discovery command to be native, executed, passed, may_open_nic=false, backed by npcap-list-ifaces, and to report runtime_available=true, listing_supported=true, live_capture_evidence=false, label=native.npcap.interface-list, and a minimum interface count. The Npcap no-live dry-run policy requires the send, roundtrip, and capture-artifact dry-run commands to be present, executed, passed, may_open_nic=false, missing live --iface/--allow-* flags, and to report attempted_open=false plus false send/capture/artifact evidence tokens. The raw-socket discovery policy requires raw socket interface discovery to be native, executed, passed, may_open_nic=false, backed by raw-socket-list-ifaces, and to report surface_implemented=, listing_supported=, live_capture_evidence=false, label=native.raw-socket.interface-list, and a minimum interface count; the default raw-socket minimum is 0 so Windows unsupported fallback can still produce a checked no-live plan. The raw-socket no-live dry-run policy requires raw socket dry-run without interface or allow flags to be present, executed, passed, may_open_nic=false, missing live --iface/--allow-* flags, and to report false send/capture/roundtrip evidence tokens. scripts/check-native-pcap-artifact.ps1 validates classic pcap artifacts from npcap-roundtrip-pcap, npcap-capture-pcap, and raw-socket-roundtrip-pcap, including magic/version/linktype, packet record bounds, minimum packet count, optional EtherType match, and artifact SHA256. scripts/check-native-pcap-tshark.ps1 validates the same artifact through an external Wireshark/TShark parser and reports frame count, EtherType matches, TShark version, pcap SHA256, and field-output SHA256. Passing -CheckPcapArtifacts to the preflight runner appends the built-in pcap checks as non-NIC-opening logged commands after pcap-producing Npcap/raw-socket commands; passing -CheckPcapWithTShark appends the TShark checks the same way, so both checker stdout/stderr/hash records can be captured in the same manifest. The scripts preserve the underlying CLI evidence fields; a successful UDP loopback, Npcap/raw-socket discovery, no-live dry-run, live evidence session, session check, handoff plan, handoff check, handoff run, target handoff plan, target handoff check, live evidence bundle, bundle check, guarded bundle run, guarded run check, live evidence plan, plan check, run, manifest, pcap artifact, checker result, environment snapshot, stdout evidence-field check, or TShark parse is not by itself permissions, device interoperability, or certification evidence.

The OS/HAL capability packages are descriptor-only gates. os_capability_report() and hal_capability_report() prove that sim-wasm forbids C FFI/raw NIC/IRQ/DMA/live I/O, while native-real, real-linux, and real-embedded declare the missing real backends as explicit capabilities. threadx_hal_skeleton_report() adds a stricter embedded skeleton check for BSP hooks, package trimming, deferred ThreadX/NetX calls, and missing board/build evidence. These reports do not implement epoll/IOCP/ThreadX, DMA, raw sockets, or embedded drivers.

The reactor package follows the same descriptor-only boundary. reactor_backend_catalog() records the planned reactor_sim, reactor_epoll, reactor_iocp, and reactor_threadx backends with deterministic/live/profile gates, so future engineering run plans can reference them without pulling in real event-loop dependencies. reactor_sim is deterministic and sim-wasm safe; epoll, IOCP, and ThreadX are marked real-only/live runtime entries. This does not implement fd readiness, async timers, cancellation, cleanup, ThreadX events, or jitter/latency evidence.

The benchmark report path is deterministic and offline. RuntimeBenchmarkReport exposes events/run, portable trace-bytes/run, and declared copy/frame, while events/s, trace-throughput, and alloc/event are explicit unsupported metrics until a backend supplies wall-clock and allocation counters. The P2P native/wasm comparison uses portable trace size and digest, not backend-labelled golden text, and does not claim hard real-time or real NIC performance.

#
AnyResult

source

#
ArbitratedBusErrorState

source

#
ArbitratedBusEventKind

source

#
ArbitratedBusFrame

source

#
ArbitratedBusFrameSlot

source

#
ArbitratedBusMedium

source

#
ArbitratedBusOfflineReport

source

#
ArbitratedBusOfflineRun

source

#
ArbitratedBusProfile

source

#
BackendProfile

source

#
BenchmarkMetric

source

#
BenchmarkMetricStatus

source

#
BenchmarkSample

source

#
BranchLabelCoverage

source

#
BuggifyGate

source

#
CancelReason

source

#
CapabilityProfile

source

#
Channel

source

#
ChannelId

source

#
ClockRelation

source

#
Container

source

#
CrossStamp

source

#
DcDomain

source

#
DiffFingerprint

source

#
DomainCrossStamp

source

#
DomainId

source

#
DomainInstant

source

#
Duration

source

#
EndpointId

source

#
Event

source

#
EventState

source

#
FabricBackgroundFlow

source

#
FabricCapabilities

source

#
FabricDelivery

source

#
FabricLoadClass

source

#
FabricLoadProfile

source

#
FabricLoadProfileRun

source

#
FabricNode

source

#
FabricPartitionScript

source

#
FabricRun

source

#
FaultCampaignCase

source

#
FaultCampaignCoverageReport

source

#
FaultCampaignReport

source

#
FaultHit

source

#
FaultKind

source

#
FaultOutcome

source

#
FaultPlan

source

#
FaultPointCoverage

source

#
FaultReport

source

#
FaultRule

source

#
FaultSchedule

source

#
Frame

source

#
FrameState

source

#
FrameWindow

source

#
HalCapabilityDescriptor

source

#
HalCapabilityKind

source

#
HalCapabilityReport

source

#
Instant

source

#
LinkDriverKind

source

#
LinkDriverMergeReport

source

#
LinkDriverRuntime

source

#
LinkDriverSource

source

#
LinkDriverSpec

source

#
LinkMasterHarnessDescriptor

source

#
LinkMasterHarnessValidationReport

source

#
LinkReadinessMatrixReport

source

#
LinkReadinessTarget

source

#
LinkReadinessTargetKind

source

#
MetricPoint

source

#
MinimalFabric

source

#
MvpStage

source

#
NativeFramePool

source

#
NativeFramePoolSmokeReport

source

#
NativeFrameRef

source

#
NativeFrameSlotState

source

#
NativeLinkError

source

#
NativeLinkSessionCatalogReport

source

#
NativeLinkSessionConfig

source

#
NativeLinkSessionDescriptor

source

#
NativeLinkSessionFramePoolSmokeReport

source

#
NativeLinkSessionKind

source

#
NativeLinkStubReport

source

#
NativeNpcapCapturePcapArtifactReport

source

#
NativeNpcapFramePoolCaptureReport

source

#
NativeNpcapInterfaceInfo

source

#
NativeNpcapInterfaceListReport

source

#
NativeNpcapLinkSession

source

#
NativeNpcapLiveAdapter

source

#
NativeNpcapLiveAdapterReport

source

#
NativeNpcapManualLiveSmokeReport

source

#
NativeNpcapManualSendSmokeReport

source

#
NativeNpcapProbeReport

source

#
NativeNpcapRoundtripPcapArtifactReport

source

#
NativeNpcapSendCaptureRoundtripReport

source

#
NativePcapWriter

source

#
NativeRawSocketAdapter

source

#
NativeRawSocketAdapterReport

source

#
NativeRawSocketInterfaceInfo

source

#
NativeRawSocketInterfaceListReport

source

#
NativeRawSocketLinkSession

source

#
NativeRawSocketManualSmokeReport

source

#
NativeRawSocketRoundtripPcapArtifactReport

source

#
NativeStubFallbackBehavior

source

#
NativeStubLiveBoundary

source

#
NativeStubModuleDescriptor

source

#
NativeStubModuleReport

source

#
NativeStubTargetGate

source

#
NativeUdpLinkSession

source

#
NativeUdpLinkSessionSmokeReport

source

#
NativeUdpLoopbackSmokeReport

source

#
NativeUdpSocket

source

#
OsCapabilityDescriptor

source

#
OsCapabilityKind

source

#
OsCapabilityReport

source

#
PortGroup

source

#
PortId

source

#
PreemptiveResource

source

#
PreemptiveResourceEvent

source

#
PreemptiveResourceEventKind

source

#
PreemptiveResourceReport

source

#
PriorityResource

source

#
PriorityResourceLease

source

#
PriorityResourceRequest

source

#
ProcessHandle

source

#
ProfinetRtLoadTraceReport

source

#
ReactorBackendDescriptor

source

#
ReactorBackendKind

source

#
ReactorBackendReport

source

#
ReactorBoundary

source

#
Recording

source

#
Replay

source

#
Resource

source

#
ResourceLease

source

#
ResourceSnapshot

source

#
RuntimeBenchmarkReport

source

#
RxEvent

source

#
SeedFailureHistogramBucket

source

#
SegmentHop

source

#
SegmentLine

source

#
SegmentNode

source

#
SegmentRun

source

#
SimDigest

source

#
SimEnv

source

#
SimInstant

source

#
SimRun

source

#
SimTruth

source

#
StepResult

source

#
Store

source

#
SwarmSeedPool

source

#
SwitchedFabricFrameRecord

source

#
SwitchedFabricIrtPhaseKind

source

#
SwitchedFabricIrtPhaseWindow

source

#
SwitchedFabricOfflineProfile

source

#
SwitchedFabricOfflineReport

source

#
SwitchedFabricOfflineRun

source

#
SwitchedFabricPort

source

#
SwitchedFabricQosIrtFrameRecord

source

#
SwitchedFabricQosIrtProfile

source

#
SwitchedFabricQosIrtReport

source

#
SwitchedFabricQosIrtRun

source

#
SwitchedFabricQueueDiscipline

source

#
SwitchedFabricTrafficFlow

source

#
ThreadxEvidenceKind

source

#
ThreadxEvidencePlanReport

source

#
ThreadxEvidenceRequirement

source

#
ThreadxHalHookDescriptor

source

#
ThreadxHalHookKind

source

#
ThreadxHalSkeletonDescriptor

source

#
ThreadxHalSkeletonReport

source

#
TimelineProbe

source

#
Timeout

source

#
TopologyFaultHit

source

#
TopologyFaultKind

source

#
TraceArtifact

source

#
TraceArtifactError

source

#
TraceArtifactFormat

source

#
TraceArtifactSidecar

source

#
TraceDirection

source

#
TraceEvent

source

#
TraceLog

source

#
TransportError

source

#
TxEvent

source

#
Uncertain

source

#
VTime

source

#
VirtualClock

source

#
VirtualCrossStamper

source

#
WallDomain

source

#
all_of

source

#
any_of

source

#
arbitrated_bus_offline_report

source

#
backend_profile_label

source
fn backend_profile_label(profile : 
BackendProfile) -> String

#
backend_profiles

source

#
buggify_swarm_coverage_report_fixture

source

#
buggify_swarm_seed_pool_fixture

source

#
buggify_swarm_trace_fixture

source

#
cancel

source

#
capability_profiles

source

#
check_rx_invariants

source
fn check_rx_invariants(events : ArrayView[
RxEvent]) -> Bool

#
default_buggify_gates

source

#
default_swarm_seed_pool

source

#
deterministic_sequence

source

#
event

source

#
fail

source
fn[T] fail(ev : 
Event[T], message : String) -> Unit

#
fault_campaign_coverage_report

source

#
framework_name

source
let framework_name : String

#
ghost_domain_status

source
fn ghost_domain_status() -> String

#
hal_capability_catalog

source

#
hal_capability_report

source

#
highres_micros

source
fn highres_micros() -> Int64

fn link_readiness_matrix_trace_fixture(seed? : Int) -> 
TraceLog

#
m0_scope

source
fn m0_scope() -> String

#
mvp_stage_label

source
fn mvp_stage_label(stage : 
MvpStage) -> String

#
mvp_stages

source

#
native_frame_pool_smoke

source

#
native_last_error_code

source
fn native_last_error_code() -> Int

#
native_last_error_message

source
fn native_last_error_message() -> String

fn native_link_driver_merge_report(seed? : Int) -> 
LinkDriverMergeReport

fn native_link_driver_trace_fixture(seed? : Int) -> 
TraceLog

#
native_make_ethernet_smoke_frame

source
fn native_make_ethernet_smoke_frame(ethertype? : Int, dst_mac? : Bytes, src_mac? : Bytes, payload? : Bytes) -> Bytes

#
native_npcap_capture_frame_pool

source
fn native_npcap_capture_frame_pool(interface_name : String, allow_capture? : Bool, snaplen? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, filter_expression? : String) -> 
NativeNpcapFramePoolCaptureReport

#
native_npcap_capture_pcap_artifact

source
fn native_npcap_capture_pcap_artifact(interface_name : String, output_path : String, allow_capture? : Bool, snaplen? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, filter_expression? : String) -> 
NativeNpcapCapturePcapArtifactReport

#
native_npcap_interface_list_report

source

#
native_npcap_list_interfaces_text

source
fn native_npcap_list_interfaces_text() -> String

#
native_npcap_live_adapter_report

source

#
native_npcap_make_ethernet_smoke_frame

source
fn native_npcap_make_ethernet_smoke_frame(ethertype? : Int, dst_mac? : Bytes, src_mac? : Bytes, payload? : Bytes) -> Bytes

#
native_npcap_manual_live_smoke

source
fn native_npcap_manual_live_smoke(interface_name : String, snaplen? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, filter_expression? : String) -> 
NativeNpcapManualLiveSmokeReport

#
native_npcap_manual_send_smoke

source
fn native_npcap_manual_send_smoke(interface_name : String, allow_send? : Bool, snaplen? : Int, promiscuous? : Bool, open_timeout_ms? : Int, frame? : Bytes) -> 
NativeNpcapManualSendSmokeReport

#
native_npcap_parse_interfaces_text

source

#
native_npcap_roundtrip_pcap_artifact

source
fn native_npcap_roundtrip_pcap_artifact(interface_name : String, output_path : String, allow_send? : Bool, allow_capture? : Bool, capture_attempts? : Int, snaplen? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, filter_expression? : String, frame? : Bytes) -> 
NativeNpcapRoundtripPcapArtifactReport

#
native_npcap_runtime_probe

source

#
native_npcap_send_capture_roundtrip

source
fn native_npcap_send_capture_roundtrip(interface_name : String, allow_send? : Bool, allow_capture? : Bool, capture_attempts? : Int, snaplen? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, filter_expression? : String, frame? : Bytes) -> 
NativeNpcapSendCaptureRoundtripReport

#
native_raw_socket_adapter_report

source

#
native_raw_socket_interface_list_report

source

#
native_raw_socket_list_interfaces_text

source
fn native_raw_socket_list_interfaces_text() -> String

#
native_raw_socket_manual_smoke

source
fn native_raw_socket_manual_smoke(interface_name : String, allow_send? : Bool, allow_capture? : Bool, ethertype? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, capture_attempts? : Int, frame? : Bytes) -> 
NativeRawSocketManualSmokeReport

#
native_raw_socket_parse_interfaces_text

source

#
native_raw_socket_roundtrip_pcap_artifact

source
fn native_raw_socket_roundtrip_pcap_artifact(interface_name : String, output_path : String, allow_send? : Bool, allow_capture? : Bool, capture_attempts? : Int, ethertype? : Int, promiscuous? : Bool, open_timeout_ms? : Int, capture_timeout_ms? : Int, frame? : Bytes) -> 
NativeRawSocketRoundtripPcapArtifactReport

#
native_stub_catalog_c_files

source
fn native_stub_catalog_c_files() -> Array[String]

#
native_stub_catalog_fallback_ffi_files

source
fn native_stub_catalog_fallback_ffi_files() -> Array[String]

#
native_stub_catalog_native_ffi_files

source
fn native_stub_catalog_native_ffi_files() -> Array[String]

#
native_stub_declared_c_files

source
fn native_stub_declared_c_files() -> Array[String]

#
native_stub_declared_fallback_ffi_files

source
fn native_stub_declared_fallback_ffi_files() -> Array[String]

#
native_stub_declared_native_ffi_files

source
fn native_stub_declared_native_ffi_files() -> Array[String]

#
native_stub_module_catalog

source

#
native_stub_module_report

source

#
native_stub_version

source
fn native_stub_version() -> Int

#
native_udp_loopback_smoke

source

#
os_capability_catalog

source

#
os_capability_report

source

#
p2p_benchmark_line

source
fn p2p_benchmark_line(seed~ : Int) -> String

#
p2p_benchmark_report

source

#
p2p_digest_line

source
fn p2p_digest_line(seed~ : Int) -> String

#
p2p_fingerprint

source

#
p2p_native_wasm_benchmark_match

source
fn p2p_native_wasm_benchmark_match(seed~ : Int) -> Bool

#
p2p_native_wasm_match

source
fn p2p_native_wasm_match(seed~ : Int) -> Bool

#
p2p_trace_log

source

#
package_ids

source
fn package_ids() -> Array[String]

#
parse_trace_artifact_text

source

#
parse_trace_log_text

source

#
parse_trace_pcapng

source

#
payload_digest_placeholder

source
fn payload_digest_placeholder(payload : Bytes) -> Int

#
pcapng_custom_block_type

source
fn pcapng_custom_block_type() -> Int

#
pcapng_linktype_ethernet

source
fn pcapng_linktype_ethernet() -> Int

#
preemptive_resource_contention_fixture

source
fn preemptive_resource_contention_fixture(seed? : Int) -> 
PreemptiveResourceReport

#
profinet_rt_load_profile

source
fn profinet_rt_load_profile(seed? : Int) -> 
FabricLoadProfile

#
profinet_rt_load_profile_report

source

#
profinet_rt_load_trace_fixture

source
fn profinet_rt_load_trace_fixture(seed? : Int) -> 
TraceLog

#
project_name

source
let project_name : String

#
provider_master_harness_trace_fixture

source

#
reactor_backend_catalog

source

#
reactor_backend_report

source

#
run_arbitrated_bus_offline

source

#
run_buggify_swarm_seed_pool

source

#
run_fabric_partition_heal

source
fn run_fabric_partition_heal(seed~ : Int) -> 
FabricRun

#
run_p2p_demo

source
fn run_p2p_demo(seed~ : Int) -> 
SimRun

#
run_profinet_rt_load_profile

source
fn run_profinet_rt_load_profile(seed? : Int) -> 
FabricLoadProfileRun

#
run_segment_toy

source
fn run_segment_toy(seed~ : Int) -> 
SegmentRun

#
run_switched_fabric_offline

source

#
run_switched_fabric_qos_irt_offline

source
fn run_switched_fabric_qos_irt_offline(seed? : Int) -> 
SwitchedFabricQosIrtRun

#
rx_event_to_trace

source
fn rx_event_to_trace(ev : 
RxEvent, seed~ : Int, rng_step~ : Int, clock_domain~ : String, node_id~ : String, medium_id~ : String, backend~ : 
BackendProfile) -> 
TraceEvent

#
same_seed_digest_stable

source
fn same_seed_digest_stable(seed~ : Int) -> Bool

#
spawn

source

#
succeed

source
fn[T] succeed(ev : 
Event[T], value : T) -> Unit

#
switched_fabric_offline_profile

source

#
switched_fabric_offline_report

source

#
switched_fabric_qos_irt_profile

source

#
switched_fabric_qos_irt_report

source

#
threadx_evidence_plan_report

source

#
threadx_evidence_requirements

source

#
threadx_hal_hook_catalog

source

#
threadx_hal_skeleton_descriptor

source

#
threadx_hal_skeleton_report

source

#
timeout

source

#
tx_event_precedes

source

#
tx_event_to_trace

source
fn tx_event_to_trace(ev : 
TxEvent, seed~ : Int, rng_step~ : Int, clock_domain~ : String, node_id~ : String, medium_id~ : String, backend~ : 
BackendProfile) -> 
TraceEvent

#
validate_master_harness_descriptors

source

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io