///|
/// Static catalog for the split native C stubs.

///|
pub(all) enum NativeStubTargetGate {
  StubTargetNativeAll
  StubTargetWindowsOnly
  StubTargetLinuxOnly
  StubTargetPosixLike
  StubTargetNonWindowsUnsupported
} derive(Eq, Debug)

///|
pub fn NativeStubTargetGate::label(self : NativeStubTargetGate) -> String {
  match self {
    StubTargetNativeAll => "native-all"
    StubTargetWindowsOnly => "native-windows"
    StubTargetLinuxOnly => "native-linux"
    StubTargetPosixLike => "native-posix-like"
    StubTargetNonWindowsUnsupported => "native-non-windows-unsupported"
  }
}

///|
pub(all) enum NativeStubFallbackBehavior {
  StubFallbackMoonBitOnly
  StubFallbackNativeUnsupportedSymbols
  StubFallbackMoonBitAndNativeUnsupported
} derive(Eq, Debug)

///|
pub fn NativeStubFallbackBehavior::label(
  self : NativeStubFallbackBehavior,
) -> String {
  match self {
    StubFallbackMoonBitOnly => "moonbit-fallback"
    StubFallbackNativeUnsupportedSymbols => "native-unsupported-symbols"
    StubFallbackMoonBitAndNativeUnsupported =>
      "moonbit-fallback+native-unsupported-symbols"
  }
}

///|
pub(all) enum NativeStubLiveBoundary {
  StubNoLiveIo
  StubLocalArtifactOnly
  StubLocalLoopbackOnly
  StubRuntimeProbeOnly
  StubLiveAdapterSurfaceOnly
  StubLocalBufferOnly
  StubUnsupportedOnly
} derive(Eq, Debug)

///|
pub fn NativeStubLiveBoundary::label(self : NativeStubLiveBoundary) -> String {
  match self {
    StubNoLiveIo => "no-live-io"
    StubLocalArtifactOnly => "local-artifact-only"
    StubLocalLoopbackOnly => "local-loopback-only"
    StubRuntimeProbeOnly => "runtime-probe-only"
    StubLiveAdapterSurfaceOnly => "live-adapter-surface-only"
    StubLocalBufferOnly => "local-buffer-only"
    StubUnsupportedOnly => "unsupported-only"
  }
}

///|
pub(all) struct NativeStubModuleDescriptor {
  id : String
  c_files : Array[String]
  support_files : Array[String]
  native_ffi_files : Array[String]
  fallback_ffi_files : Array[String]
  symbol_family : String
  target_gate : NativeStubTargetGate
  fallback_behavior : NativeStubFallbackBehavior
  live_boundary : NativeStubLiveBoundary
  moonbit_fallback_available : Bool
  raw_adapter_implemented : Bool
  live_adapter_implemented : Bool
} derive(Eq, Debug)

///|
pub(all) struct NativeStubCapabilityLedgerEntry {
  c_file : String
  module_id : String
  capability_family : String
  phase : String
  target_gate : NativeStubTargetGate
  live_boundary : NativeStubLiveBoundary
  native_ffi_file : String
  fallback_ffi_file : String
  public_symbols : Array[String]
  ffi_wrappers : Array[String]
  helper_only : Bool
  fallback_mirror_exports : Bool
} derive(Eq, Debug)

///|
pub(all) struct NativeStubModuleReport {
  module_count : Int
  catalog_c_file_count : Int
  moon_pkg_native_stub_file_count : Int
  catalog_native_ffi_file_count : Int
  moon_pkg_native_ffi_file_count : Int
  catalog_fallback_ffi_file_count : Int
  moon_pkg_fallback_ffi_file_count : Int
  missing_from_catalog_count : Int
  extra_in_catalog_count : Int
  missing_native_ffi_from_catalog_count : Int
  extra_native_ffi_in_catalog_count : Int
  missing_fallback_ffi_from_catalog_count : Int
  extra_fallback_ffi_in_catalog_count : Int
  fallback_gap_count : Int
  raw_adapter_count : Int
  live_adapter_count : Int
  runtime_probe_only_count : Int
} derive(Eq, Debug)

///|
pub(all) struct NativeStubCapabilityLedgerReport {
  entry_count : Int
  declared_c_file_count : Int
  missing_from_ledger_count : Int
  extra_in_ledger_count : Int
  helper_only_count : Int
  fallback_mirror_count : Int
  public_symbol_count : Int
  ffi_wrapper_count : Int
  wrapper_mismatch_count : Int
} derive(Eq, Debug)

///|
pub(all) struct NativeStubSourceSymbolFact {
  symbol : String
  file : String
} derive(Eq, Debug)

///|
pub(all) struct NativeStubSourceSymbolPolicyReport {
  expected_owner_count : Int
  actual_owner_count : Int
  missing_owner_count : Int
  extra_owner_count : Int
  duplicate_owner_count : Int
  replaces_file_reading : Bool
  replaces_symbol_extraction : Bool
  live_io_evidence : Bool
} derive(Eq, Debug)

///|
pub fn NativeStubModuleDescriptor::c_file_count(
  self : NativeStubModuleDescriptor,
) -> Int {
  self.c_files.length()
}

///|
pub fn NativeStubModuleDescriptor::respects_no_live_boundary(
  self : NativeStubModuleDescriptor,
) -> Bool {
  !self.raw_adapter_implemented &&
  !self.live_adapter_implemented &&
  self.moonbit_fallback_available
}

///|
pub fn NativeStubModuleDescriptor::respects_declared_boundary(
  self : NativeStubModuleDescriptor,
) -> Bool {
  if !self.moonbit_fallback_available {
    return false
  }
  match self.live_boundary {
    StubLiveAdapterSurfaceOnly =>
      self.raw_adapter_implemented && self.live_adapter_implemented
    _ => !self.raw_adapter_implemented && !self.live_adapter_implemented
  }
}

///|
pub fn NativeStubModuleReport::passes(self : NativeStubModuleReport) -> Bool {
  self.module_count > 0 &&
  self.catalog_c_file_count == self.moon_pkg_native_stub_file_count &&
  self.catalog_native_ffi_file_count == self.moon_pkg_native_ffi_file_count &&
  self.catalog_fallback_ffi_file_count == self.moon_pkg_fallback_ffi_file_count &&
  self.missing_from_catalog_count == 0 &&
  self.extra_in_catalog_count == 0 &&
  self.missing_native_ffi_from_catalog_count == 0 &&
  self.extra_native_ffi_in_catalog_count == 0 &&
  self.missing_fallback_ffi_from_catalog_count == 0 &&
  self.extra_fallback_ffi_in_catalog_count == 0 &&
  self.fallback_gap_count == 0 &&
  self.raw_adapter_count == 9 &&
  self.live_adapter_count == 9
}

///|
pub fn NativeStubCapabilityLedgerReport::passes(
  self : NativeStubCapabilityLedgerReport,
) -> Bool {
  self.entry_count == self.declared_c_file_count &&
  self.missing_from_ledger_count == 0 &&
  self.extra_in_ledger_count == 0 &&
  self.helper_only_count == 8 &&
  self.fallback_mirror_count == 9 &&
  self.public_symbol_count == self.ffi_wrapper_count &&
  self.wrapper_mismatch_count == 0
}

///|
pub fn NativeStubSourceSymbolPolicyReport::passes(
  self : NativeStubSourceSymbolPolicyReport,
) -> Bool {
  self.expected_owner_count > 0 &&
  self.actual_owner_count == self.expected_owner_count &&
  self.missing_owner_count == 0 &&
  self.extra_owner_count == 0 &&
  self.duplicate_owner_count == 0 &&
  !self.replaces_file_reading &&
  !self.replaces_symbol_extraction &&
  !self.live_io_evidence
}

///|
pub fn native_stub_expected_source_symbol_facts() -> Array[
  NativeStubSourceSymbolFact,
] {
  let facts : Array[NativeStubSourceSymbolFact] = []
  for entry in native_stub_capability_ledger() {
    for symbol in entry.public_symbols {
      facts.push({ symbol, file: entry.c_file })
    }
  }
  facts
}

///|
pub fn native_stub_source_symbol_policy_report(
  actual : Array[NativeStubSourceSymbolFact],
) -> NativeStubSourceSymbolPolicyReport {
  native_stub_source_symbol_policy_report_from_expected(
    native_stub_expected_source_symbol_facts(),
    actual,
  )
}

///|
pub fn native_stub_source_symbol_policy_report_from_expected(
  expected : Array[NativeStubSourceSymbolFact],
  actual : Array[NativeStubSourceSymbolFact],
) -> NativeStubSourceSymbolPolicyReport {
  {
    expected_owner_count: expected.length(),
    actual_owner_count: actual.length(),
    missing_owner_count: count_missing_source_symbol_facts(expected, actual),
    extra_owner_count: count_missing_source_symbol_facts(actual, expected),
    duplicate_owner_count: count_duplicate_source_symbol_facts(actual),
    replaces_file_reading: false,
    replaces_symbol_extraction: false,
    live_io_evidence: false,
  }
}

///|
pub fn native_stub_declared_c_files() -> Array[String] {
  [
    "stub_common_status.c", "stub_common_handle.c", "stub_common_bytes.c", "stub_clock_windows.c",
    "stub_clock_posix.c", "stub_clock_unsupported.c", "stub_pcap_common.c", "stub_pcap_writer.c",
    "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", "stub_npcap_unsupported.c", "stub_raw_socket_linux_common.c",
    "stub_raw_socket_linux_adapter.c", "stub_raw_socket_linux_send.c", "stub_raw_socket_linux_capture.c",
    "stub_raw_socket_linux_list.c", "stub_raw_socket_unsupported.c", "stub_frame_pool_common.c",
    "stub_frame_pool_lifecycle.c", "stub_frame_pool_state.c", "stub_frame_pool_io.c",
    "stub_udp_windows_common.c", "stub_udp_windows_adapter.c", "stub_udp_windows_send.c",
    "stub_udp_windows_recv.c", "stub_udp_posix_common.c", "stub_udp_posix_adapter.c",
    "stub_udp_posix_send.c", "stub_udp_posix_recv.c", "stub_udp_unsupported.c", "stub_clock_millis_windows.c",
    "stub_clock_millis_posix.c", "stub_clock_millis_unsupported.c", "stub_sleep_windows.c",
    "stub_sleep_posix.c", "stub_sleep_unsupported.c", "stub_rt_affinity_windows.c",
    "stub_rt_affinity_unsupported.c", "stub_npcap_windows_local_mac.c", "stub_npcap_windows_nonblock.c",
    "stub_npcap_unsupported_live_ext.c", "stub_raw_socket_linux_local_mac.c", "stub_raw_socket_linux_nonblock.c",
    "stub_raw_socket_unsupported_live_ext.c",
  ]
}

///|
pub fn native_stub_declared_native_ffi_files() -> Array[String] {
  [
    "ffi_common_native.mbt", "ffi_clock_native.mbt", "ffi_pcap_native.mbt", "ffi_npcap_native.mbt",
    "ffi_raw_socket_native.mbt", "ffi_udp_native.mbt", "ffi_frame_pool_native.mbt",
    "ffi_rt_affinity_native.mbt",
  ]
}

///|
pub fn native_stub_declared_fallback_ffi_files() -> Array[String] {
  [
    "ffi_common_fallback.mbt", "ffi_clock_fallback.mbt", "ffi_pcap_fallback.mbt",
    "ffi_npcap_fallback.mbt", "ffi_raw_socket_fallback.mbt", "ffi_udp_fallback.mbt",
    "ffi_frame_pool_fallback.mbt", "ffi_rt_affinity_fallback.mbt",
  ]
}

///|
pub fn native_stub_capability_ledger() -> Array[NativeStubCapabilityLedgerEntry] {
  [
    {
      c_file: "stub_common_status.c",
      module_id: "native.stub.common",
      capability_family: "common-status",
      phase: "phase0-common",
      target_gate: StubTargetNativeAll,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_common_native.mbt",
      fallback_ffi_file: "ffi_common_fallback.mbt",
      public_symbols: [
        "lockwire_native_stub_version", "lockwire_native_last_error_code", "lockwire_native_last_error_message",
      ],
      ffi_wrappers: [
        "ffi_stub_version", "ffi_last_error_code", "ffi_last_error_message",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_common_handle.c",
      module_id: "native.stub.common",
      capability_family: "common-handle",
      phase: "phase0-common",
      target_gate: StubTargetNativeAll,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_common_native.mbt",
      fallback_ffi_file: "ffi_common_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_common_bytes.c",
      module_id: "native.stub.common",
      capability_family: "common-bytes",
      phase: "phase0-common",
      target_gate: StubTargetNativeAll,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_common_native.mbt",
      fallback_ffi_file: "ffi_common_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_clock_windows.c",
      module_id: "native.stub.clock",
      capability_family: "clock-windows",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_highres_micros"],
      ffi_wrappers: ["ffi_highres_micros"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_clock_posix.c",
      module_id: "native.stub.clock",
      capability_family: "clock-posix",
      phase: "phase1-platform",
      target_gate: StubTargetPosixLike,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_highres_micros"],
      ffi_wrappers: ["ffi_highres_micros"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_clock_unsupported.c",
      module_id: "native.stub.clock",
      capability_family: "clock-unsupported",
      phase: "phase1-platform",
      target_gate: StubTargetNativeAll,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_highres_micros"],
      ffi_wrappers: ["ffi_highres_micros"],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_pcap_common.c",
      module_id: "native.stub.pcap_writer",
      capability_family: "pcap-common",
      phase: "phase2-artifact",
      target_gate: StubTargetNativeAll,
      live_boundary: StubLocalArtifactOnly,
      native_ffi_file: "ffi_pcap_native.mbt",
      fallback_ffi_file: "ffi_pcap_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_pcap_writer.c",
      module_id: "native.stub.pcap_writer",
      capability_family: "pcap",
      phase: "phase2-artifact",
      target_gate: StubTargetNativeAll,
      live_boundary: StubLocalArtifactOnly,
      native_ffi_file: "ffi_pcap_native.mbt",
      fallback_ffi_file: "ffi_pcap_fallback.mbt",
      public_symbols: [
        "lockwire_native_pcap_open", "lockwire_native_pcap_write_packet", "lockwire_native_pcap_write_packet_at",
        "lockwire_native_pcap_close",
      ],
      ffi_wrappers: [
        "ffi_pcap_open", "ffi_pcap_write_packet", "ffi_pcap_write_packet_at", "ffi_pcap_close",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_loader.c",
      module_id: "native.stub.npcap_windows_loader",
      capability_family: "loader",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubRuntimeProbeOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: [
        "lockwire_native_npcap_probe_implemented", "lockwire_native_npcap_runtime_available",
      ],
      ffi_wrappers: [
        "ffi_npcap_probe_implemented", "ffi_npcap_runtime_available",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_listing.c",
      module_id: "native.stub.npcap_windows_listing",
      capability_family: "listing",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubRuntimeProbeOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: ["lockwire_native_npcap_list_interfaces_text"],
      ffi_wrappers: ["ffi_npcap_list_interfaces_text"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_common.c",
      module_id: "native.stub.npcap_windows_common",
      capability_family: "common",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_live.c",
      module_id: "native.stub.npcap_windows_live",
      capability_family: "session",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: [
        "lockwire_native_npcap_live_adapter_implemented", "lockwire_native_npcap_open_live",
        "lockwire_native_npcap_close_live",
      ],
      ffi_wrappers: [
        "ffi_npcap_live_adapter_implemented", "ffi_npcap_open_live", "ffi_npcap_close_live",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_live_send.c",
      module_id: "native.stub.npcap_windows_live_send",
      capability_family: "send",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: ["lockwire_native_npcap_send_packet"],
      ffi_wrappers: ["ffi_npcap_send_packet"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_live_filter.c",
      module_id: "native.stub.npcap_windows_live_filter",
      capability_family: "filter",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: ["lockwire_native_npcap_set_filter"],
      ffi_wrappers: ["ffi_npcap_set_filter"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_live_capture.c",
      module_id: "native.stub.npcap_windows_live_capture",
      capability_family: "capture",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: ["lockwire_native_npcap_capture_one"],
      ffi_wrappers: ["ffi_npcap_capture_one"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_unsupported.c",
      module_id: "native.stub.npcap_unsupported",
      capability_family: "fallback",
      phase: "phase3-fallback",
      target_gate: StubTargetNonWindowsUnsupported,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: [
        "lockwire_native_npcap_probe_implemented", "lockwire_native_npcap_runtime_available",
        "lockwire_native_npcap_list_interfaces_text", "lockwire_native_npcap_live_adapter_implemented",
        "lockwire_native_npcap_open_live", "lockwire_native_npcap_send_packet", "lockwire_native_npcap_set_filter",
        "lockwire_native_npcap_capture_one", "lockwire_native_npcap_close_live",
      ],
      ffi_wrappers: [
        "ffi_npcap_probe_implemented", "ffi_npcap_runtime_available", "ffi_npcap_list_interfaces_text",
        "ffi_npcap_live_adapter_implemented", "ffi_npcap_open_live", "ffi_npcap_send_packet",
        "ffi_npcap_set_filter", "ffi_npcap_capture_one", "ffi_npcap_close_live",
      ],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_raw_socket_linux_common.c",
      module_id: "native.stub.raw_socket_linux",
      capability_family: "common",
      phase: "phase1-platform",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_linux_adapter.c",
      module_id: "native.stub.raw_socket_linux",
      capability_family: "adapter",
      phase: "phase2-execution",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: [
        "lockwire_native_raw_socket_adapter_implemented", "lockwire_native_raw_socket_open",
        "lockwire_native_raw_socket_close",
      ],
      ffi_wrappers: [
        "ffi_raw_socket_adapter_implemented", "ffi_raw_socket_open", "ffi_raw_socket_close",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_linux_send.c",
      module_id: "native.stub.raw_socket_linux",
      capability_family: "send",
      phase: "phase2-execution",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: ["lockwire_native_raw_socket_send_packet"],
      ffi_wrappers: ["ffi_raw_socket_send_packet"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_linux_capture.c",
      module_id: "native.stub.raw_socket_linux",
      capability_family: "capture",
      phase: "phase2-execution",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: ["lockwire_native_raw_socket_capture_one"],
      ffi_wrappers: ["ffi_raw_socket_capture_one"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_linux_list.c",
      module_id: "native.stub.raw_socket_linux",
      capability_family: "listing",
      phase: "phase2-execution",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: ["lockwire_native_raw_socket_list_interfaces_text"],
      ffi_wrappers: ["ffi_raw_socket_list_interfaces_text"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_unsupported.c",
      module_id: "native.stub.raw_socket_linux",
      capability_family: "fallback",
      phase: "phase3-fallback",
      target_gate: StubTargetNonWindowsUnsupported,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: [
        "lockwire_native_raw_socket_adapter_implemented", "lockwire_native_raw_socket_list_interfaces_text",
        "lockwire_native_raw_socket_open", "lockwire_native_raw_socket_send_packet",
        "lockwire_native_raw_socket_capture_one", "lockwire_native_raw_socket_close",
      ],
      ffi_wrappers: [
        "ffi_raw_socket_adapter_implemented", "ffi_raw_socket_list_interfaces_text",
        "ffi_raw_socket_open", "ffi_raw_socket_send_packet", "ffi_raw_socket_capture_one",
        "ffi_raw_socket_close",
      ],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_frame_pool_common.c",
      module_id: "native.stub.frame_pool",
      capability_family: "frame-pool-common",
      phase: "phase1-buffer",
      target_gate: StubTargetNativeAll,
      live_boundary: StubLocalBufferOnly,
      native_ffi_file: "ffi_frame_pool_native.mbt",
      fallback_ffi_file: "ffi_frame_pool_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_frame_pool_lifecycle.c",
      module_id: "native.stub.frame_pool",
      capability_family: "frame-pool-lifecycle",
      phase: "phase2-buffer",
      target_gate: StubTargetNativeAll,
      live_boundary: StubLocalBufferOnly,
      native_ffi_file: "ffi_frame_pool_native.mbt",
      fallback_ffi_file: "ffi_frame_pool_fallback.mbt",
      public_symbols: [
        "lockwire_native_frame_pool_create", "lockwire_native_frame_pool_destroy",
        "lockwire_native_frame_pool_acquire", "lockwire_native_frame_pool_acquire_rx",
        "lockwire_native_frame_pool_release",
      ],
      ffi_wrappers: [
        "ffi_frame_pool_create", "ffi_frame_pool_destroy", "ffi_frame_pool_acquire",
        "ffi_frame_pool_acquire_rx", "ffi_frame_pool_release",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_frame_pool_state.c",
      module_id: "native.stub.frame_pool",
      capability_family: "frame-pool-state",
      phase: "phase2-buffer",
      target_gate: StubTargetNativeAll,
      live_boundary: StubLocalBufferOnly,
      native_ffi_file: "ffi_frame_pool_native.mbt",
      fallback_ffi_file: "ffi_frame_pool_fallback.mbt",
      public_symbols: [
        "lockwire_native_frame_pool_mark_filled", "lockwire_native_frame_pool_mark_sending",
        "lockwire_native_frame_pool_mark_sent", "lockwire_native_frame_pool_mark_received",
        "lockwire_native_frame_pool_free_count", "lockwire_native_frame_pool_slot_state",
        "lockwire_native_frame_pool_slot_length",
      ],
      ffi_wrappers: [
        "ffi_frame_pool_mark_filled", "ffi_frame_pool_mark_sending", "ffi_frame_pool_mark_sent",
        "ffi_frame_pool_mark_received", "ffi_frame_pool_free_count", "ffi_frame_pool_slot_state",
        "ffi_frame_pool_slot_length",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_frame_pool_io.c",
      module_id: "native.stub.frame_pool",
      capability_family: "frame-pool-io",
      phase: "phase2-buffer",
      target_gate: StubTargetNativeAll,
      live_boundary: StubLocalBufferOnly,
      native_ffi_file: "ffi_frame_pool_native.mbt",
      fallback_ffi_file: "ffi_frame_pool_fallback.mbt",
      public_symbols: [
        "lockwire_native_frame_pool_write", "lockwire_native_frame_pool_read_into",
        "lockwire_native_frame_pool_copy",
      ],
      ffi_wrappers: [
        "ffi_frame_pool_write", "ffi_frame_pool_read_into", "ffi_frame_pool_copy",
      ],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_windows_common.c",
      module_id: "native.stub.udp_windows_common",
      capability_family: "common",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_windows_adapter.c",
      module_id: "native.stub.udp_windows_adapter",
      capability_family: "adapter",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: [
        "lockwire_native_udp_open", "lockwire_native_udp_bound_port", "lockwire_native_udp_close",
      ],
      ffi_wrappers: ["ffi_udp_open", "ffi_udp_bound_port", "ffi_udp_close"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_windows_send.c",
      module_id: "native.stub.udp_windows_send",
      capability_family: "send",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: ["lockwire_native_udp_sendto"],
      ffi_wrappers: ["ffi_udp_send_to"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_windows_recv.c",
      module_id: "native.stub.udp_windows_receive",
      capability_family: "receive",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: ["lockwire_native_udp_receive"],
      ffi_wrappers: ["ffi_udp_receive"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_posix_common.c",
      module_id: "native.stub.udp_posix_common",
      capability_family: "common",
      phase: "phase1-platform",
      target_gate: StubTargetPosixLike,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: [],
      ffi_wrappers: [],
      helper_only: true,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_posix_adapter.c",
      module_id: "native.stub.udp_posix_adapter",
      capability_family: "adapter",
      phase: "phase2-execution",
      target_gate: StubTargetPosixLike,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: [
        "lockwire_native_udp_open", "lockwire_native_udp_bound_port", "lockwire_native_udp_close",
      ],
      ffi_wrappers: ["ffi_udp_open", "ffi_udp_bound_port", "ffi_udp_close"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_posix_send.c",
      module_id: "native.stub.udp_posix_send",
      capability_family: "send",
      phase: "phase2-execution",
      target_gate: StubTargetPosixLike,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: ["lockwire_native_udp_sendto"],
      ffi_wrappers: ["ffi_udp_send_to"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_posix_recv.c",
      module_id: "native.stub.udp_posix_receive",
      capability_family: "receive",
      phase: "phase2-execution",
      target_gate: StubTargetPosixLike,
      live_boundary: StubLocalLoopbackOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: ["lockwire_native_udp_receive"],
      ffi_wrappers: ["ffi_udp_receive"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_udp_unsupported.c",
      module_id: "native.stub.udp_unsupported",
      capability_family: "fallback",
      phase: "phase3-fallback",
      target_gate: StubTargetNonWindowsUnsupported,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_udp_native.mbt",
      fallback_ffi_file: "ffi_udp_fallback.mbt",
      public_symbols: [
        "lockwire_native_udp_open", "lockwire_native_udp_bound_port", "lockwire_native_udp_sendto",
        "lockwire_native_udp_receive", "lockwire_native_udp_close",
      ],
      ffi_wrappers: [
        "ffi_udp_open", "ffi_udp_bound_port", "ffi_udp_send_to", "ffi_udp_receive",
        "ffi_udp_close",
      ],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_clock_millis_windows.c",
      module_id: "native.stub.clock_millis",
      capability_family: "clock-millis",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_monotonic_millis"],
      ffi_wrappers: ["ffi_monotonic_millis"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_clock_millis_posix.c",
      module_id: "native.stub.clock_millis",
      capability_family: "clock-millis",
      phase: "phase1-platform",
      target_gate: StubTargetPosixLike,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_monotonic_millis"],
      ffi_wrappers: ["ffi_monotonic_millis"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_clock_millis_unsupported.c",
      module_id: "native.stub.clock_millis",
      capability_family: "clock-millis",
      phase: "phase3-fallback",
      target_gate: StubTargetNativeAll,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_monotonic_millis"],
      ffi_wrappers: ["ffi_monotonic_millis"],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_sleep_windows.c",
      module_id: "native.stub.sleep",
      capability_family: "clock-sleep",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_sleep_until_micros"],
      ffi_wrappers: ["ffi_sleep_until_micros"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_sleep_posix.c",
      module_id: "native.stub.sleep",
      capability_family: "clock-sleep",
      phase: "phase1-platform",
      target_gate: StubTargetPosixLike,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_sleep_until_micros"],
      ffi_wrappers: ["ffi_sleep_until_micros"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_sleep_unsupported.c",
      module_id: "native.stub.sleep",
      capability_family: "clock-sleep",
      phase: "phase3-fallback",
      target_gate: StubTargetNativeAll,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_clock_native.mbt",
      fallback_ffi_file: "ffi_clock_fallback.mbt",
      public_symbols: ["lockwire_native_sleep_until_micros"],
      ffi_wrappers: ["ffi_sleep_until_micros"],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_rt_affinity_windows.c",
      module_id: "native.stub.rt_affinity",
      capability_family: "rt-affinity",
      phase: "phase1-platform",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubNoLiveIo,
      native_ffi_file: "ffi_rt_affinity_native.mbt",
      fallback_ffi_file: "ffi_rt_affinity_fallback.mbt",
      public_symbols: [
        "lockwire_native_win_rt_set_affinity", "lockwire_native_win_rt_supported",
      ],
      ffi_wrappers: ["ffi_win_rt_set_affinity", "ffi_win_rt_supported"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_rt_affinity_unsupported.c",
      module_id: "native.stub.rt_affinity",
      capability_family: "rt-affinity",
      phase: "phase3-fallback",
      target_gate: StubTargetNativeAll,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_rt_affinity_native.mbt",
      fallback_ffi_file: "ffi_rt_affinity_fallback.mbt",
      public_symbols: [
        "lockwire_native_win_rt_set_affinity", "lockwire_native_win_rt_supported",
      ],
      ffi_wrappers: ["ffi_win_rt_set_affinity", "ffi_win_rt_supported"],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_npcap_windows_local_mac.c",
      module_id: "native.stub.npcap_windows_local_mac",
      capability_family: "local-mac",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: ["lockwire_native_npcap_local_mac"],
      ffi_wrappers: ["ffi_npcap_local_mac"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_windows_nonblock.c",
      module_id: "native.stub.npcap_windows_nonblock",
      capability_family: "nonblock",
      phase: "phase2-execution",
      target_gate: StubTargetWindowsOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: ["lockwire_native_npcap_set_nonblock"],
      ffi_wrappers: ["ffi_npcap_set_nonblock"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_npcap_unsupported_live_ext.c",
      module_id: "native.stub.npcap_live_ext_unsupported",
      capability_family: "fallback",
      phase: "phase3-fallback",
      target_gate: StubTargetNonWindowsUnsupported,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_npcap_native.mbt",
      fallback_ffi_file: "ffi_npcap_fallback.mbt",
      public_symbols: [
        "lockwire_native_npcap_local_mac", "lockwire_native_npcap_last_capture_micros",
        "lockwire_native_npcap_set_nonblock",
      ],
      ffi_wrappers: [
        "ffi_npcap_local_mac", "ffi_npcap_last_capture_micros", "ffi_npcap_set_nonblock",
      ],
      helper_only: false,
      fallback_mirror_exports: true,
    },
    {
      c_file: "stub_raw_socket_linux_local_mac.c",
      module_id: "native.stub.raw_socket_linux_local_mac",
      capability_family: "local-mac",
      phase: "phase2-execution",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: ["lockwire_native_raw_socket_local_mac"],
      ffi_wrappers: ["ffi_raw_socket_local_mac"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_linux_nonblock.c",
      module_id: "native.stub.raw_socket_linux_nonblock",
      capability_family: "nonblock",
      phase: "phase2-execution",
      target_gate: StubTargetLinuxOnly,
      live_boundary: StubLiveAdapterSurfaceOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: ["lockwire_native_raw_socket_set_nonblock"],
      ffi_wrappers: ["ffi_raw_socket_set_nonblock"],
      helper_only: false,
      fallback_mirror_exports: false,
    },
    {
      c_file: "stub_raw_socket_unsupported_live_ext.c",
      module_id: "native.stub.raw_socket_live_ext_unsupported",
      capability_family: "fallback",
      phase: "phase3-fallback",
      target_gate: StubTargetNonWindowsUnsupported,
      live_boundary: StubUnsupportedOnly,
      native_ffi_file: "ffi_raw_socket_native.mbt",
      fallback_ffi_file: "ffi_raw_socket_fallback.mbt",
      public_symbols: [
        "lockwire_native_raw_socket_local_mac", "lockwire_native_raw_socket_last_capture_micros",
        "lockwire_native_raw_socket_set_nonblock",
      ],
      ffi_wrappers: [
        "ffi_raw_socket_local_mac", "ffi_raw_socket_last_capture_micros", "ffi_raw_socket_set_nonblock",
      ],
      helper_only: false,
      fallback_mirror_exports: true,
    },
  ]
}

///|
pub fn native_stub_module_catalog() -> Array[NativeStubModuleDescriptor] {
  [
    {
      id: "native.stub.common",
      c_files: [
        "stub_common_status.c", "stub_common_handle.c", "stub_common_bytes.c",
      ],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_common_native.mbt"],
      fallback_ffi_files: ["ffi_common_fallback.mbt"],
      symbol_family: "lockwire_native_stub_version/last_error/handle/u16",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubNoLiveIo,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.clock",
      c_files: [
        "stub_clock_windows.c", "stub_clock_posix.c", "stub_clock_unsupported.c",
      ],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_clock_native.mbt"],
      fallback_ffi_files: ["ffi_clock_fallback.mbt"],
      symbol_family: "lockwire_native_highres_micros",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubNoLiveIo,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.pcap_writer",
      c_files: ["stub_pcap_common.c", "stub_pcap_writer.c"],
      support_files: ["stub_common.h", "stub_pcap.h"],
      native_ffi_files: ["ffi_pcap_native.mbt"],
      fallback_ffi_files: ["ffi_pcap_fallback.mbt"],
      symbol_family: "lockwire_native_pcap_*",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubLocalArtifactOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_windows_common",
      c_files: ["stub_udp_windows_common.c"],
      support_files: ["stub_common.h", "stub_udp_windows.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_windows_ensure/fill_sockaddr/handle",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_windows_adapter",
      c_files: ["stub_udp_windows_adapter.c"],
      support_files: ["stub_common.h", "stub_udp_windows.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_open/bound_port/close",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_windows_send",
      c_files: ["stub_udp_windows_send.c"],
      support_files: ["stub_common.h", "stub_udp_windows.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_sendto",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_windows_receive",
      c_files: ["stub_udp_windows_recv.c"],
      support_files: ["stub_common.h", "stub_udp_windows.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_receive",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_posix_common",
      c_files: ["stub_udp_posix_common.c"],
      support_files: ["stub_common.h", "stub_udp_posix.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_posix_fill_sockaddr/handle",
      target_gate: StubTargetPosixLike,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_posix_adapter",
      c_files: ["stub_udp_posix_adapter.c"],
      support_files: ["stub_common.h", "stub_udp_posix.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_open/bound_port/close",
      target_gate: StubTargetPosixLike,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_posix_send",
      c_files: ["stub_udp_posix_send.c"],
      support_files: ["stub_common.h", "stub_udp_posix.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_sendto",
      target_gate: StubTargetPosixLike,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_posix_receive",
      c_files: ["stub_udp_posix_recv.c"],
      support_files: ["stub_common.h", "stub_udp_posix.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_receive",
      target_gate: StubTargetPosixLike,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLocalLoopbackOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.udp_unsupported",
      c_files: ["stub_udp_unsupported.c"],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_udp_native.mbt"],
      fallback_ffi_files: ["ffi_udp_fallback.mbt"],
      symbol_family: "lockwire_native_udp_*",
      target_gate: StubTargetNonWindowsUnsupported,
      fallback_behavior: StubFallbackNativeUnsupportedSymbols,
      live_boundary: StubUnsupportedOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.npcap_windows_loader",
      c_files: ["stub_npcap_windows_loader.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_probe/runtime",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubRuntimeProbeOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.npcap_windows_listing",
      c_files: ["stub_npcap_windows_listing.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_list_interfaces_text",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubRuntimeProbeOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.npcap_windows_common",
      c_files: ["stub_npcap_windows_common.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_live_handle/copy_bytes",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubNoLiveIo,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.npcap_windows_live",
      c_files: ["stub_npcap_windows_live.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_live_adapter_implemented/open_live/close_live/session",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.npcap_windows_live_send",
      c_files: ["stub_npcap_windows_live_send.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_send_packet",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.npcap_windows_live_filter",
      c_files: ["stub_npcap_windows_live_filter.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_set_filter",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.npcap_windows_live_capture",
      c_files: ["stub_npcap_windows_live_capture.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_capture_one",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.npcap_unsupported",
      c_files: ["stub_npcap_unsupported.c"],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_*",
      target_gate: StubTargetNonWindowsUnsupported,
      fallback_behavior: StubFallbackNativeUnsupportedSymbols,
      live_boundary: StubUnsupportedOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.raw_socket_linux",
      c_files: [
        "stub_raw_socket_linux_common.c", "stub_raw_socket_linux_adapter.c", "stub_raw_socket_linux_send.c",
        "stub_raw_socket_linux_capture.c", "stub_raw_socket_linux_list.c", "stub_raw_socket_unsupported.c",
      ],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_raw_socket_native.mbt"],
      fallback_ffi_files: ["ffi_raw_socket_fallback.mbt"],
      symbol_family: "lockwire_native_raw_socket_*",
      target_gate: StubTargetLinuxOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.frame_pool",
      c_files: [
        "stub_frame_pool_common.c", "stub_frame_pool_lifecycle.c", "stub_frame_pool_state.c",
        "stub_frame_pool_io.c",
      ],
      support_files: ["stub_common.h", "stub_frame_pool.h"],
      native_ffi_files: ["ffi_frame_pool_native.mbt"],
      fallback_ffi_files: ["ffi_frame_pool_fallback.mbt"],
      symbol_family: "lockwire_native_frame_pool_*",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubLocalBufferOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.clock_millis",
      c_files: [
        "stub_clock_millis_windows.c", "stub_clock_millis_posix.c", "stub_clock_millis_unsupported.c",
      ],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_clock_native.mbt"],
      fallback_ffi_files: ["ffi_clock_fallback.mbt"],
      symbol_family: "lockwire_native_monotonic_millis",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubNoLiveIo,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.sleep",
      c_files: [
        "stub_sleep_windows.c", "stub_sleep_posix.c", "stub_sleep_unsupported.c",
      ],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_clock_native.mbt"],
      fallback_ffi_files: ["ffi_clock_fallback.mbt"],
      symbol_family: "lockwire_native_sleep_until_micros",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubNoLiveIo,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.rt_affinity",
      c_files: ["stub_rt_affinity_windows.c", "stub_rt_affinity_unsupported.c"],
      support_files: ["stub_common.h"],
      native_ffi_files: ["ffi_rt_affinity_native.mbt"],
      fallback_ffi_files: ["ffi_rt_affinity_fallback.mbt"],
      symbol_family: "lockwire_native_win_rt_*",
      target_gate: StubTargetNativeAll,
      fallback_behavior: StubFallbackMoonBitOnly,
      live_boundary: StubNoLiveIo,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.npcap_windows_local_mac",
      c_files: ["stub_npcap_windows_local_mac.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_local_mac",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.npcap_windows_nonblock",
      c_files: ["stub_npcap_windows_nonblock.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_set_nonblock",
      target_gate: StubTargetWindowsOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.npcap_live_ext_unsupported",
      c_files: ["stub_npcap_unsupported_live_ext.c"],
      support_files: ["stub_common.h", "stub_npcap_windows.h"],
      native_ffi_files: ["ffi_npcap_native.mbt"],
      fallback_ffi_files: ["ffi_npcap_fallback.mbt"],
      symbol_family: "lockwire_native_npcap_live_ext_*",
      target_gate: StubTargetNonWindowsUnsupported,
      fallback_behavior: StubFallbackNativeUnsupportedSymbols,
      live_boundary: StubUnsupportedOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
    {
      id: "native.stub.raw_socket_linux_local_mac",
      c_files: ["stub_raw_socket_linux_local_mac.c"],
      support_files: ["stub_common.h", "stub_raw_socket_linux.h"],
      native_ffi_files: ["ffi_raw_socket_native.mbt"],
      fallback_ffi_files: ["ffi_raw_socket_fallback.mbt"],
      symbol_family: "lockwire_native_raw_socket_local_mac",
      target_gate: StubTargetLinuxOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.raw_socket_linux_nonblock",
      c_files: ["stub_raw_socket_linux_nonblock.c"],
      support_files: ["stub_common.h", "stub_raw_socket_linux.h"],
      native_ffi_files: ["ffi_raw_socket_native.mbt"],
      fallback_ffi_files: ["ffi_raw_socket_fallback.mbt"],
      symbol_family: "lockwire_native_raw_socket_set_nonblock",
      target_gate: StubTargetLinuxOnly,
      fallback_behavior: StubFallbackMoonBitAndNativeUnsupported,
      live_boundary: StubLiveAdapterSurfaceOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: true,
      live_adapter_implemented: true,
    },
    {
      id: "native.stub.raw_socket_live_ext_unsupported",
      c_files: ["stub_raw_socket_unsupported_live_ext.c"],
      support_files: ["stub_common.h", "stub_raw_socket_linux.h"],
      native_ffi_files: ["ffi_raw_socket_native.mbt"],
      fallback_ffi_files: ["ffi_raw_socket_fallback.mbt"],
      symbol_family: "lockwire_native_raw_socket_live_ext_*",
      target_gate: StubTargetNonWindowsUnsupported,
      fallback_behavior: StubFallbackNativeUnsupportedSymbols,
      live_boundary: StubUnsupportedOnly,
      moonbit_fallback_available: true,
      raw_adapter_implemented: false,
      live_adapter_implemented: false,
    },
  ]
}

///|
pub fn native_stub_catalog_native_ffi_files() -> Array[String] {
  let files : Array[String] = []
  for entry in native_stub_module_catalog() {
    for file in entry.native_ffi_files {
      push_unique_string(files, file)
    }
  }
  files
}

///|
pub fn native_stub_catalog_fallback_ffi_files() -> Array[String] {
  let files : Array[String] = []
  for entry in native_stub_module_catalog() {
    for file in entry.fallback_ffi_files {
      push_unique_string(files, file)
    }
  }
  files
}

///|
pub fn native_stub_catalog_c_files() -> Array[String] {
  let files : Array[String] = []
  for entry in native_stub_module_catalog() {
    for file in entry.c_files {
      files.push(file)
    }
  }
  files
}

///|
pub fn native_stub_capability_ledger_c_files() -> Array[String] {
  let files : Array[String] = []
  for entry in native_stub_capability_ledger() {
    files.push(entry.c_file)
  }
  files
}

///|
pub fn native_stub_raw_socket_symbol_roster() -> Array[String] {
  [
    "lockwire_native_raw_socket_adapter_implemented", "lockwire_native_raw_socket_list_interfaces_text",
    "lockwire_native_raw_socket_open", "lockwire_native_raw_socket_send_packet",
    "lockwire_native_raw_socket_capture_one", "lockwire_native_raw_socket_close",
  ]
}

///|
pub fn native_stub_udp_symbol_roster() -> Array[String] {
  [
    "lockwire_native_udp_open", "lockwire_native_udp_bound_port", "lockwire_native_udp_sendto",
    "lockwire_native_udp_receive", "lockwire_native_udp_close",
  ]
}

///|
pub fn native_stub_capability_ledger_report() -> NativeStubCapabilityLedgerReport {
  let declared = native_stub_declared_c_files()
  let ledger = native_stub_capability_ledger()
  let ledger_files = native_stub_capability_ledger_c_files()
  {
    entry_count: ledger.length(),
    declared_c_file_count: declared.length(),
    missing_from_ledger_count: count_missing(declared, ledger_files),
    extra_in_ledger_count: count_missing(ledger_files, declared),
    helper_only_count: count_helper_only_entries(ledger),
    fallback_mirror_count: count_fallback_mirror_entries(ledger),
    public_symbol_count: count_ledger_public_symbols(ledger),
    ffi_wrapper_count: count_ledger_ffi_wrappers(ledger),
    wrapper_mismatch_count: count_wrapper_mismatches(ledger),
  }
}

///|
pub fn native_stub_module_report() -> NativeStubModuleReport {
  let catalog = native_stub_module_catalog()
  let declared = native_stub_declared_c_files()
  let declared_native_ffi = native_stub_declared_native_ffi_files()
  let declared_fallback_ffi = native_stub_declared_fallback_ffi_files()
  let catalog_files = native_stub_catalog_c_files()
  let catalog_native_ffi = native_stub_catalog_native_ffi_files()
  let catalog_fallback_ffi = native_stub_catalog_fallback_ffi_files()
  {
    module_count: catalog.length(),
    catalog_c_file_count: catalog_files.length(),
    moon_pkg_native_stub_file_count: declared.length(),
    catalog_native_ffi_file_count: catalog_native_ffi.length(),
    moon_pkg_native_ffi_file_count: declared_native_ffi.length(),
    catalog_fallback_ffi_file_count: catalog_fallback_ffi.length(),
    moon_pkg_fallback_ffi_file_count: declared_fallback_ffi.length(),
    missing_from_catalog_count: count_missing(declared, catalog_files),
    extra_in_catalog_count: count_missing(catalog_files, declared),
    missing_native_ffi_from_catalog_count: count_missing(
      declared_native_ffi, catalog_native_ffi,
    ),
    extra_native_ffi_in_catalog_count: count_missing(
      catalog_native_ffi, declared_native_ffi,
    ),
    missing_fallback_ffi_from_catalog_count: count_missing(
      declared_fallback_ffi, catalog_fallback_ffi,
    ),
    extra_fallback_ffi_in_catalog_count: count_missing(
      catalog_fallback_ffi, declared_fallback_ffi,
    ),
    fallback_gap_count: count_fallback_gaps(catalog),
    raw_adapter_count: count_raw_adapters(catalog),
    live_adapter_count: count_live_adapters(catalog),
    runtime_probe_only_count: count_runtime_probe_only(catalog),
  }
}

///|
fn push_unique_string(items : Array[String], item : String) -> Unit {
  if !contains_string(items, item) {
    items.push(item)
  }
}

///|
fn count_missing(expected : Array[String], actual : Array[String]) -> Int {
  let mut missing = 0
  for item in expected {
    if !contains_string(actual, item) {
      missing = missing + 1
    }
  }
  missing
}

///|
fn contains_string(items : Array[String], item : String) -> Bool {
  for got in items {
    if got == item {
      return true
    }
  }
  false
}

///|
fn count_fallback_gaps(catalog : Array[NativeStubModuleDescriptor]) -> Int {
  let mut count = 0
  for entry in catalog {
    if !entry.moonbit_fallback_available {
      count = count + 1
    }
  }
  count
}

///|
fn count_helper_only_entries(
  ledger : Array[NativeStubCapabilityLedgerEntry],
) -> Int {
  let mut count = 0
  for entry in ledger {
    if entry.helper_only {
      count = count + 1
    }
  }
  count
}

///|
fn count_fallback_mirror_entries(
  ledger : Array[NativeStubCapabilityLedgerEntry],
) -> Int {
  let mut count = 0
  for entry in ledger {
    if entry.fallback_mirror_exports {
      count = count + 1
    }
  }
  count
}

///|
fn count_ledger_public_symbols(
  ledger : Array[NativeStubCapabilityLedgerEntry],
) -> Int {
  let mut count = 0
  for entry in ledger {
    count = count + entry.public_symbols.length()
  }
  count
}

///|
fn count_ledger_ffi_wrappers(
  ledger : Array[NativeStubCapabilityLedgerEntry],
) -> Int {
  let mut count = 0
  for entry in ledger {
    count = count + entry.ffi_wrappers.length()
  }
  count
}

///|
fn count_wrapper_mismatches(
  ledger : Array[NativeStubCapabilityLedgerEntry],
) -> Int {
  let mut count = 0
  for entry in ledger {
    if entry.helper_only {
      if entry.public_symbols.length() != 0 || entry.ffi_wrappers.length() != 0 {
        count = count + 1
      }
    } else if entry.public_symbols.length() != entry.ffi_wrappers.length() {
      count = count + 1
    }
  }
  count
}

///|
fn count_missing_source_symbol_facts(
  expected : Array[NativeStubSourceSymbolFact],
  actual : Array[NativeStubSourceSymbolFact],
) -> Int {
  let mut count = 0
  for fact in expected {
    if !contains_source_symbol_fact(actual, fact) {
      count += 1
    }
  }
  count
}

///|
fn count_duplicate_source_symbol_facts(
  facts : Array[NativeStubSourceSymbolFact],
) -> Int {
  let unique : Array[NativeStubSourceSymbolFact] = []
  let mut count = 0
  for fact in facts {
    if contains_source_symbol_fact(unique, fact) {
      count += 1
    } else {
      unique.push(fact)
    }
  }
  count
}

///|
fn contains_source_symbol_fact(
  facts : Array[NativeStubSourceSymbolFact],
  fact : NativeStubSourceSymbolFact,
) -> Bool {
  for got in facts {
    if got == fact {
      return true
    }
  }
  false
}

///|
fn count_raw_adapters(catalog : Array[NativeStubModuleDescriptor]) -> Int {
  let mut count = 0
  for entry in catalog {
    if entry.raw_adapter_implemented {
      count = count + 1
    }
  }
  count
}

///|
fn count_live_adapters(catalog : Array[NativeStubModuleDescriptor]) -> Int {
  let mut count = 0
  for entry in catalog {
    if entry.live_adapter_implemented {
      count = count + 1
    }
  }
  count
}

///|
fn count_runtime_probe_only(catalog : Array[NativeStubModuleDescriptor]) -> Int {
  let mut count = 0
  for entry in catalog {
    if entry.live_boundary == StubRuntimeProbeOnly {
      count = count + 1
    }
  }
  count
}