@machinen/runtime 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -207,7 +207,7 @@ interface BootOptions {
      *
      *   - `'<path>'` — caller-managed file. Used as-is (must exist).
      *     Used by `restore()` to attach a tar archive of the bundle's
-     *     CRIU images on `/dev/vdb`; the guest's
+     *     checkpoint images on `/dev/vdb`; the guest's
      *     `/sbin/machinen-restore` untars it and runs `criu restore`.
      *     The runtime synthesizes `cmd: ['/sbin/machinen-restore']` if
      *     no other cmd is given.
@@ -637,10 +637,10 @@ interface RestoreOptions extends Omit<BootOptions, "snapshot" | "image" | "cmd"
      */
     name?: string;
     /**
-     * Opt into CRIU lazy-pages restore — the CRIU image directory is mounted
+     * Opt into CRIU lazy-pages restore — the checkpoint image directory is mounted
      * into the guest read-only via in-VMM virtio-fs and `criu restore
      * --lazy-pages` faults pages on demand (#266). Default false: the runtime
-     * packs the CRIU image into a tar on `/dev/vdb`, the guest's
+     * packs the checkpoint image into a tar on `/dev/vdb`, the guest's
      * `/sbin/machinen-restore` untars it into tmpfs, and CRIU does an eager
      * load.
      *
@@ -654,7 +654,7 @@ interface RestoreOptions extends Omit<BootOptions, "snapshot" | "image" | "cmd"
 /**
  * Restore a microVM from a snapshot bundle produced by
  * `vm.snapshot({ outDir })`. Reads the bundle's `meta.json` to
- * recover the source name, tars the CRIU image directory into a
+ * recover the source name, tars the checkpoint image directory into a
  * temporary archive, then `boot()`s with that archive attached as
  * the scratch block device — the guest's `/sbin/machinen-restore`
  * untars `/dev/vdb` into tmpfs and runs `criu restore` against the
@@ -785,12 +785,12 @@ interface VmHandle {
      * before booting through the normal vmstate restore path.
      *
      * With `MACHINEN_SNAPSHOT_ENGINE=criu`, this keeps the historical
-     * process-tree behavior: CRIU image files live under `<outDir>/img/`,
+     * process-tree behavior: checkpoint image files live under `<outDir>/img/`,
      * `opts.leaveRunning: true` keeps the source alive, and the default
      * destructive CRIU snapshot powers the source off after the dump.
-     * With `MACHINEN_SNAPSHOT_ENGINE=portable`, snapshot currently
-     * refuses with an experimental/unsupported-workload error; the
-     * semantic cross-ISA checkpoint implementation has not landed yet.
+     * With `MACHINEN_SNAPSHOT_ENGINE=portable`, snapshot writes a
+     * legacy portable machine bundle for the removed ping socket route
+     * workload subset and refuses other/unsafe states fail-closed.
      *
      * `mount-lower.sqfs` and `mount-upper.img` are reflinked from the
      * runtime's per-VM materialization (#272), so on APFS / btrfs / xfs
@@ -958,7 +958,7 @@ interface SnapshotResult {
     /** Absolute path to the snapshot bundle directory. */
     snapDir: string;
     /**
-     * Absolute path to the CRIU image directory inside the bundle.
+     * Absolute path to the checkpoint image directory inside the bundle.
      * Set by the criu engine only; undefined for vmstate bundles.
      */
     imgDir?: string;
@@ -1151,10 +1151,10 @@ interface ForkOptions extends Omit<RestoreOptions, "snapDir"> {
      */
     onLog?: OnLog;
     /**
-     * Opt into CRIU lazy-pages restore for the fork — the CRIU image directory
+     * Opt into CRIU lazy-pages restore for the fork — the checkpoint image directory
      * is mounted into the guest read-only via in-VMM virtio-fs and `criu restore
      * --lazy-pages` faults pages on demand. Default false: the runtime packs the
-     * CRIU image into a tar on `/dev/vdb` and the guest does an eager load.
+     * checkpoint image into a tar on `/dev/vdb` and the guest does an eager load.
      *
      * Lazy keeps fork RSS proportional to the pages the sibling actually
      * touches, not the full snapshot size. Worth setting when the source dumped
@@ -1772,6 +1772,136 @@ declare function validatePid(pid: number, expected: {
     startedAt?: number;
 }): PidStatus;
 
+declare const LEVEL5_RUNTIME_ADAPTER_SUBSTRATE_FORMAT_VERSION: 1;
+type Level5EvidenceStatus = "proof" | "support" | "refusal";
+type Level5ProductSupport = "supported" | "not-yet-supported" | "unsupported";
+type Level5ImplementationLevel = "not-implemented" | "level-0-fail-closed-discovery" | "level-5-cross-arch-process-continuation-substrate" | "level-5-cross-arch-process-continuation";
+type Level5GraduationTargetLevel = "level-5-cross-arch-process-continuation";
+type Level5AdapterOperation = "snapshot" | "restore";
+type Level5RuntimeFamily = "node" | "go" | "jvm" | "python" | "ruby" | "native" | string;
+declare const level5SubstrateRefusalCodes: readonly ["level5-runtime-family-unsupported", "level5-runtime-profile-unsupported", "level5-target-native-runtime-missing", "level5-source-target-arch-unsupported", "level5-source-isa-emulation-forbidden", "level5-sidecar-output-forbidden", "level5-metadata-only-success-forbidden", "level5-active-syscall-unsupported", "level5-active-tcp-stream-unsupported", "level5-thread-state-unsupported", "level5-kernel-resource-unsupported", "level5-runtime-heap-stack-unsupported"];
+type Level5SubstrateRefusalCode = (typeof level5SubstrateRefusalCodes)[number];
+interface Level5StatusFields {
+    evidenceStatus: Level5EvidenceStatus;
+    productSupport: Level5ProductSupport;
+    implementationLevel: Level5ImplementationLevel;
+    graduationTargetLevel: Level5GraduationTargetLevel;
+    migrationCompleted: boolean;
+}
+interface Level5ArchitectureMetadata {
+    sourceArch?: "arm64" | "amd64" | string;
+    targetArch?: "arm64" | "amd64" | string;
+}
+interface Level5ArtifactEnvelope extends Level5StatusFields, Level5ArchitectureMetadata {
+    kind: string;
+    formatVersion: typeof LEVEL5_RUNTIME_ADAPTER_SUBSTRATE_FORMAT_VERSION | number;
+    adapterId: string;
+    runtimeFamily: Level5RuntimeFamily;
+    profile: string;
+}
+interface Level5AdapterDetectInput {
+    operation: Level5AdapterOperation;
+    snapDir?: string;
+    bundleFiles?: string[];
+    runtimeFamily?: Level5RuntimeFamily;
+    profile?: string;
+    artifactKind?: string;
+}
+interface Level5AdapterDetection {
+    matched: boolean;
+    adapterId: string;
+    runtimeFamily: Level5RuntimeFamily;
+    profile?: string;
+    reason: string;
+}
+interface Level5QuiesceResult {
+    state: "quiesced" | "refused";
+    refusals: Level5RefusalEnvelope[];
+}
+interface Level5ValidationResult {
+    state: "passed" | "refused";
+    refusals: Level5RefusalEnvelope[];
+}
+interface Level5RestorePlan extends Level5ArtifactEnvelope {
+    kind: "machinen.level5-restore-plan";
+    planState: "planned" | "refused";
+    steps: string[];
+    refusals: Level5RefusalEnvelope[];
+}
+interface Level5VerifierEvidence extends Level5StatusFields {
+    kind: "machinen.level5-target-verifier-evidence" | string;
+    status: "passed" | "failed" | "not-run";
+    targetNativeExecution: boolean;
+    sourceIsaEmulationUsed: boolean;
+    sidecarOutputUsed: boolean;
+    metadataOnlySuccess: boolean;
+    message: string;
+}
+interface Level5RefusalEnvelope extends Level5StatusFields {
+    kind: "machinen.level5-refusal";
+    code: Level5SubstrateRefusalCode | string;
+    message: string;
+    adapterId?: string;
+    runtimeFamily?: Level5RuntimeFamily;
+    profile?: string;
+    stable: true;
+}
+interface Level5RuntimeAdapter<SnapshotContext = unknown, CaptureArtifact = unknown, RestoreContext = unknown, Plan extends Level5RestorePlan = Level5RestorePlan, RestoreResult = unknown, VerifyEvidence extends Level5VerifierEvidence = Level5VerifierEvidence> {
+    id: string;
+    runtimeFamily: Level5RuntimeFamily;
+    supportedProfiles: readonly string[];
+    graduationTargetLevel: Level5GraduationTargetLevel;
+    detect(input: Level5AdapterDetectInput): Level5AdapterDetection;
+    quiesce(input: SnapshotContext): Level5QuiesceResult | Promise<Level5QuiesceResult>;
+    capture(input: SnapshotContext): CaptureArtifact | Promise<CaptureArtifact>;
+    validate(input: CaptureArtifact | RestoreContext): Level5ValidationResult | Promise<Level5ValidationResult>;
+    planRestore(input: RestoreContext): Plan | Promise<Plan>;
+    restoreTargetNative(input: Plan): RestoreResult | Promise<RestoreResult>;
+    verify(input: RestoreResult): VerifyEvidence | Promise<VerifyEvidence>;
+    refuse(input: {
+        code: Level5SubstrateRefusalCode | string;
+        message: string;
+        profile?: string;
+    }): Level5RefusalEnvelope;
+}
+interface Level5RuntimeAdapterMatch<Adapter extends Level5RuntimeAdapter = Level5RuntimeAdapter> {
+    adapter: Adapter;
+    detection: Level5AdapterDetection;
+}
+interface Level5RuntimeAdapterRegistry<Adapter extends Level5RuntimeAdapter = Level5RuntimeAdapter> {
+    adapters: readonly Adapter[];
+    detect(input: Level5AdapterDetectInput): Level5RuntimeAdapterMatch<Adapter> | undefined;
+    refuseUnsupported(input: {
+        code?: Level5SubstrateRefusalCode;
+        message: string;
+        runtimeFamily?: Level5RuntimeFamily;
+        profile?: string;
+    }): Level5RefusalEnvelope;
+    summary(): Level5RuntimeAdapterRegistrySummary;
+}
+interface Level5RuntimeAdapterRegistrySummary extends Level5StatusFields {
+    kind: "machinen.level5-runtime-adapter-registry-summary";
+    formatVersion: typeof LEVEL5_RUNTIME_ADAPTER_SUBSTRATE_FORMAT_VERSION;
+    adapterCount: number;
+    adapters: Array<{
+        id: string;
+        runtimeFamily: Level5RuntimeFamily;
+        supportedProfiles: readonly string[];
+        graduationTargetLevel: Level5GraduationTargetLevel;
+    }>;
+    stableRefusalCodes: readonly Level5SubstrateRefusalCode[];
+}
+declare function createLevel5RuntimeAdapterRegistry<Adapter extends Level5RuntimeAdapter>(adapters: readonly Adapter[]): Level5RuntimeAdapterRegistry<Adapter>;
+declare function buildLevel5RefusalEnvelope(input: {
+    code: Level5SubstrateRefusalCode | string;
+    message: string;
+    adapterId?: string;
+    runtimeFamily?: Level5RuntimeFamily;
+    profile?: string;
+}): Level5RefusalEnvelope;
+declare function buildLevel5ProofOnlyStatus(): Level5StatusFields;
+declare function buildLevel5RuntimeAdapterRegistrySummary(adapters: readonly Pick<Level5RuntimeAdapter, "id" | "runtimeFamily" | "supportedProfiles" | "graduationTargetLevel">[]): Level5RuntimeAdapterRegistrySummary;
+
 /** Per-entry record of what `runGc` did (or would do, with dryRun). */
 interface GcResult {
     pid: number;
@@ -2106,6 +2236,7 @@ declare const ErrorCode: {
     readonly BOOT_MEMORY_INVALID: "BOOT_MEMORY_INVALID";
     readonly BOOT_NESTED_VIRT_UNSUPPORTED: "BOOT_NESTED_VIRT_UNSUPPORTED";
     readonly BOOT_VMSTATE_UNSUPPORTED: "BOOT_VMSTATE_UNSUPPORTED";
+    readonly BOOT_VMSTATE_CROSS_ISA_UNSUPPORTED: "BOOT_VMSTATE_CROSS_ISA_UNSUPPORTED";
     readonly BOOT_VMSTATE_RESEED_FAILED: "BOOT_VMSTATE_RESEED_FAILED";
     readonly BOOT_PORTABLE_UNSUPPORTED: "BOOT_PORTABLE_UNSUPPORTED";
     readonly FORK_MEMORY_BACKPRESSURE: "FORK_MEMORY_BACKPRESSURE";
@@ -2119,6 +2250,7 @@ declare const ErrorCode: {
     readonly SNAPSHOT_DUMP_FAILED: "SNAPSHOT_DUMP_FAILED";
     readonly SNAPSHOT_TIMEOUT: "SNAPSHOT_TIMEOUT";
     readonly SNAPSHOT_PORTABLE_UNSUPPORTED: "SNAPSHOT_PORTABLE_UNSUPPORTED";
+    readonly SNAPSHOT_PORTABLE_REFUSED: "SNAPSHOT_PORTABLE_REFUSED";
     readonly PROVISION_BASE_NOT_FOUND: "PROVISION_BASE_NOT_FOUND";
     readonly PROVISION_KERNEL_NOT_FOUND: "PROVISION_KERNEL_NOT_FOUND";
     readonly PROVISION_DTB_NOT_FOUND: "PROVISION_DTB_NOT_FOUND";
@@ -2216,6 +2348,1618 @@ declare function isMachinenError(err: unknown, code?: ErrorCode): err is Machine
  */
 declare function formatMachinenError(err: MachinenError): string;
 
+declare const NODE_LEVEL5_TARGET_SIDE_PROOF_FORMAT_VERSION: 1;
+interface NodeLevel5TargetSideProofInput {
+    outPath?: string;
+    token?: string;
+    keepWorkspace?: boolean;
+}
+interface NodeLevel5TargetSideProof {
+    kind: "machinen.node-level5-target-side-continuation-proof";
+    formatVersion: typeof NODE_LEVEL5_TARGET_SIDE_PROOF_FORMAT_VERSION;
+    sourceGoal: "009";
+    evidenceStatus: "proof";
+    productSupport: "not-yet-supported";
+    implementationLevel: "not-implemented";
+    graduationTargetLevel: "level-5-cross-arch-process-continuation";
+    fixture: {
+        kind: "small-node-http-app";
+        appPath: string;
+        appSha256: string;
+    };
+    capture: {
+        selectedProofState: {
+            continuationToken: string;
+            route: "/continuation";
+            expectedRuntime: "node";
+        };
+    };
+    restoreHarness: {
+        kind: "target-side-node-http-proof-harness";
+        targetNativeExecution: true;
+        verifierRequestPath: "/continuation";
+    };
+    targetOutput: {
+        kind: "machinen.node-level5-target-output";
+        continuationToken: string;
+        runtime: "node";
+        processArch: string;
+        execPath: string;
+        pid: number;
+        targetNativeExecution: true;
+    };
+    assertions: {
+        sourceIsaEmulationUsed: false;
+        sidecarOutputUsed: false;
+        metadataOnlySuccess: false;
+        targetVerifierObservedActualNodeContinuation: true;
+    };
+    summary: {
+        state: "completed";
+        migrationCompleted: false;
+        proofOnly: true;
+        targetOutputVerified: true;
+    };
+}
+declare function runNodeLevel5TargetSideProof(input?: NodeLevel5TargetSideProofInput): Promise<NodeLevel5TargetSideProof>;
+
+declare const NODE_LEVEL5_HTTP_PROFILE_FORMAT_VERSION: 1;
+declare const NODE_LEVEL5_HTTP_PROFILE_NAME: "node-v8-libuv-single-thread-http-v1";
+declare const nodeLevel5HttpProfileRefusalCodes: readonly ["node-level5-http-arbitrary-v8-heap-native-stack-unsupported", "node-level5-http-native-addon-unsupported", "node-level5-http-worker-thread-unsupported", "node-level5-http-inspector-unsupported", "node-level5-http-active-request-unsupported", "node-level5-http-active-tcp-stream-unsupported", "node-level5-http-active-syscall-unsupported", "node-level5-http-unsupported-timer-async-handle", "node-level5-http-unsupported-module-runtime-state", "node-level5-http-target-native-node-missing", "node-level5-http-source-isa-emulation-forbidden", "node-level5-http-sidecar-output-forbidden", "node-level5-http-metadata-only-success-forbidden"];
+type NodeLevel5HttpProfileRefusalCode = (typeof nodeLevel5HttpProfileRefusalCodes)[number];
+interface NodeLevel5HttpProfileRefusal {
+    code: NodeLevel5HttpProfileRefusalCode;
+    unsafeNeighbor: "arbitrary-v8-heap-native-stack" | "native-addon" | "worker-thread" | "inspector-debug" | "active-request" | "active-tcp-stream" | "active-syscall" | "unsupported-timer-async-handle" | "unsupported-module-runtime-state" | "missing-target-native-node" | "source-isa-emulation" | "sidecar-output" | "metadata-only-success";
+    message: string;
+    evidenceStatus: "refusal";
+    productSupport: "unsupported";
+    implementationLevel: "level-0-fail-closed-discovery";
+    graduationTargetLevel: "level-5-cross-arch-process-continuation";
+    migrationCompleted: false;
+}
+interface NodeLevel5HttpProfileSelectedState {
+    kind: "node-http-counter-selected-state-v1";
+    route: "/";
+    captureMethod: "http-root-json-next-count";
+    observedNextCount: number;
+    restoredInitialCount: number;
+    expectedFirstTargetBody: string;
+}
+interface NodeLevel5HttpProfileCaptureInput {
+    sourceArch: "arm64" | "amd64" | string;
+    nodeVersion: string;
+    sourceCwd: string;
+    argv: string[];
+    guestPort: number;
+    verifier: {
+        kind: string;
+        path: string;
+        sha256: string;
+        bytes: number;
+    };
+    selectedState?: NodeLevel5HttpProfileSelectedState;
+    eventLoopResources?: unknown;
+    kernelResources?: unknown;
+}
+interface NodeLevel5HttpProfileCapture {
+    kind: "machinen.node-level5-runtime-profile";
+    formatVersion: typeof NODE_LEVEL5_HTTP_PROFILE_FORMAT_VERSION;
+    sourceGoal: "021" | "022";
+    evidenceStatus: "proof";
+    productSupport: "not-yet-supported";
+    implementationLevel: "not-implemented";
+    graduationTargetLevel: "level-5-cross-arch-process-continuation";
+    migrationCompleted: false;
+    runtimeFamily: "node";
+    profile: typeof NODE_LEVEL5_HTTP_PROFILE_NAME;
+    sourceArch: string;
+    runtimeIdentity: {
+        executable: "node";
+        version: string;
+        targetNativeRuntimeRequired: true;
+    };
+    processModel: {
+        processCount: 1;
+        threadModel: "single-thread-required";
+        activeSyscallsAllowed: false;
+        activeRequestsAllowed: false;
+        activeTcpStreamsAllowed: false;
+    };
+    moduleIdentity: {
+        sourceCwd: string;
+        argv: string[];
+        entrypoint: string | null;
+        unsupportedModuleStateAllowed: false;
+    };
+    selectedV8State: {
+        stateModel: "bounded-profile-roots-only";
+        arbitraryHeapContinuationAllowed: false;
+        arbitraryNativeStackContinuationAllowed: false;
+    };
+    libuv: {
+        handleInventory: unknown | null;
+        timersAsyncHandlesPolicy: "refuse-unless-modeled";
+    };
+    kernelResources: {
+        inventory: unknown | null;
+        httpListeners: Array<{
+            protocol: "tcp";
+            bindAddress: "127.0.0.1";
+            port: number;
+            level4Profile: "tcp-listener-v1-loopback-empty-accept-queue";
+        }>;
+    };
+    verifier: NodeLevel5HttpProfileCaptureInput["verifier"];
+    selectedState?: NodeLevel5HttpProfileSelectedState;
+    gates: {
+        sourceIsaEmulationAllowed: false;
+        sidecarOutputAllowed: false;
+        metadataOnlySuccessAllowed: false;
+        targetNativeNodeRequired: true;
+    };
+    refusals: NodeLevel5HttpProfileRefusal[];
+    summary: {
+        profileReady: true;
+        targetNativeContinuationRequired: true;
+        productSupportBlockedUntilActualRuntimeStateContinuation: true;
+        selectedStateReconstructionHarness: boolean;
+        notProperLevel5Reason: "app-specific-selected-state-descriptor" | "no-selected-state";
+    };
+}
+declare function buildNodeLevel5HttpProfileCapture(input: NodeLevel5HttpProfileCaptureInput): NodeLevel5HttpProfileCapture;
+declare function isSupportedNodeLevel5HttpSelectedState(selectedState: NodeLevel5HttpProfileSelectedState | undefined): selectedState is NodeLevel5HttpProfileSelectedState;
+declare function nodeLevel5HttpProfileRefusalRows(): NodeLevel5HttpProfileRefusal[];
+
+declare const NODE_PROPER_LEVEL5_SOURCE_INSPECTION_KIND: "machinen.node-proper-level5-source-inspection";
+type NodeProperLevel5MapKind = "executable-file" | "shared-object" | "heap" | "stack" | "anonymous-rw" | "anonymous-executable" | "special" | "other";
+interface NodeProperLevel5ProcMapEntry {
+    start: bigint;
+    end: bigint;
+    permissions: string;
+    offset: bigint;
+    device: string;
+    inode: string;
+    path?: string;
+    kind: NodeProperLevel5MapKind;
+}
+interface NodeProperLevel5SourceInspectionInput {
+    procMaps: string;
+    cmdline?: string[];
+    fdTargets?: string[];
+}
+interface NodeProperLevel5SourceInspectionSummary {
+    kind: typeof NODE_PROPER_LEVEL5_SOURCE_INSPECTION_KIND;
+    goal: "023";
+    productSupport: "not-yet-supported";
+    implementationLevel: "first-proof-only";
+    graduationTargetLevel: "level-5-cross-arch-process-continuation";
+    migrationCompleted: true;
+    runtimeLevelProfilesUsed: false;
+    checkpointRestoreSubstrateUsed: false;
+    appSpecificSelectedStateUsed: false;
+    maps: {
+        total: number;
+        executableFiles: number;
+        sharedObjects: number;
+        heaps: number;
+        stacks: number;
+        anonymousRw: number;
+        anonymousExecutable: number;
+    };
+    completedRecoveries: string[];
+    proofCommand: "pnpm run smoke-node-proper-level5-proof";
+    firstProofTarget: {
+        singleThreadNode: true;
+        nativeAddonsAllowed: false;
+        workersAllowed: false;
+        httpListeners: 1;
+        stateSource: "reconstructed-runtime-native-state";
+        targetResponse: {
+            count: 3;
+        };
+    };
+}
+declare function parseNodeProperLevel5ProcMaps(text: string): NodeProperLevel5ProcMapEntry[];
+declare function summarizeNodeProperLevel5SourceInspection(input: NodeProperLevel5SourceInspectionInput): NodeProperLevel5SourceInspectionSummary;
+
+declare const NODE_PROPER_LEVEL5_V8_CLOSURE_RECOVERY_KIND: "machinen.node-proper-level5-v8-closure-recovery";
+type NodeProperLevel5V8ClosureRecoveryRefusalCode = "node-proper-level5-v8-heap-snapshot-malformed" | "node-proper-level5-v8-counter-closure-context-missing" | "node-proper-level5-v8-counter-cell-primitive-smi-not-addressable" | "node-proper-level5-v8-counter-cell-ambiguous";
+interface NodeProperLevel5V8ClosureRecoveryRefusal {
+    code: NodeProperLevel5V8ClosureRecoveryRefusalCode;
+    message: string;
+}
+interface NodeProperLevel5V8ClosureCounterCellCandidate {
+    closureNode: number;
+    closureName: string;
+    contextNode: number;
+    variableName: string;
+    cellNode: number;
+    cellType: string;
+    cellName: string;
+    evidence: string[];
+}
+interface NodeProperLevel5RawMemoryFragment {
+    bytes: Uint8Array;
+    startAddress: bigint;
+    bytesPath?: string;
+}
+interface NodeProperLevel5RawV8ContextSmiRecoveryResult {
+    accepted: boolean;
+    value?: number;
+    anchorTaggedAddress?: string;
+    anchorBytesPath?: string;
+    contextBytesPath?: string;
+    contextSlotOffset?: number;
+    smiEncoding?: "v8-pointer-compressed-smi32" | "v8-tagged-smi64";
+    refusals: NodeProperLevel5V8ClosureRecoveryRefusal[];
+}
+interface NodeProperLevel5V8ClosureRecoveryResult {
+    kind: typeof NODE_PROPER_LEVEL5_V8_CLOSURE_RECOVERY_KIND;
+    accepted: boolean;
+    variableName: string;
+    candidates: NodeProperLevel5V8ClosureCounterCellCandidate[];
+    refusals: NodeProperLevel5V8ClosureRecoveryRefusal[];
+}
+declare function recoverNodeProperLevel5RawV8ContextSmiCounter(fragments: NodeProperLevel5RawMemoryFragment[], options: {
+    anchor: string;
+    expectedValue?: number;
+    searchRadiusBytes?: number;
+}): NodeProperLevel5RawV8ContextSmiRecoveryResult;
+declare function recoverNodeProperLevel5V8ClosureCounterCell(heapSnapshot: unknown, options?: {
+    variableName?: string;
+    closureNameIncludes?: string;
+}): NodeProperLevel5V8ClosureRecoveryResult;
+
+declare const NODE_PROPER_LEVEL5_LIBUV_TIMER_RECOVERY_KIND: "machinen.node-proper-level5-libuv-timer-recovery";
+type NodeProperLevel5LibuvTimerRecoveryRefusalCode = "node-proper-level5-libuv-timer-missing" | "node-proper-level5-libuv-timer-ambiguous" | "node-proper-level5-libuv-timer-callback-active-unsupported";
+interface NodeProperLevel5LibuvTimerRecoveryRefusal {
+    code: NodeProperLevel5LibuvTimerRecoveryRefusalCode;
+    message: string;
+}
+interface NodeProperLevel5LibuvTimerMemoryFragment {
+    bytes: Uint8Array;
+    bytesPath?: string;
+    startAddress?: bigint;
+}
+interface NodeProperLevel5LibuvTimerCandidate {
+    anchor: string;
+    bytesPath?: string;
+    offset: number;
+    evidence: string[];
+}
+interface NodeProperLevel5LibuvTimerRecoveryResult {
+    kind: typeof NODE_PROPER_LEVEL5_LIBUV_TIMER_RECOVERY_KIND;
+    accepted: boolean;
+    timerCount: number;
+    candidates: NodeProperLevel5LibuvTimerCandidate[];
+    refusals: NodeProperLevel5LibuvTimerRecoveryRefusal[];
+}
+declare function recoverNodeProperLevel5LibuvTimerEvidence(fragments: NodeProperLevel5LibuvTimerMemoryFragment[], options: {
+    anchor: string;
+    callbackName?: string;
+    activeCallbackDetected?: boolean;
+}): NodeProperLevel5LibuvTimerRecoveryResult;
+
+declare const NODE_PROPER_LEVEL5_V8_OBJECT_RECOVERY_KIND: "machinen.node-proper-level5-v8-object-recovery";
+type NodeProperLevel5V8ObjectRecoveryRefusalCode = "node-proper-level5-v8-object-state-missing" | "node-proper-level5-v8-object-state-ambiguous" | "node-proper-level5-v8-object-hidden-class-unsupported" | "node-proper-level5-v8-object-sparse-array-unsupported" | "node-proper-level5-v8-object-accessor-unsupported" | "node-proper-level5-v8-object-proxy-unsupported" | "node-proper-level5-v8-object-symbol-key-unsupported" | "node-proper-level5-v8-object-external-string-unsupported" | "node-proper-level5-v8-object-elements-kind-unsupported";
+interface NodeProperLevel5V8ObjectRecoveryRefusal {
+    code: NodeProperLevel5V8ObjectRecoveryRefusalCode;
+    message: string;
+}
+interface NodeProperLevel5V8ObjectMemoryFragment {
+    bytes: Uint8Array;
+    bytesPath?: string;
+}
+interface NodeProperLevel5V8ObjectCandidate {
+    anchor: string;
+    bytesPath?: string;
+    offset: number;
+    total: number;
+    history: number[];
+    evidence: string[];
+}
+interface NodeProperLevel5V8ObjectRecoveryResult {
+    kind: typeof NODE_PROPER_LEVEL5_V8_OBJECT_RECOVERY_KIND;
+    accepted: boolean;
+    candidates: NodeProperLevel5V8ObjectCandidate[];
+    refusals: NodeProperLevel5V8ObjectRecoveryRefusal[];
+}
+interface NodeProperLevel5V8ObjectRecoveryOptions {
+    anchor: string;
+    expectedTotal: number;
+    expectedHistory: number[];
+    unsupportedShape?: NodeProperLevel5V8ObjectRecoveryRefusalCode;
+}
+declare function recoverNodeProperLevel5V8ObjectStateEvidence(fragments: NodeProperLevel5V8ObjectMemoryFragment[], options: NodeProperLevel5V8ObjectRecoveryOptions): NodeProperLevel5V8ObjectRecoveryResult;
+
+declare const NODE_PROPER_LEVEL5_HTTP_STATE_POLICY_KIND: "machinen.node-proper-level5-http-state-policy";
+type NodeProperLevel5HttpStatePolicyRefusalCode = "node-proper-level5-http-active-request-unsupported" | "node-proper-level5-http-partial-read-unsupported" | "node-proper-level5-http-partial-write-unsupported" | "node-proper-level5-http-ambiguous-connection-state";
+interface NodeProperLevel5HttpStatePolicyRefusal {
+    code: NodeProperLevel5HttpStatePolicyRefusalCode;
+    message: string;
+}
+interface NodeProperLevel5HttpStatePolicyInput {
+    activeRequestDetected?: boolean;
+    partialReadDetected?: boolean;
+    partialWriteDetected?: boolean;
+    ambiguousConnectionState?: boolean;
+    idleKeepAliveSockets?: number;
+}
+interface NodeProperLevel5HttpStatePolicyResult {
+    kind: typeof NODE_PROPER_LEVEL5_HTTP_STATE_POLICY_KIND;
+    accepted: boolean;
+    activeRequestPolicy: "refuse-active-request" | "no-active-request-detected";
+    idleKeepAlivePolicy: "none-detected" | "safe-close-and-recreate-idle-connections-on-target";
+    refusals: NodeProperLevel5HttpStatePolicyRefusal[];
+}
+declare function classifyNodeProperLevel5HttpStatePolicy(input: NodeProperLevel5HttpStatePolicyInput): NodeProperLevel5HttpStatePolicyResult;
+
+declare const NODE_LEVEL5_PROOF_COMPOSITION_FORMAT_VERSION: 1;
+declare const nodeLevel5ProofIngredientNames: readonly ["register-translation", "stack-return-chain-translation", "private-memory-materialization", "executable-target-module-materialization", "target-restore-loader", "level4-event-loop-resource-map", "target-native-verifier"];
+type NodeLevel5ProofIngredientName = (typeof nodeLevel5ProofIngredientNames)[number];
+declare const nodeLevel5ProofRefusalCodes: readonly ["node-level5-tls-rseq-unsupported", "node-level5-simd-fpu-unsupported", "node-level5-signal-frame-unsupported", "node-level5-active-syscall-unsupported", "node-level5-active-tcp-unsupported", "node-level5-worker-thread-unsupported", "node-level5-multithread-unsupported", "node-level5-memory-mapping-unsupported", "node-level5-kernel-resource-unsupported", "node-level5-native-addon-abi-unsupported", "node-level5-inspector-unsupported", "node-level5-v8-libuv-state-unsupported", "node-level5-arbitrary-heap-stack-continuation-refused"];
+type NodeLevel5ProofRefusalCode = (typeof nodeLevel5ProofRefusalCodes)[number];
+interface NodeLevel5ProofIngredient {
+    name: NodeLevel5ProofIngredientName;
+    evidenceStatus: "checked" | "proof" | "missing";
+    checkedSummary?: string;
+    notes: string;
+}
+interface NodeLevel5ProofCompositionInput {
+    eventLoopResourceMapPresent: boolean;
+    targetNativeVerifierPresent: boolean;
+    checkedSummaries?: Partial<Record<NodeLevel5ProofIngredientName, string>>;
+    targetProof?: NodeLevel5TargetProofEvidence;
+}
+interface NodeLevel5TargetProofEvidence {
+    path: string;
+    status: "passed" | "missing" | "failed" | "not-run";
+    kind?: "machinen.node-level5-target-side-continuation-proof";
+    sourceArch?: string;
+    targetArch?: string;
+    targetRuntime?: string;
+    noSourceIsaEmulation: boolean;
+    noSidecarOutput: boolean;
+    noMetadataOnlySuccess: boolean;
+    targetVerifierObservedActualNodeContinuation: boolean;
+    message: string;
+}
+interface NodeLevel5ProofCompositionRefusal {
+    code: NodeLevel5ProofRefusalCode;
+    message: string;
+    migrationCompleted: false;
+    productSupport: "unsupported";
+    implementationLevel: "level-0-fail-closed-discovery";
+    evidenceStatus: "refusal";
+}
+interface NodeLevel5ProofEvidenceCheck {
+    name: NodeLevel5ProofIngredientName;
+    path: string;
+    requiredFragments: string[];
+    status: "passed" | "missing" | "failed";
+    message: string;
+}
+interface NodeLevel5ProofRefusalMatrixRow extends NodeLevel5ProofCompositionRefusal {
+    unsafeNeighbor: "tls-rseq" | "simd-fpu" | "active-signals" | "active-syscalls" | "active-tcp" | "worker-threads" | "multithread" | "unsupported-memory-mappings" | "unsupported-kernel-resources" | "native-addon-abi" | "inspector-debug" | "unsupported-v8-libuv-state" | "arbitrary-heap-stack-continuation";
+}
+interface NodeLevel5ProofComposition {
+    kind: "machinen.node-level5-proof-composition";
+    formatVersion: typeof NODE_LEVEL5_PROOF_COMPOSITION_FORMAT_VERSION;
+    sourceGoal: "009";
+    evidenceStatus: "proof";
+    productSupport: "not-yet-supported";
+    implementationLevel: "not-implemented";
+    graduationTargetLevel: "level-5-cross-arch-process-continuation";
+    selectedSubset: "node-http-clean-root-v1-with-level4-event-loop-map";
+    requiredIngredients: NodeLevel5ProofIngredient[];
+    evidenceChecks?: NodeLevel5ProofEvidenceCheck[];
+    targetProof?: NodeLevel5TargetProofEvidence;
+    proofRunner?: "scripts/node-level5-proof-composition.ts";
+    refusals: NodeLevel5ProofCompositionRefusal[];
+    refusalMatrix: NodeLevel5ProofRefusalMatrixRow[];
+    gates: {
+        arbitraryV8HeapContinuationAllowed: false;
+        arbitraryNativeStackContinuationAllowed: false;
+        sourceIsaEmulationAllowed: false;
+        sidecarRuntimeAllowed: false;
+        metadataOnlyContinuationAllowed: false;
+        publicProductVerbRequiredBeforeSupport: true;
+    };
+    summary: {
+        required: number;
+        present: number;
+        missing: number;
+        refusalCount: number;
+        proofReady: boolean;
+    };
+}
+declare function buildNodeLevel5ProofComposition(input: NodeLevel5ProofCompositionInput & {
+    evidenceChecks?: NodeLevel5ProofEvidenceCheck[];
+    proofRunner?: "scripts/node-level5-proof-composition.ts";
+}): NodeLevel5ProofComposition;
+
+declare const NODE_LEVEL5_DECLARED_SUBSET_FORMAT_VERSION = 1;
+declare const NODE_LEVEL5_DECLARED_SUBSET_MANIFEST = "machinen.node-level5-declared-subset-manifest";
+declare const NODE_LEVEL5_DECLARED_SUBSET_RESTORE_SUMMARY = "machinen.node-level5-declared-subset-restore-summary";
+declare const nodeLevel5DeclaredSubsetRefusalCodes: {
+    readonly experimentalFlagRequired: "node-level5-declared-subset-experimental-flag-required";
+    readonly outputRequired: "node-level5-declared-subset-output-required";
+    readonly manifestRequired: "node-level5-declared-subset-manifest-required";
+    readonly manifestMissing: "node-level5-declared-subset-manifest-missing";
+    readonly manifestInvalid: "node-level5-declared-subset-manifest-invalid";
+    readonly rawCpuRestoreRefused: "node-level5-declared-subset-raw-cpu-restore-refused";
+    readonly unsupportedNeighborRefused: "node-level5-declared-subset-unsupported-neighbor-refused";
+    readonly productClaimRefused: "node-level5-declared-subset-product-claim-refused";
+};
+type NodeLevel5DeclaredSubsetRefusalCode = (typeof nodeLevel5DeclaredSubsetRefusalCodes)[keyof typeof nodeLevel5DeclaredSubsetRefusalCodes];
+type NodeLevel5DeclaredSubsetArchitecture = "arm64" | "amd64";
+type NodeLevel5DeclaredSubsetRefusal = {
+    code: NodeLevel5DeclaredSubsetRefusalCode;
+    message: string;
+};
+type NodeLevel5DeclaredSubsetSupportMatrix = {
+    kind: "machinen.node-level5-declared-subset-support-matrix";
+    formatVersion: typeof NODE_LEVEL5_DECLARED_SUBSET_FORMAT_VERSION;
+    status: "experimental-candidate-not-supported";
+    productSupportClaimed: false;
+    broadLevel5ImplementationClaimed: false;
+    declaredSubsetCoverage: 100;
+    node: "22.x";
+    v8: "12.x pointer-compressed";
+    libuv: "supported idle handles only";
+    supportedStateFamilies: readonly string[];
+    unsupportedStateFamilies: readonly string[];
+    refusalCodes: typeof nodeLevel5DeclaredSubsetRefusalCodes;
+};
+declare const nodeLevel5DeclaredSubsetSupportMatrix: NodeLevel5DeclaredSubsetSupportMatrix;
+type CreateNodeLevel5DeclaredSubsetCaptureInput = {
+    outDir: string;
+    sourceArch: NodeLevel5DeclaredSubsetArchitecture;
+    targetArch: NodeLevel5DeclaredSubsetArchitecture;
+    experimental: boolean;
+    productSupportClaimed?: boolean;
+    dryRun?: boolean;
+};
+type NodeLevel5DeclaredSubsetManifest = {
+    kind: typeof NODE_LEVEL5_DECLARED_SUBSET_MANIFEST;
+    formatVersion: typeof NODE_LEVEL5_DECLARED_SUBSET_FORMAT_VERSION;
+    status: "experimental-candidate-not-supported";
+    productSupportClaimed: false;
+    broadLevel5ImplementationClaimed: false;
+    sourceArch: NodeLevel5DeclaredSubsetArchitecture;
+    targetArch: NodeLevel5DeclaredSubsetArchitecture;
+    translatedContinuationRequired: true;
+    rawCpuRestoreSupported: false;
+    supportMatrix: NodeLevel5DeclaredSubsetSupportMatrix;
+};
+type NodeLevel5DeclaredSubsetCaptureSummary = {
+    kind: "machinen.node-level5-declared-subset-capture-summary";
+    accepted: boolean;
+    manifestPath?: string;
+    manifest?: NodeLevel5DeclaredSubsetManifest;
+    dryRun: boolean;
+    targetStarted: false;
+    productSupportClaimed: false;
+    broadLevel5ImplementationClaimed: false;
+    refusal?: NodeLevel5DeclaredSubsetRefusal;
+};
+type RestoreNodeLevel5DeclaredSubsetInput = {
+    manifestPath: string;
+    experimental: boolean;
+    rawCpuRestore?: boolean;
+    productSupportClaimed?: boolean;
+    dryRun?: boolean;
+};
+type NodeLevel5DeclaredSubsetRestoreSummary = {
+    kind: typeof NODE_LEVEL5_DECLARED_SUBSET_RESTORE_SUMMARY;
+    accepted: boolean;
+    manifestPath: string;
+    dryRun: boolean;
+    targetStarted: false;
+    translatedContinuationRequired: true;
+    targetNativeNodeRequired: true;
+    productSupportClaimed: false;
+    broadLevel5ImplementationClaimed: false;
+    refusal?: NodeLevel5DeclaredSubsetRefusal;
+};
+declare function createNodeLevel5DeclaredSubsetCapture(input: CreateNodeLevel5DeclaredSubsetCaptureInput): NodeLevel5DeclaredSubsetCaptureSummary;
+declare function restoreNodeLevel5DeclaredSubset(input: RestoreNodeLevel5DeclaredSubsetInput): NodeLevel5DeclaredSubsetRestoreSummary;
+declare function isNodeLevel5DeclaredSubsetManifest(value: unknown): value is NodeLevel5DeclaredSubsetManifest;
+
+declare const NODE_LEVEL5_READINESS_MATRIX_KIND = "machinen.node-level5-readiness-matrix";
+declare const NODE_LEVEL5_READINESS_MATRIX_VERSION = 1;
+type NodeLevel5ReadinessGateStatus = "passed" | "refused" | "documented";
+type NodeLevel5ReadinessGate = {
+    id: string;
+    family: "narrow-product" | "broad-proof" | "final-audit";
+    title: string;
+    status: NodeLevel5ReadinessGateStatus;
+    artifact: string;
+    productSupportClaimed: false;
+    broadProductSupportClaimed: false;
+};
+type NodeLevel5UnsupportedNeighborGate = NodeLevel5ReadinessGate & {
+    refusalCode: string;
+    targetStarted: false;
+    sourceIsaEmulationUsed: false;
+    rawCpuRestoreUsed: false;
+};
+type NodeLevel5AppCorpusGate = NodeLevel5ReadinessGate & {
+    appFamily: string;
+    direction: "arm64-to-amd64" | "amd64-to-arm64" | "both";
+    repeatabilityRuns: number;
+};
+type NodeLevel5ReadinessMatrix = {
+    kind: typeof NODE_LEVEL5_READINESS_MATRIX_KIND;
+    version: typeof NODE_LEVEL5_READINESS_MATRIX_VERSION;
+    status: "proof-matrix-complete-product-support-not-claimed";
+    declaredSubsetCoverage: 100;
+    narrowExperimentalProductReadiness: 100;
+    broadNodeProofReadiness: 100;
+    broadNodeProductSupportClaimed: 0;
+    arbitraryProcessCrossArchRestore: 5;
+    productSupportClaimed: false;
+    broadLevel5ImplementationClaimed: false;
+    narrowProductGates: readonly NodeLevel5ReadinessGate[];
+    unsupportedNeighborGates: readonly NodeLevel5UnsupportedNeighborGate[];
+    appCorpusGates: readonly NodeLevel5AppCorpusGate[];
+    repeatabilityGates: readonly NodeLevel5ReadinessGate[];
+    finalAuditGates: readonly NodeLevel5ReadinessGate[];
+};
+declare const nodeLevel5NarrowProductReadinessGates: readonly NodeLevel5ReadinessGate[];
+declare const nodeLevel5UnsupportedNeighborGates: readonly NodeLevel5UnsupportedNeighborGate[];
+declare const nodeLevel5AppCorpusGates: readonly NodeLevel5AppCorpusGate[];
+declare const nodeLevel5FinalAuditGates: readonly NodeLevel5ReadinessGate[];
+declare const nodeLevel5ReadinessMatrix: NodeLevel5ReadinessMatrix;
+declare function assertNodeLevel5ReadinessMatrixComplete(matrix?: NodeLevel5ReadinessMatrix): boolean;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_20_KIND = "machinen.node-level5-product-support-20";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_20_VERSION = 1;
+type NodeLevel5ProductSupportFamilyId = "idle-http-listener" | "timer-service" | "plain-js-heap" | "readonly-file-stdio" | "pipes-streams-idle";
+type NodeLevel5ProductSupportDirection = "arm64-to-amd64" | "amd64-to-arm64";
+type NodeLevel5ProductSupportFamily = {
+    id: NodeLevel5ProductSupportFamilyId;
+    title: string;
+    coveragePercent: 4;
+    status: "experimental-supported";
+    included: readonly string[];
+    excluded: readonly string[];
+    contractArtifact: string;
+    e2eArtifact: string;
+    directions: readonly NodeLevel5ProductSupportDirection[];
+    targetNativeVerified: true;
+    productSupportClaimed: true;
+    broadNodeProductSupportClaimed: false;
+};
+type NodeLevel5ProductUnsupportedNeighbor = {
+    id: string;
+    refusalCode: string;
+    targetStarted: false;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    productSupportClaimed: false;
+};
+type NodeLevel5ProductSupport20Matrix = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_20_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_20_VERSION;
+    status: "experimental-node-product-support-20";
+    nodeProductSupportClaimed: 20;
+    nodeProductSupportScope: "five-idle-service-families";
+    declaredSubsetExperimentalProductSupportClaimed: 100;
+    broadNodeProductSupportClaimed: 0;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+    node: "22.x";
+    v8: "12.x pointer-compressed";
+    libuv: "supported idle handles only";
+    families: readonly NodeLevel5ProductSupportFamily[];
+    unsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+    safety: {
+        rawCpuRestoreSupported: false;
+        sourceIsaEmulationSupported: false;
+        appCheckpointHooksRequired: false;
+        targetNativeNodeRequired: true;
+    };
+};
+declare const nodeLevel5ProductSupport20Families: readonly NodeLevel5ProductSupportFamily[];
+declare const nodeLevel5ProductUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+declare const nodeLevel5ProductSupport20Matrix: NodeLevel5ProductSupport20Matrix;
+declare function assertNodeLevel5ProductSupport20MatrixComplete(matrix?: NodeLevel5ProductSupport20Matrix): boolean;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_50_KIND = "machinen.node-level5-product-support-50";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_50_VERSION = 1;
+type NodeLevel5ProductSupport50FamilyId = NodeLevel5ProductSupportFamily["id"] | "http-keepalive-idle-pool" | "completed-microtask-checkpoint" | "promise-async-closure-graph" | "commonjs-esm-module-cache" | "json-config-data-heap-graph" | "graceful-shutdown-lifecycle";
+type NodeLevel5ProductSupport50Family = {
+    id: NodeLevel5ProductSupport50FamilyId;
+    title: string;
+    coveragePercent: 4 | 5;
+    status: "experimental-supported";
+    included: readonly string[];
+    excluded: readonly string[];
+    contractArtifact: string;
+    e2eArtifact: string;
+    directions: readonly NodeLevel5ProductSupportDirection[];
+    targetNativeVerified: true;
+    productSupportClaimed: true;
+    broadNodeProductSupportClaimed: false;
+};
+type NodeLevel5ProductSupport50Matrix = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_50_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_50_VERSION;
+    status: "experimental-node-product-support-50";
+    nodeProductSupportClaimed: 50;
+    nodeProductSupportScope: "eleven-service-families";
+    previousNodeProductSupportClaimed: 20;
+    newNodeProductSupportClaimed: 30;
+    declaredSubsetExperimentalProductSupportClaimed: 100;
+    broadNodeProductSupportClaimed: 0;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+    node: "22.x";
+    v8: "12.x pointer-compressed";
+    libuv: "supported idle handles only";
+    families: readonly NodeLevel5ProductSupport50Family[];
+    expandedUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+    positiveAppCorpus: readonly string[];
+    negativeAppCorpus: readonly string[];
+    repeatabilityRuns: 20;
+    safety: {
+        rawCpuRestoreSupported: false;
+        sourceIsaEmulationSupported: false;
+        appCheckpointHooksRequired: false;
+        targetNativeNodeRequired: true;
+        metadataOnlySuccessAccepted: false;
+    };
+};
+declare const nodeLevel5ProductSupport50NewFamilies: readonly NodeLevel5ProductSupport50Family[];
+declare const nodeLevel5ProductSupport50Families: readonly NodeLevel5ProductSupport50Family[];
+declare const nodeLevel5ProductSupport50ExpandedUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+declare const nodeLevel5ProductSupport50Matrix: NodeLevel5ProductSupport50Matrix;
+declare function assertNodeLevel5ProductSupport50MatrixComplete(matrix?: NodeLevel5ProductSupport50Matrix): boolean;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_65_KIND = "machinen.node-level5-product-support-65";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_65_VERSION = 1;
+type NodeLevel5ProductSupport65FamilyId = NodeLevel5ProductSupport50Family["id"] | "active-async-idle-boundary" | "tls-boundary-policy" | "child-process-boundary";
+type NodeLevel5ProductSupport65Family = {
+    id: NodeLevel5ProductSupport65FamilyId;
+    title: string;
+    coveragePercent: 4 | 5;
+    status: "experimental-supported";
+    included: readonly string[];
+    excluded: readonly string[];
+    contractArtifact: string;
+    e2eArtifact: string;
+    directions: readonly NodeLevel5ProductSupportDirection[];
+    targetNativeVerified: true;
+    productSupportClaimed: true;
+    broadNodeFacilityAddressed: boolean;
+    broadNodeProductSupportClaimed: false;
+};
+type NodeLevel5ProductSupport65Matrix = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_65_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_65_VERSION;
+    status: "experimental-node-product-support-65";
+    nodeProductSupportClaimed: 65;
+    nodeProductSupportScope: "fourteen-service-and-boundary-families";
+    previousNodeProductSupportClaimed: 50;
+    newNodeProductSupportClaimed: 15;
+    broadNodeProductSupportClaimed: 5;
+    broadNodeProductSupportScope: "selected-hard-facility-boundaries";
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+    node: "22.x";
+    v8: "12.x pointer-compressed";
+    libuv: "supported idle handles plus selected hard-facility boundaries";
+    families: readonly NodeLevel5ProductSupport65Family[];
+    expandedUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+    hardFacilitiesAddressed: readonly string[];
+    repeatabilityRuns: 25;
+    safety: {
+        rawCpuRestoreSupported: false;
+        sourceIsaEmulationSupported: false;
+        appCheckpointHooksRequired: false;
+        targetNativeNodeRequired: true;
+        metadataOnlySuccessAccepted: false;
+        broadNodeSupportIsPartial: true;
+    };
+};
+declare const nodeLevel5ProductSupport65NewFamilies: readonly NodeLevel5ProductSupport65Family[];
+declare const nodeLevel5ProductSupport65Families: readonly NodeLevel5ProductSupport65Family[];
+declare const nodeLevel5ProductSupport65ExpandedUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+declare const nodeLevel5ProductSupport65Matrix: NodeLevel5ProductSupport65Matrix;
+declare function assertNodeLevel5ProductSupport65MatrixComplete(matrix?: NodeLevel5ProductSupport65Matrix): boolean;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_80_KIND = "machinen.node-level5-product-support-80";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_80_VERSION = 1;
+type NodeLevel5ProductSupport80FamilyId = NodeLevel5ProductSupport65Family["id"] | "express-fastify-http-app" | "dependency-heavy-app" | "streams-files-mixed-app";
+type NodeLevel5RealVmCrossArchEvidence = {
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: NodeLevel5ProductSupportDirection;
+    substrate: "machinen-real-vm-cross-arch";
+    artifactBundle: string;
+    manifestVerified: true;
+    captureSummaryVerified: true;
+    restoreSummaryVerified: true;
+    targetLogsVerified: true;
+    targetNativeNodeVerified: true;
+    behavioralVerifierPassed: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+};
+type NodeLevel5ProductSupport80Family = {
+    id: NodeLevel5ProductSupport80FamilyId;
+    title: string;
+    coveragePercent: 4 | 5;
+    status: "experimental-supported";
+    included: readonly string[];
+    excluded: readonly string[];
+    contractArtifact: string;
+    e2eArtifact: string;
+    directions: readonly NodeLevel5ProductSupportDirection[];
+    realVmCrossArchEvidence: readonly NodeLevel5RealVmCrossArchEvidence[];
+    targetNativeVerified: true;
+    productSupportClaimed: true;
+    broadNodeFacilityAddressed: boolean;
+};
+type NodeLevel5ProductSupport80Matrix = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_80_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_80_VERSION;
+    status: "experimental-node-product-support-80";
+    nodeProductSupportClaimed: 80;
+    nodeProductSupportScope: "seventeen-service-app-and-boundary-families";
+    previousNodeProductSupportClaimed: 65;
+    newNodeProductSupportClaimed: 15;
+    broadNodeProductSupportClaimed: 20;
+    broadNodeProductSupportScope: "real-app-corpus-plus-selected-hard-facility-boundaries";
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+    node: "22.x";
+    v8: "12.x pointer-compressed";
+    libuv: "supported idle handles plus selected hard-facility boundaries";
+    families: readonly NodeLevel5ProductSupport80Family[];
+    expandedUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+    positiveRealAppCorpus: readonly string[];
+    negativeRealAppCorpus: readonly string[];
+    repeatabilityRuns: 30;
+    flakeBudgetPercent: 0;
+    artifactRetention: readonly string[];
+    safety: {
+        rawCpuRestoreSupported: false;
+        sourceIsaEmulationSupported: false;
+        appCheckpointHooksRequired: false;
+        targetNativeNodeRequired: true;
+        metadataOnlySuccessAccepted: false;
+        broadNodeSupportIsPartial: true;
+    };
+};
+declare const nodeLevel5ProductSupport80NewFamilies: readonly NodeLevel5ProductSupport80Family[];
+declare const nodeLevel5ProductSupport80Families: readonly NodeLevel5ProductSupport80Family[];
+declare const nodeLevel5ProductSupport80ExpandedUnsupportedNeighbors: readonly NodeLevel5ProductUnsupportedNeighbor[];
+declare const nodeLevel5ProductSupport80Matrix: NodeLevel5ProductSupport80Matrix;
+declare function assertNodeLevel5ProductSupport80MatrixComplete(matrix?: NodeLevel5ProductSupport80Matrix): boolean;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_85_KIND = "machinen.node-level5-product-support-85";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_85_VERSION = 1;
+type NodeLevel5ProductSupport85ClaimRegistry = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_85_KIND;
+    status: "node-product-support-85-claimed";
+    declaredSubsetExperimentalProductSupportClaimed: 100;
+    nodeProductSupportTiers: readonly [20, 50, 65, 80, 85];
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+    previousNodeProductSupportClaimed: 80;
+    previousBroadNodeProductSupportClaimed: 20;
+    genericVmDetectedEvidenceRequired: true;
+    retainedEvidenceRequired: true;
+    rowArtifactEvidenceRequired: true;
+    refusalArtifactEvidenceRequired: true;
+    realVmCrossArchEvidenceRequired: true;
+    artifactRetentionDays: 30;
+    flakeBudgetPercent: 0;
+    supportedAppRows: 68;
+    refusedAppRows: 42;
+    notProvenAppRows: 4;
+    unsupportedDetectorCount: number;
+};
+declare const nodeLevel5ProductSupport85ClaimRegistry: NodeLevel5ProductSupport85ClaimRegistry;
+
+declare const NODE_LEVEL5_APP_SUPPORT_MATRIX_KIND = "machinen.node-level5-app-support-matrix";
+declare const NODE_LEVEL5_APP_SUPPORT_MATRIX_VERSION = 2;
+type NodeLevel5AppSupportStatus = "supported" | "refused" | "not-proven";
+type NodeLevel5AppSupportFramework = "express" | "fastify";
+type NodeLevel5AppSupportEvidenceKind = "fixture-product-run-corpus" | "template-corpus" | "installed-package-corpus" | "generic-vm-detected-corpus" | "refusal-corpus" | "matrix-gap";
+type NodeLevel5AppSupportProductBehavior = "machinen snapshot <vm-name> --out <dir>; machinen restore <dir>" | "refuse-before-snapshot" | "not-proven";
+type NodeLevel5AppSupportDirection = "arm64-to-amd64" | "amd64-to-arm64";
+type NodeLevel5AppSupportRouteFeature = "simple-route" | "router-route" | "plugin-route" | "unsupported-live-state" | "not-proven";
+type NodeLevel5AppSupportResponseFeature = "text" | "json" | "not-proven";
+type NodeLevel5AppSupportMiddlewareFeature = "none" | "pure-js" | "not-proven";
+type NodeLevel5AppSupportFeatureName = "route" | "response" | "middleware" | "asyncHandler" | "params" | "query" | "staticAssets" | "externalNetwork" | "backgroundTasks";
+type NodeLevel5AppSupportFeatureStatus = "supported" | "refused" | "not-proven";
+type NodeLevel5AppSupportFeatures = {
+    route: NodeLevel5AppSupportRouteFeature;
+    response: NodeLevel5AppSupportResponseFeature;
+    middleware: NodeLevel5AppSupportMiddlewareFeature;
+    asyncHandler: boolean;
+    params: boolean;
+    query: boolean;
+    staticAssets: boolean;
+    externalNetwork: boolean;
+    backgroundTasks: boolean;
+};
+type NodeLevel5AppSupportFeatureAssessment = Record<NodeLevel5AppSupportFeatureName, NodeLevel5AppSupportFeatureStatus>;
+type NodeLevel5AppSupportEvidence = {
+    kind: NodeLevel5AppSupportEvidenceKind;
+    proofRange: string;
+    corpusReport: string;
+};
+type NodeLevel5AppSupportMatrixRow = {
+    id: string;
+    appName: string;
+    framework: NodeLevel5AppSupportFramework;
+    status: NodeLevel5AppSupportStatus;
+    productBehavior: NodeLevel5AppSupportProductBehavior;
+    supportScope: "declared-subset-idle-http" | "unsupported-live-state" | "not-proven-gap";
+    directions: NodeLevel5AppSupportDirection[];
+    evidence: NodeLevel5AppSupportEvidence;
+    supportedAppShape: string;
+    features: NodeLevel5AppSupportFeatures;
+    featureAssessment: NodeLevel5AppSupportFeatureAssessment;
+    limitations: string[];
+};
+type NodeLevel5AppSupportBoundary = {
+    id: string;
+    status: "not-claimed" | "out-of-scope";
+    reason: string;
+};
+type NodeLevel5AppSupportMatrix = {
+    kind: typeof NODE_LEVEL5_APP_SUPPORT_MATRIX_KIND;
+    version: typeof NODE_LEVEL5_APP_SUPPORT_MATRIX_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    rows: NodeLevel5AppSupportMatrixRow[];
+    boundaries: NodeLevel5AppSupportBoundary[];
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function buildNodeLevel5AppSupportMatrix(): NodeLevel5AppSupportMatrix;
+declare function supportedNodeLevel5AppSupportRows(): NodeLevel5AppSupportMatrixRow[];
+declare function refusedNodeLevel5AppSupportRows(): NodeLevel5AppSupportMatrixRow[];
+declare function notProvenNodeLevel5AppSupportRows(): NodeLevel5AppSupportMatrixRow[];
+
+declare const NODE_LEVEL5_PRODUCT_SNAPSHOT_KIND = "machinen.node-level5-product-snapshot";
+declare const NODE_LEVEL5_PRODUCT_SNAPSHOT_VERSION = 1;
+declare const NODE_LEVEL5_PRODUCT_DETECTOR_REPORT_KIND = "machinen.node-level5-product-detector-report";
+declare const NODE_LEVEL5_PRODUCT_TARGET_IDENTITY_KIND = "machinen.node-level5-product-target-identity";
+declare const NODE_LEVEL5_PRODUCT_CAPTURE_REPORT_KIND = "machinen.node-level5-product-capture-report";
+declare const NODE_LEVEL5_PRODUCT_RESTORE_MATERIALIZATION_REPORT_KIND = "machinen.node-level5-product-restore-materialization-report";
+declare const NODE_LEVEL5_PRODUCT_RESTORE_LAUNCH_REPORT_KIND = "machinen.node-level5-product-restore-launch-report";
+declare const NODE_LEVEL5_PRODUCT_BEHAVIORAL_VERIFIER_REPORT_KIND = "machinen.node-level5-product-behavioral-verifier-report";
+declare const DEFAULT_NODE_LEVEL5_PRODUCT_SNAPSHOT_DIRECTION = "arm64-to-amd64";
+type NodeLevel5ProductSnapshotDirection = "arm64-to-amd64" | "amd64-to-arm64";
+type NodeLevel5ProductSnapshotRefusalCode = "node-level5-non-node-target-refused" | "node-level5-target-app-root-missing" | "node-level5-unsupported-app-refused" | "node-level5-active-request-refused" | "node-level5-worker-thread-refused" | "node-level5-native-addon-refused" | "node-level5-wasm-external-memory-refused" | "node-level5-tls-active-state-refused" | "node-level5-child-process-live-state-refused" | "node-level5-filesystem-watcher-refused" | "node-level5-websocket-live-state-refused" | "node-level5-db-connection-live-state-refused" | "node-level5-redis-queue-live-state-refused" | "node-level5-outbound-http-live-socket-refused" | "node-level5-http2-live-session-refused" | "node-level5-sse-live-stream-refused" | "node-level5-open-writable-file-refused" | "node-level5-timer-background-task-refused" | "node-level5-cluster-mode-refused";
+type NodeLevel5ProductSnapshotRefusal = {
+    code: NodeLevel5ProductSnapshotRefusalCode;
+    message: string;
+};
+type NodeLevel5ProductTargetIdentity = {
+    kind: typeof NODE_LEVEL5_PRODUCT_TARGET_IDENTITY_KIND;
+    target: string;
+    targetKind: "pid" | "name" | "current-directory";
+    runtime: "node" | "unknown";
+    appDir?: string;
+    pid?: number;
+    executable?: string;
+    argv?: string;
+    registryMatched: boolean;
+    accepted: boolean;
+    refusal?: NodeLevel5ProductSnapshotRefusal;
+};
+type NodeLevel5ProductDetectedFeature = "safe-idle-timer" | "safe-outbound-http-reconnect";
+type NodeLevel5ProductDetectorReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_DETECTOR_REPORT_KIND;
+    accepted: boolean;
+    appDir: string;
+    familyId?: NodeLevel5ProductSupport80FamilyId;
+    direction: NodeLevel5ProductSnapshotDirection;
+    detectedFramework?: "express" | "fastify";
+    detectedFeatures?: NodeLevel5ProductDetectedFeature[];
+    refusal?: NodeLevel5ProductSnapshotRefusal;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ProductCaptureReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_CAPTURE_REPORT_KIND;
+    accepted: true;
+    productCommandPath: "machinen snapshot <vm-name> --out <dir>";
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: NodeLevel5ProductSnapshotDirection;
+    targetIdentitySha256: string;
+    detectorReportSha256: string;
+    artifactRoot: string;
+    translatedContinuationRequired: true;
+    targetNativeNodeRequired: true;
+    rawCpuRestoreCaptured: false;
+    sourceIsaEmulationCaptured: false;
+    metadataOnlySuccessAccepted: false;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ProductRestoreMaterializationReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_RESTORE_MATERIALIZATION_REPORT_KIND;
+    accepted: true;
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: NodeLevel5ProductSnapshotDirection;
+    captureReportVerified: boolean;
+    targetIdentityVerified: boolean;
+    detectorReportVerified: boolean;
+    targetNativeNodeVerified: boolean;
+    translatedContinuationRequired: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ProductRestoreLaunchReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_RESTORE_LAUNCH_REPORT_KIND;
+    accepted: boolean;
+    executable: string;
+    appDir: string;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    targetNativeNodeVerified: boolean;
+    translatedContinuationRequired: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ProductBehavioralVerifierReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_BEHAVIORAL_VERIFIER_REPORT_KIND;
+    accepted: boolean;
+    verifier: "target-native-http-loopback" | "target-native-app-route";
+    executable: string;
+    appDir: string;
+    routePath: string;
+    expectedStatus: number;
+    actualStatus?: number;
+    expectedBody: string;
+    actualBody?: string;
+    expectedHeaders?: Record<string, string>;
+    actualHeaders?: Record<string, string>;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    targetNativeNodeVerified: boolean;
+    translatedContinuationRequired: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ProductSnapshotManifest = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SNAPSHOT_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SNAPSHOT_VERSION;
+    status: "node-product-support-85";
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: NodeLevel5ProductSnapshotDirection;
+    artifactRoot: string;
+    detectorReportPath: "node-level5-detector-report.json";
+    detectorReportSha256: string;
+    targetIdentityPath: "node-level5-target-identity.json";
+    targetIdentitySha256: string;
+    captureReportPath: "node-level5-product-capture-report.json";
+    captureReportSha256: string;
+    artifactBundleKind: "machinen.node-level5-product-support-80-artifact-bundle";
+    translatedContinuationRequired: true;
+    targetNativeNodeRequired: true;
+    rawCpuRestoreSupported: false;
+    sourceIsaEmulationSupported: false;
+    appCheckpointHooksRequired: false;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ProductSnapshotSummary = {
+    kind: "machinen.node-level5-product-snapshot-summary";
+    accepted: boolean;
+    snapshotDir: string;
+    manifestPath?: string;
+    manifest?: NodeLevel5ProductSnapshotManifest;
+    targetIdentity: NodeLevel5ProductTargetIdentity;
+    detectorReport?: NodeLevel5ProductDetectorReport;
+    captureReport?: NodeLevel5ProductCaptureReport;
+    refusal?: NodeLevel5ProductSnapshotRefusal;
+};
+type NodeLevel5ProductRestoreSummary = {
+    kind: "machinen.node-level5-product-restore-summary";
+    accepted: boolean;
+    snapshotDir: string;
+    manifestPath: string;
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: NodeLevel5ProductSnapshotDirection;
+    targetIdentityVerified: boolean;
+    detectorReportVerified: boolean;
+    captureReportVerified: boolean;
+    materializationReportPath: string;
+    materializationReport: NodeLevel5ProductRestoreMaterializationReport;
+    launchReportPath: string;
+    launchReport: NodeLevel5ProductRestoreLaunchReport;
+    launchReportVerified: boolean;
+    behavioralVerifierReportPath: string;
+    behavioralVerifierReport: NodeLevel5ProductBehavioralVerifierReport;
+    targetNativeNodeVerified: boolean;
+    behavioralVerifierPassed: boolean;
+    artifactHashesVerified: boolean;
+    retentionComplete: boolean;
+    translatedContinuationRequired: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    nodeProductSupportClaimed: 85;
+    broadNodeProductSupportClaimed: 25;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5ProductSnapshot(input: {
+    outDir: string;
+    appDir?: string;
+    target?: Partial<NodeLevel5ProductTargetIdentity> & {
+        target: string;
+        targetKind: "pid" | "name";
+    };
+    direction?: NodeLevel5ProductSnapshotDirection;
+}): NodeLevel5ProductSnapshotSummary;
+declare function detectNodeLevel5ProductSnapshotApp(input: {
+    appDir: string;
+    direction?: NodeLevel5ProductSnapshotDirection;
+}): NodeLevel5ProductDetectorReport;
+declare function isNodeLevel5ProductSnapshotBundle(snapshotDir: string): boolean;
+declare function restoreNodeLevel5ProductSnapshot(input: {
+    snapshotDir: string;
+}): NodeLevel5ProductRestoreSummary;
+
+type NodeLevel5CorpusHttpEvidence = {
+    routePath: string;
+    expectedStatus: number;
+    actualStatus: number;
+    expectedBody: string;
+    actualBody: string;
+    expectedHeaders: Record<string, string>;
+    actualHeaders: Record<string, string>;
+    snapshotAccepted: boolean;
+    restoreAccepted: boolean;
+    behavioralVerifierPassed: boolean;
+    targetNativeNodeVerified: boolean;
+};
+
+declare const NODE_LEVEL5_REAL_APP_CORPUS_REPORT_KIND = "machinen.node-level5-real-app-corpus-report";
+declare const NODE_LEVEL5_REAL_APP_CORPUS_REPORT_VERSION = 1;
+type NodeLevel5RealAppCorpusFramework = "express" | "fastify";
+type NodeLevel5RealAppCorpusRow = NodeLevel5CorpusHttpEvidence & {
+    framework: NodeLevel5RealAppCorpusFramework;
+    direction: NodeLevel5ProductSnapshotDirection;
+};
+type NodeLevel5RealAppCorpusReport = {
+    kind: typeof NODE_LEVEL5_REAL_APP_CORPUS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_REAL_APP_CORPUS_REPORT_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    rowsSha256: string;
+    rows: NodeLevel5RealAppCorpusRow[];
+    harnessProof: true;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5RealAppCorpusVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-real-app-corpus-verification";
+    rowCount: number;
+    rowsSha256Verified: boolean;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5RealAppCorpusReport(rows: NodeLevel5RealAppCorpusRow[]): NodeLevel5RealAppCorpusReport;
+declare function writeNodeLevel5RealAppCorpusReport(input: {
+    path: string;
+    rows: NodeLevel5RealAppCorpusRow[];
+}): NodeLevel5RealAppCorpusReport;
+declare function verifyNodeLevel5RealAppCorpusReport(report: NodeLevel5RealAppCorpusReport): NodeLevel5RealAppCorpusVerification;
+declare function loadNodeLevel5RealAppCorpusReport(path: string): NodeLevel5RealAppCorpusReport;
+
+declare const NODE_LEVEL5_GENERIC_VM_CORPUS_REPORT_KIND = "machinen.node-level5-generic-vm-corpus-report";
+declare const NODE_LEVEL5_GENERIC_VM_CORPUS_REPORT_VERSION = 1;
+type NodeLevel5GenericVmModuleSystem = "cjs" | "esm";
+type NodeLevel5GenericVmRefusalMarker = "activeRequests" | "workerThreads" | "nativeAddons" | "tlsActiveState" | "childProcesses";
+type NodeLevel5GenericVmPositiveRow = {
+    kind: "positive";
+    id: string;
+    framework: NodeLevel5RealAppCorpusFramework;
+    moduleSystem: NodeLevel5GenericVmModuleSystem;
+    direction: NodeLevel5ProductSnapshotDirection;
+    productCommandPath: "machinen snapshot <vm-name> --out <dir>; machinen restore <dir>";
+    wholeVmSnapshot: true;
+    nodeDetectedInsideVm: true;
+    hostPidProductTargetingUsed: false;
+    nodeOnlyProductSelectorUsed: false;
+    snapshotAccepted: true;
+    restoreAccepted: true;
+    behaviorVerified: true;
+    targetNativeNodeVerified: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+};
+type NodeLevel5GenericVmRefusalRow = {
+    kind: "refusal";
+    id: string;
+    framework: NodeLevel5RealAppCorpusFramework;
+    marker: NodeLevel5GenericVmRefusalMarker;
+    direction: NodeLevel5ProductSnapshotDirection;
+    productCommandPath: "machinen snapshot <vm-name> --out <dir>";
+    expectedRefusalCode: NodeLevel5ProductSnapshotRefusalCode;
+    actualRefusalCode: NodeLevel5ProductSnapshotRefusalCode;
+    snapshotAccepted: false;
+    restoreAttempted: false;
+    refusedBeforeSnapshot: true;
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+};
+type NodeLevel5GenericVmCorpusRow = NodeLevel5GenericVmPositiveRow | NodeLevel5GenericVmRefusalRow;
+type NodeLevel5GenericVmCorpusReport = {
+    kind: typeof NODE_LEVEL5_GENERIC_VM_CORPUS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_GENERIC_VM_CORPUS_REPORT_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    positiveRowCount: number;
+    refusalRowCount: number;
+    rowsSha256: string;
+    rows: NodeLevel5GenericVmCorpusRow[];
+    claimChangeAllowed: false;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5GenericVmCorpusVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-generic-vm-corpus-verification";
+    rowCount: number;
+    positiveRowCount: number;
+    refusalRowCount: number;
+    rowsSha256Verified: boolean;
+    claimChangeAllowed: false;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5GenericVmCorpusReport(rows: NodeLevel5GenericVmCorpusRow[]): NodeLevel5GenericVmCorpusReport;
+declare function writeNodeLevel5GenericVmCorpusReport(input: {
+    path: string;
+    rows: NodeLevel5GenericVmCorpusRow[];
+}): NodeLevel5GenericVmCorpusReport;
+declare function verifyNodeLevel5GenericVmCorpusReport(report: NodeLevel5GenericVmCorpusReport): NodeLevel5GenericVmCorpusVerification;
+declare function loadNodeLevel5GenericVmCorpusReport(path: string): NodeLevel5GenericVmCorpusReport;
+
+declare const NODE_LEVEL5_GENERIC_VM_REFUSAL_ARTIFACTS_REPORT_KIND = "machinen.node-level5-generic-vm-refusal-artifacts-report";
+declare const NODE_LEVEL5_GENERIC_VM_REFUSAL_ARTIFACTS_REPORT_VERSION = 1;
+type NodeLevel5GenericVmRefusalArtifactFile = {
+    rowId: string;
+    framework: NodeLevel5GenericVmRefusalRow["framework"];
+    marker: NodeLevel5GenericVmRefusalMarker;
+    direction: NodeLevel5GenericVmRefusalRow["direction"];
+    expectedRefusalCode: NodeLevel5GenericVmRefusalRow["expectedRefusalCode"];
+    path: string;
+    sha256: string;
+    required: true;
+};
+type NodeLevel5GenericVmRefusalArtifactsReport = {
+    kind: typeof NODE_LEVEL5_GENERIC_VM_REFUSAL_ARTIFACTS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_GENERIC_VM_REFUSAL_ARTIFACTS_REPORT_VERSION;
+    accepted: boolean;
+    refusalRowCount: number;
+    refusalArtifactFiles: NodeLevel5GenericVmRefusalArtifactFile[];
+    refusalArtifactFileCount: number;
+    refusalArtifactFilesSha256: string;
+    markersCovered: NodeLevel5GenericVmRefusalMarker[];
+    claimChangeAllowed: false;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5GenericVmRefusalArtifactsVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-generic-vm-refusal-artifacts-verification";
+    refusalArtifactFileCount: number;
+    markersCovered: NodeLevel5GenericVmRefusalMarker[];
+    refusalArtifactFilesSha256Verified: boolean;
+    claimChangeAllowed: false;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5GenericVmRefusalArtifactsReport(input: {
+    corpusReport: NodeLevel5GenericVmCorpusReport;
+    outDir: string;
+}): NodeLevel5GenericVmRefusalArtifactsReport;
+declare function writeNodeLevel5GenericVmRefusalArtifactsReport(input: {
+    corpusReport: NodeLevel5GenericVmCorpusReport;
+    outDir: string;
+    path: string;
+}): NodeLevel5GenericVmRefusalArtifactsReport;
+declare function verifyNodeLevel5GenericVmRefusalArtifactsReport(report: NodeLevel5GenericVmRefusalArtifactsReport): NodeLevel5GenericVmRefusalArtifactsVerification;
+declare function loadNodeLevel5GenericVmRefusalArtifactsReport(path: string): NodeLevel5GenericVmRefusalArtifactsReport;
+
+declare const NODE_LEVEL5_GENERIC_VM_RETAINED_EVIDENCE_REPORT_KIND = "machinen.node-level5-generic-vm-retained-evidence-report";
+declare const NODE_LEVEL5_GENERIC_VM_RETAINED_EVIDENCE_REPORT_VERSION = 1;
+type NodeLevel5GenericVmRetainedEvidenceFile = {
+    path: string;
+    sha256: string;
+    required: true;
+};
+type NodeLevel5GenericVmRetainedEvidenceReport = {
+    kind: typeof NODE_LEVEL5_GENERIC_VM_RETAINED_EVIDENCE_REPORT_KIND;
+    version: typeof NODE_LEVEL5_GENERIC_VM_RETAINED_EVIDENCE_REPORT_VERSION;
+    accepted: boolean;
+    productCommandPath: "machinen snapshot <vm-name> --out <dir>; machinen restore <dir>";
+    vmDetectedNodeWorkload: true;
+    restoreProbePassed: true;
+    retainedFiles: NodeLevel5GenericVmRetainedEvidenceFile[];
+    retainedFileCount: number;
+    retainedFilesSha256: string;
+    claimChangeAllowed: false;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5GenericVmRetainedEvidenceVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-generic-vm-retained-evidence-verification";
+    retainedFileCount: number;
+    retainedFilesSha256Verified: boolean;
+    claimChangeAllowed: false;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5GenericVmRetainedEvidenceReport(input: {
+    workDir: string;
+}): NodeLevel5GenericVmRetainedEvidenceReport;
+declare function writeNodeLevel5GenericVmRetainedEvidenceReport(input: {
+    workDir: string;
+    path: string;
+}): NodeLevel5GenericVmRetainedEvidenceReport;
+declare function verifyNodeLevel5GenericVmRetainedEvidenceReport(report: NodeLevel5GenericVmRetainedEvidenceReport): NodeLevel5GenericVmRetainedEvidenceVerification;
+declare function loadNodeLevel5GenericVmRetainedEvidenceReport(path: string): NodeLevel5GenericVmRetainedEvidenceReport;
+
+declare const NODE_LEVEL5_GENERIC_VM_ROW_ARTIFACTS_REPORT_KIND = "machinen.node-level5-generic-vm-row-artifacts-report";
+declare const NODE_LEVEL5_GENERIC_VM_ROW_ARTIFACTS_REPORT_VERSION = 1;
+type NodeLevel5GenericVmRowArtifactFile = {
+    rowId: string;
+    rowKind: NodeLevel5GenericVmCorpusRow["kind"];
+    path: string;
+    sha256: string;
+    required: true;
+};
+type NodeLevel5GenericVmRowArtifactsReport = {
+    kind: typeof NODE_LEVEL5_GENERIC_VM_ROW_ARTIFACTS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_GENERIC_VM_ROW_ARTIFACTS_REPORT_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    positiveRowCount: number;
+    refusalRowCount: number;
+    rowArtifactFiles: NodeLevel5GenericVmRowArtifactFile[];
+    rowArtifactFileCount: number;
+    rowArtifactFilesSha256: string;
+    claimChangeAllowed: false;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5GenericVmRowArtifactsVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-generic-vm-row-artifacts-verification";
+    rowCount: number;
+    positiveRowCount: number;
+    refusalRowCount: number;
+    rowArtifactFileCount: number;
+    rowArtifactFilesSha256Verified: boolean;
+    claimChangeAllowed: false;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5GenericVmRowArtifactsReport(input: {
+    corpusReport: NodeLevel5GenericVmCorpusReport;
+    outDir: string;
+}): NodeLevel5GenericVmRowArtifactsReport;
+declare function writeNodeLevel5GenericVmRowArtifactsReport(input: {
+    corpusReport: NodeLevel5GenericVmCorpusReport;
+    outDir: string;
+    path: string;
+}): NodeLevel5GenericVmRowArtifactsReport;
+declare function verifyNodeLevel5GenericVmRowArtifactsReport(report: NodeLevel5GenericVmRowArtifactsReport): NodeLevel5GenericVmRowArtifactsVerification;
+declare function loadNodeLevel5GenericVmRowArtifactsReport(path: string): NodeLevel5GenericVmRowArtifactsReport;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_85_READINESS_KIND = "machinen.node-level5-product-support-85-readiness";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_85_READINESS_VERSION = 1;
+type NodeLevel5ProductSupport85ReadinessGateStatus = "passed" | "blocked";
+type NodeLevel5ProductSupport85ReadinessGateId = "generic-vm-corpus-accepted" | "generic-vm-positive-row-count" | "generic-vm-refusal-row-count" | "generic-vm-corpus-hash-verified" | "generic-vm-retained-evidence-accepted" | "generic-vm-retained-evidence-files" | "generic-vm-row-artifacts-accepted" | "generic-vm-row-artifacts-complete" | "generic-vm-refusal-artifacts-accepted" | "generic-vm-refusal-artifacts-complete" | "claim-values-remain-current" | "claim-change-unlocked";
+type NodeLevel5ProductSupport85ReadinessGate = {
+    id: NodeLevel5ProductSupport85ReadinessGateId;
+    status: NodeLevel5ProductSupport85ReadinessGateStatus;
+    message: string;
+};
+type NodeLevel5ProductSupport85ReadinessReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_85_READINESS_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_85_READINESS_VERSION;
+    accepted: boolean;
+    candidateEvidenceAccepted: boolean;
+    claimChangeAllowed: false;
+    currentNodeProductSupportClaimed: 80;
+    currentBroadNodeProductSupportClaimed: 20;
+    currentArbitraryProcessCrossArchRestoreClaimed: 0;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    candidateArbitraryProcessCrossArchRestoreClaimed: 0;
+    gates: NodeLevel5ProductSupport85ReadinessGate[];
+    blockedGates: NodeLevel5ProductSupport85ReadinessGate[];
+};
+declare function loadNodeLevel5ProductSupport85ReadinessReport(path: string): NodeLevel5ProductSupport85ReadinessReport;
+declare function evaluateNodeLevel5ProductSupport85Readiness(input: {
+    genericVmCorpusReport: NodeLevel5GenericVmCorpusReport;
+    genericVmRetainedEvidenceReport?: NodeLevel5GenericVmRetainedEvidenceReport;
+    genericVmRowArtifactsReport?: NodeLevel5GenericVmRowArtifactsReport;
+    genericVmRefusalArtifactsReport?: NodeLevel5GenericVmRefusalArtifactsReport;
+}): NodeLevel5ProductSupport85ReadinessReport;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_85_CLAIM_READY_KIND = "machinen.node-level5-product-support-85-claim-ready";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_85_CLAIM_READY_VERSION = 1;
+type NodeLevel5ProductSupport85ClaimReadyGateStatus = "passed" | "blocked";
+type NodeLevel5ProductSupport85ClaimReadyGateId = "readiness-report-shape" | "candidate-evidence-complete" | "only-claim-unlock-blocked" | "matrix-counts-stable" | "claim-values-current" | "candidate-target-present" | "arbitrary-process-remains-zero" | "claim-change-unlocked";
+type NodeLevel5ProductSupport85ClaimReadyGate = {
+    id: NodeLevel5ProductSupport85ClaimReadyGateId;
+    status: NodeLevel5ProductSupport85ClaimReadyGateStatus;
+    message: string;
+};
+type NodeLevel5ProductSupport85ClaimReadyReport = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_85_CLAIM_READY_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_85_CLAIM_READY_VERSION;
+    accepted: boolean;
+    claimReadyEvidenceAccepted: boolean;
+    claimChangeAllowed: true;
+    currentNodeProductSupportClaimed: 85;
+    currentBroadNodeProductSupportClaimed: 25;
+    currentArbitraryProcessCrossArchRestoreClaimed: 0;
+    candidateNodeProductSupportClaimed: 85;
+    candidateBroadNodeProductSupportClaimed: 25;
+    candidateArbitraryProcessCrossArchRestoreClaimed: 0;
+    matrixCounts: {
+        total: 114;
+        supported: 68;
+        refused: 42;
+        notProven: 4;
+    };
+    gates: NodeLevel5ProductSupport85ClaimReadyGate[];
+    blockedGates: NodeLevel5ProductSupport85ClaimReadyGate[];
+};
+declare function evaluateNodeLevel5ProductSupport85ClaimReady(input: {
+    readinessReport: NodeLevel5ProductSupport85ReadinessReport;
+    appSupportMatrix?: NodeLevel5AppSupportMatrix;
+}): NodeLevel5ProductSupport85ClaimReadyReport;
+
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_80_ARTIFACT_BUNDLE_KIND = "machinen.node-level5-product-support-80-artifact-bundle";
+declare const NODE_LEVEL5_PRODUCT_SUPPORT_80_HARDENING_KIND = "machinen.node-level5-product-support-80-hardening";
+type NodeLevel5ProductSupport80ArtifactBundle = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_80_ARTIFACT_BUNDLE_KIND;
+    version: typeof NODE_LEVEL5_PRODUCT_SUPPORT_80_VERSION;
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: "arm64-to-amd64" | "amd64-to-arm64";
+    artifactRoot: string;
+    manifestPath: string;
+    captureSummaryPath: string;
+    restoreSummaryPath: string;
+    targetLogPath: string;
+    targetNativeVerifierPath: string;
+    behavioralVerifierPath: string;
+    refusalRowsPath: string;
+    versionInfoPath: string;
+    triageBundlePath: string;
+    evidence: NodeLevel5RealVmCrossArchEvidence;
+};
+type NodeLevel5ProductSupport80ArtifactVerification = {
+    accepted: boolean;
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: "arm64-to-amd64" | "amd64-to-arm64";
+    checkedPaths: readonly string[];
+    targetNativeNodeVerified: boolean;
+    behavioralVerifierPassed: boolean;
+    rawCpuRestoreUsed: boolean;
+    sourceIsaEmulationUsed: boolean;
+    metadataOnlySuccessAccepted: boolean;
+    manifestSchemaVerified: boolean;
+    artifactHashesVerified: boolean;
+    retentionComplete: boolean;
+};
+type NodeLevel5ProductSupport80UnsupportedDetector = NodeLevel5ProductUnsupportedNeighbor & {
+    detector: string;
+    stable: true;
+    artifactRequired: true;
+};
+type NodeLevel5ProductSupport80ClaimRegistry = {
+    kind: typeof NODE_LEVEL5_PRODUCT_SUPPORT_80_HARDENING_KIND;
+    status: "node-product-support-80-hardened";
+    declaredSubsetExperimentalProductSupportClaimed: 100;
+    nodeProductSupportTiers: readonly [20, 50, 65, 80];
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+    realVmCrossArchEvidenceRequired: true;
+    artifactRetentionDays: 30;
+    flakeBudgetPercent: 0;
+    supportedFamilyCount: 17;
+    unsupportedDetectorCount: number;
+};
+declare const nodeLevel5ProductSupport80UnsupportedDetectors: readonly NodeLevel5ProductSupport80UnsupportedDetector[];
+declare const nodeLevel5ProductSupport80ClaimRegistry: NodeLevel5ProductSupport80ClaimRegistry;
+declare function createNodeLevel5ProductSupport80ArtifactBundle(input: {
+    outDir: string;
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: "arm64-to-amd64" | "amd64-to-arm64";
+}): NodeLevel5ProductSupport80ArtifactBundle;
+declare function loadNodeLevel5ProductSupport80ArtifactBundle(input: {
+    artifactRoot: string;
+    familyId: NodeLevel5ProductSupport80FamilyId;
+    direction: "arm64-to-amd64" | "amd64-to-arm64";
+}): NodeLevel5ProductSupport80ArtifactBundle;
+declare function verifyNodeLevel5ProductSupport80ArtifactBundle(bundle: NodeLevel5ProductSupport80ArtifactBundle): NodeLevel5ProductSupport80ArtifactVerification;
+declare function assertNodeLevel5ProductSupport80HardeningComplete(): boolean;
+
+declare const NODE_LEVEL5_INSTALLED_THIRD_PARTY_APP_CORPUS_REPORT_KIND = "machinen.node-level5-installed-third-party-app-corpus-report";
+declare const NODE_LEVEL5_INSTALLED_THIRD_PARTY_APP_CORPUS_REPORT_VERSION = 1;
+type NodeLevel5InstalledThirdPartyAppSource = "express-installed-hello-world" | "express-installed-router" | "express-installed-json-response" | "express-installed-route-params" | "express-installed-query-string" | "express-installed-static-asset" | "express-installed-idle-timer" | "express-installed-safe-outbound-reconnect" | "express-installed-post-json-body" | "express-installed-custom-header" | "express-installed-put-route" | "express-installed-delete-route" | "express-installed-cookie-read" | "express-installed-status-code" | "express-installed-redirect" | "express-installed-response-header" | "express-installed-middleware-chain" | "express-installed-not-found" | "express-installed-error-handler" | "express-installed-request-id" | "express-installed-nested-router" | "express-installed-optional-param" | "express-installed-multi-route" | "express-installed-static-cache-header" | "express-installed-env-read" | "express-installed-config-json-read" | "express-installed-feature-flag-env" | "express-installed-configured-prefix" | "express-installed-health-check" | "fastify-installed-getting-started" | "fastify-installed-plugin-route" | "fastify-installed-json-response" | "fastify-installed-route-params" | "fastify-installed-query-string" | "fastify-installed-static-asset" | "fastify-installed-idle-timer" | "fastify-installed-safe-outbound-reconnect" | "fastify-installed-post-json-body" | "fastify-installed-custom-header" | "fastify-installed-put-route" | "fastify-installed-delete-route" | "fastify-installed-cookie-read" | "fastify-installed-status-code" | "fastify-installed-redirect" | "fastify-installed-response-header" | "fastify-installed-hook-chain" | "fastify-installed-not-found" | "fastify-installed-error-handler" | "fastify-installed-request-id" | "fastify-installed-prefix-route" | "fastify-installed-optional-param" | "fastify-installed-multi-route" | "fastify-installed-static-cache-header" | "fastify-installed-env-read" | "fastify-installed-config-json-read" | "fastify-installed-feature-flag-env" | "fastify-installed-configured-prefix" | "fastify-installed-health-check";
+type NodeLevel5InstalledThirdPartyAppCorpusRow = NodeLevel5CorpusHttpEvidence & {
+    appName: string;
+    source: NodeLevel5InstalledThirdPartyAppSource;
+    framework: NodeLevel5RealAppCorpusFramework;
+    direction: NodeLevel5ProductSnapshotDirection;
+    installedPackage: string;
+    installedPackageVersion: string;
+    declaredSubset: true;
+    unsupportedStateDetected: false;
+};
+type NodeLevel5InstalledThirdPartyAppCorpusReport = {
+    kind: typeof NODE_LEVEL5_INSTALLED_THIRD_PARTY_APP_CORPUS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_INSTALLED_THIRD_PARTY_APP_CORPUS_REPORT_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    rowsSha256: string;
+    rows: NodeLevel5InstalledThirdPartyAppCorpusRow[];
+    harnessProof: true;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5InstalledThirdPartyAppCorpusVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-installed-third-party-app-corpus-verification";
+    rowCount: number;
+    rowsSha256Verified: boolean;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5InstalledThirdPartyAppCorpusReport(rows: NodeLevel5InstalledThirdPartyAppCorpusRow[]): NodeLevel5InstalledThirdPartyAppCorpusReport;
+declare function writeNodeLevel5InstalledThirdPartyAppCorpusReport(input: {
+    path: string;
+    rows: NodeLevel5InstalledThirdPartyAppCorpusRow[];
+}): NodeLevel5InstalledThirdPartyAppCorpusReport;
+declare function verifyNodeLevel5InstalledThirdPartyAppCorpusReport(report: NodeLevel5InstalledThirdPartyAppCorpusReport): NodeLevel5InstalledThirdPartyAppCorpusVerification;
+declare function loadNodeLevel5InstalledThirdPartyAppCorpusReport(path: string): NodeLevel5InstalledThirdPartyAppCorpusReport;
+
+declare const NODE_LEVEL5_THIRD_PARTY_APP_CORPUS_REPORT_KIND = "machinen.node-level5-third-party-app-corpus-report";
+declare const NODE_LEVEL5_THIRD_PARTY_APP_CORPUS_REPORT_VERSION = 1;
+type NodeLevel5ThirdPartyAppSource = "express-official-hello-world" | "express-generator-router" | "fastify-official-getting-started" | "fastify-plugin-route";
+type NodeLevel5ThirdPartyAppCorpusRow = NodeLevel5CorpusHttpEvidence & {
+    appName: string;
+    source: NodeLevel5ThirdPartyAppSource;
+    framework: NodeLevel5RealAppCorpusFramework;
+    direction: NodeLevel5ProductSnapshotDirection;
+    declaredSubset: true;
+    unsupportedStateDetected: false;
+};
+type NodeLevel5ThirdPartyAppCorpusReport = {
+    kind: typeof NODE_LEVEL5_THIRD_PARTY_APP_CORPUS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_THIRD_PARTY_APP_CORPUS_REPORT_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    rowsSha256: string;
+    rows: NodeLevel5ThirdPartyAppCorpusRow[];
+    harnessProof: true;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5ThirdPartyAppCorpusVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-third-party-app-corpus-verification";
+    rowCount: number;
+    rowsSha256Verified: boolean;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5ThirdPartyAppCorpusReport(rows: NodeLevel5ThirdPartyAppCorpusRow[]): NodeLevel5ThirdPartyAppCorpusReport;
+declare function writeNodeLevel5ThirdPartyAppCorpusReport(input: {
+    path: string;
+    rows: NodeLevel5ThirdPartyAppCorpusRow[];
+}): NodeLevel5ThirdPartyAppCorpusReport;
+declare function verifyNodeLevel5ThirdPartyAppCorpusReport(report: NodeLevel5ThirdPartyAppCorpusReport): NodeLevel5ThirdPartyAppCorpusVerification;
+declare function loadNodeLevel5ThirdPartyAppCorpusReport(path: string): NodeLevel5ThirdPartyAppCorpusReport;
+
+declare const NODE_LEVEL5_REAL_APP_REFUSAL_CORPUS_REPORT_KIND = "machinen.node-level5-real-app-refusal-corpus-report";
+declare const NODE_LEVEL5_REAL_APP_REFUSAL_CORPUS_REPORT_VERSION = 1;
+type NodeLevel5RealAppRefusalMarker = "activeRequests" | "workerThreads" | "nativeAddons" | "wasmExternalMemory" | "tlsActiveState" | "childProcesses" | "filesystemWatchers" | "websockets" | "dbConnections" | "redisQueueConnections" | "outboundHttpSockets" | "http2Sessions" | "serverSentEvents" | "openWritableFiles" | "timersIntervals" | "clusterMode";
+type NodeLevel5RealAppRefusalCorpusRow = {
+    framework: NodeLevel5RealAppCorpusFramework;
+    direction: NodeLevel5ProductSnapshotDirection;
+    marker: NodeLevel5RealAppRefusalMarker;
+    expectedRefusalCode: NodeLevel5ProductSnapshotRefusalCode;
+    actualRefusalCode: NodeLevel5ProductSnapshotRefusalCode;
+    snapshotAccepted: false;
+    snapshotManifestWritten: false;
+    refusedBeforeSnapshot: true;
+    productCommandPath: "machinen snapshot <vm-name> --out <dir>";
+    rawCpuRestoreUsed: false;
+    sourceIsaEmulationUsed: false;
+    metadataOnlySuccessAccepted: false;
+};
+type NodeLevel5RealAppRefusalCorpusReport = {
+    kind: typeof NODE_LEVEL5_REAL_APP_REFUSAL_CORPUS_REPORT_KIND;
+    version: typeof NODE_LEVEL5_REAL_APP_REFUSAL_CORPUS_REPORT_VERSION;
+    accepted: boolean;
+    rowCount: number;
+    rowsSha256: string;
+    rows: NodeLevel5RealAppRefusalCorpusRow[];
+    harnessProof: true;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+type NodeLevel5RealAppRefusalCorpusVerification = {
+    accepted: boolean;
+    kind: "machinen.node-level5-real-app-refusal-corpus-verification";
+    rowCount: number;
+    rowsSha256Verified: boolean;
+    nodeProductSupportClaimed: 80;
+    broadNodeProductSupportClaimed: 20;
+    arbitraryProcessCrossArchRestoreClaimed: 0;
+};
+declare function createNodeLevel5RealAppRefusalCorpusReport(rows: NodeLevel5RealAppRefusalCorpusRow[]): NodeLevel5RealAppRefusalCorpusReport;
+declare function writeNodeLevel5RealAppRefusalCorpusReport(input: {
+    path: string;
+    rows: NodeLevel5RealAppRefusalCorpusRow[];
+}): NodeLevel5RealAppRefusalCorpusReport;
+declare function verifyNodeLevel5RealAppRefusalCorpusReport(report: NodeLevel5RealAppRefusalCorpusReport): NodeLevel5RealAppRefusalCorpusVerification;
+declare function loadNodeLevel5RealAppRefusalCorpusReport(path: string): NodeLevel5RealAppRefusalCorpusReport;
+
 /**
  * Transparent native cross-ISA process image contract.
  *
@@ -2236,7 +3980,7 @@ declare const NATIVE_PROCESS_IMAGE_FILES: {
 };
 declare const nativeProcessImageArchitectures: readonly ["arm64", "amd64"];
 type NativeProcessImageArchitecture = (typeof nativeProcessImageArchitectures)[number];
-declare const nativeProcessImageRefusalCodes: readonly ["active-syscall", "architecture-pair-unsupported", "architecture-unsupported", "blocking-syscall-state-unsupported", "code-location-unknown", "fd-kind-unsupported", "futex-state-unsupported", "inherited-stdio-policy-required", "kernel-state-unsupported", "mapping-ambiguous", "mapping-permission-unsupported", "mapping-unreadable", "pointer-ambiguous", "resource-kind-unsupported", "non-stdio-kernel-state-unsupported", "rseq-state-unsupported", "signal-frame-active", "signal-state-unsupported", "stdin-buffer-state-unsupported", "syscall-argument-state-unsupported", "syscall-restart-unsupported", "target-build-id-mismatch", "target-build-mismatch", "target-code-location-unresolved", "target-callee-saved-state-unsupported", "target-caller-frame-unavailable", "target-code-rva-unmapped", "target-frame-layout-unsupported", "target-frame-register-value-unavailable", "target-module-bytes-missing", "target-module-file-missing", "target-module-missing", "target-module-not-executable", "target-module-range-unreadable", "target-ppoll-syscall-continuation-missing", "target-ppoll-timeout-missing", "target-return-slot-unsupported", "target-resume-execution-unavailable", "target-resume-fault-invalid-code-landing", "target-resume-fault-outside-target-bytes", "target-resume-fault-privileged-instruction", "target-resume-fault-signal-unsupported", "target-resume-fault-timeout", "target-resume-fault-unmodeled-memory", "target-semantic-continuation-missing", "target-sleep-remaining-time-missing", "target-sleep-signal-restart-unsupported", "target-sleep-syscall-continuation-missing", "target-synthetic-signal-restart-unsupported", "target-synthetic-syscall-return-unmodeled", "thread-state-unsupported", "tls-state-unsupported", "return-slot-unreadable", "target-unwind-mismatch", "unwind-fde-missing", "unwind-metadata-missing", "unwind-rule-unsupported", "vdso-policy-unsupported"];
+declare const nativeProcessImageRefusalCodes: readonly ["active-syscall", "architecture-pair-unsupported", "architecture-unsupported", "blocking-syscall-state-unsupported", "code-location-unknown", "cross-isa-vmstate-restore-unsupported", "fd-kind-unsupported", "futex-state-unsupported", "inherited-stdio-policy-required", "kernel-state-unsupported", "mapping-ambiguous", "mapping-captured-range-unsupported", "mapping-executable-unsupported", "mapping-permission-unsupported", "mapping-provenance-ambiguous", "mapping-shared-unsupported", "mapping-unreadable", "pointer-ambiguous", "proof-arch-pair-unsupported", "resource-kind-unsupported", "non-stdio-kernel-state-unsupported", "rseq-state-unsupported", "signal-frame-active", "signal-state-unsupported", "simd-fpu-state-unsupported", "stdin-buffer-state-unsupported", "syscall-argument-state-unsupported", "syscall-restart-unsupported", "target-build-id-mismatch", "target-build-mismatch", "target-code-location-unresolved", "target-callee-saved-state-unsupported", "target-caller-frame-unavailable", "target-code-rva-unmapped", "target-code-outside-portable-bundle", "target-epoll-syscall-state-unsupported", "target-fd-table-duplicate", "target-fd-read-state-missing", "target-fd-write-state-missing", "target-fd-table-missing", "target-frame-layout-unsupported", "target-frame-register-value-unavailable", "target-module-bytes-missing", "target-module-file-missing", "target-module-missing", "target-module-not-executable", "target-module-range-unreadable", "target-ppoll-syscall-continuation-missing", "target-ppoll-timeout-missing", "target-process-context-unsupported", "target-return-slot-unsupported", "target-signalfd-state-unsupported", "target-resume-execution-unavailable", "target-resume-fault-invalid-code-landing", "target-resume-fault-outside-target-bytes", "target-resume-fault-privileged-instruction", "target-resume-fault-signal-unsupported", "target-resume-fault-timeout", "target-resume-fault-unmodeled-memory", "target-semantic-continuation-missing", "target-sleep-remaining-time-missing", "target-socket-syscall-state-unsupported", "target-sleep-signal-restart-unsupported", "target-sleep-syscall-continuation-missing", "target-stack-window-unsupported", "target-synthetic-signal-interrupted-unsupported", "target-synthetic-signal-restart-unsupported", "target-synthetic-syscall-return-unmodeled", "thread-state-unsupported", "tls-state-unsupported", "return-slot-unreadable", "target-unwind-mismatch", "unwind-fde-missing", "unwind-metadata-missing", "unwind-rule-unsupported", "vdso-policy-unsupported"];
 type NativeProcessImageRefusalCode = (typeof nativeProcessImageRefusalCodes)[number];
 interface NativeProcessImageRefusal {
     code: NativeProcessImageRefusalCode;
@@ -2337,6 +4081,37 @@ interface NativeAmd64Registers {
     gsBase: string;
 }
 type NativeRegisterState = NativeArm64Registers | NativeAmd64Registers;
+type NativeTlsThreadPointerRegister = "arm64-tpidr-el0" | "amd64-fs-base";
+type NativeTlsAmd64SegmentBases = {
+    state: "not-required";
+    fsBase: string;
+    gsBase: string;
+    reason?: string;
+} | {
+    state: "provided";
+    fsBase: string;
+    gsBase: string;
+    provenance?: string;
+} | {
+    state: "unsupported";
+    reason?: string;
+    refusal?: NativeProcessImageRefusal;
+};
+type NativeSimdFpuLiveSubset = "fp-control-state" | "caller-saved-vector-registers" | "callee-saved-vector-registers" | "unknown-live-state";
+type NativeSimdFpuState = {
+    state: "not-live";
+    provenance?: string;
+} | {
+    state: "requires-restore";
+    arch?: NativeProcessImageArchitecture;
+    byteLength?: number;
+    liveSubset?: NativeSimdFpuLiveSubset;
+    reason?: string;
+} | {
+    state: "not-captured" | "unsupported";
+    reason?: string;
+    refusal?: NativeProcessImageRefusal;
+};
 interface NativeThreadState {
     id: string;
     lwpid?: number;
@@ -2365,11 +4140,14 @@ interface NativeThreadState {
     };
     tls: {
         threadPointer: string;
+        sourceRegister?: NativeTlsThreadPointerRegister;
+        targetSegmentBases?: NativeTlsAmd64SegmentBases;
         rseq: {
             state: "absent" | "captured" | "unsupported";
             refusal?: NativeProcessImageRefusal;
         };
     };
+    simdFpu?: NativeSimdFpuState;
     refusal?: NativeProcessImageRefusal;
 }
 interface NativeProcessImageThreads {
@@ -2377,7 +4155,7 @@ interface NativeProcessImageThreads {
     threads: NativeThreadState[];
     refusals: NativeProcessImageRefusals;
 }
-type NativeProcessResourceKind = "argv" | "env" | "cwd" | "exe" | "auxv" | "fd" | "file" | "pipe" | "socket" | "raw-socket" | "pty" | "timer" | "eventfd" | "signal" | "namespace" | "credential" | "futex" | "epoll" | "unknown";
+type NativeProcessResourceKind = "argv" | "env" | "cwd" | "exe" | "auxv" | "fd" | "file" | "pipe" | "socket" | "raw-socket" | "pty" | "timer" | "eventfd" | "signal" | "signalfd" | "namespace" | "credential" | "futex" | "epoll" | "unknown";
 interface NativeProcessResource {
     id: string;
     kind: NativeProcessResourceKind;
@@ -2667,12 +4445,26 @@ declare function buildNativeCodeMap(request: NativeCodeMapRequest): NativeCodeMa
 
 /** Active native syscall classification for actual real-utility attempts. */
 
-type NativeActiveSyscallClass = "outside-syscall" | "sleep-timer" | "poll-timeout" | "fd-blocking" | "restart" | "unknown-active";
+type NativeActiveSyscallClass = "outside-syscall" | "sleep-timer" | "poll-timeout" | "fd-blocking" | "futex-wait" | "restart" | "unknown-active";
 type NativeSleepTimerSyscallPolicy = "refuse" | "defer-target-resume";
 type NativePollTimeoutSyscallPolicy = "refuse" | "defer-target-resume";
+type NativePollTimeoutFdPolicy = "zero-fd-only" | "synthetic-empty-pipe" | "synthetic-empty-eventfd" | "synthetic-timerfd";
+type NativeFdReadPolicy = "refuse" | "defer-target-resume";
+type NativeFdReadResourcePolicy = "synthetic-empty-pipe" | "synthetic-empty-eventfd" | "synthetic-timerfd" | "reopen-file";
+type NativeFdWritePolicy = "refuse" | "defer-target-resume";
+type NativeFdWriteResourcePolicy = "reopen-file";
+type NativePingSocketRecvmsgPolicy = "refuse" | "defer-target-resume";
 interface NativeActiveSyscallPolicyOptions {
     sleepTimerPolicy?: NativeSleepTimerSyscallPolicy;
     pollTimeoutPolicy?: NativePollTimeoutSyscallPolicy;
+    pollTimeoutFdPolicy?: NativePollTimeoutFdPolicy;
+    fdReadPolicy?: NativeFdReadPolicy;
+    fdReadResourcePolicy?: NativeFdReadResourcePolicy;
+    fdWritePolicy?: NativeFdWritePolicy;
+    fdWriteResourcePolicy?: NativeFdWriteResourcePolicy;
+    pingSocketRecvmsgPolicy?: NativePingSocketRecvmsgPolicy;
+    pingSocketRecvmsgSourceFd?: number;
+    pingSocketRecvmsgTargetFd?: number;
     documents?: NativeProcessImageDocuments;
 }
 interface NativeSleepTimerDuration {
@@ -2702,18 +4494,68 @@ interface NativeModeledSleepTimerState {
     requestedTime: NativeSleepTimerDuration;
     remainingTime: NativeModeledSleepTimerRemainingTime;
 }
+type NativeModeledPpollTargetResource = "synthetic-empty-pipe-read-end" | "synthetic-empty-eventfd" | "synthetic-timerfd";
+interface NativeModeledPpollFdState {
+    fd: number;
+    events: number;
+    revents: number;
+    sourceAddress: string;
+    resourceId?: string;
+    targetResource: NativeModeledPpollTargetResource;
+}
 interface NativeModeledPpollTimeoutState {
     kind: "relative-duration";
     syscallName: "ppoll";
     argumentSource: "proc-syscall" | "registers";
-    fdsPointer: "0x0";
-    nfds: 0;
+    fdsPointer: string;
+    nfds: 0 | 1;
+    pollFds?: NativeModeledPpollFdState[];
     timeoutPointer: string;
     sigmaskPointer: "0x0";
     sigsetSize?: string;
     requestedTime: NativeSleepTimerDuration;
     remainingTime: NativeModeledPpollTimeoutRemainingTime;
 }
+type NativeModeledFdReadTargetResource = "synthetic-empty-pipe-read-end" | "synthetic-empty-eventfd" | "synthetic-timerfd" | "reopened-offset-file";
+interface NativeModeledFdReadTimerRemainingTime extends NativeSleepTimerDuration {
+    state: "modeled";
+    kind: "relative-duration";
+    source: "active-syscall-timerfd-read-timeout";
+    precision: "captured-fdinfo-upper-bound";
+}
+interface NativeModeledFdReadState {
+    kind: "fd-read-block";
+    syscallName: "read" | "pread64" | "readv";
+    argumentSource: "proc-syscall" | "registers";
+    fd: number;
+    bufferPointer: string;
+    countBytes: number;
+    iovPointer?: string;
+    iovCount?: 1;
+    bufferMapping: string;
+    resourceId: string;
+    pairedWriteResourceId?: string;
+    targetResource: NativeModeledFdReadTargetResource;
+    targetBufferPointer?: string;
+    fileOffset?: number;
+    remainingTime?: NativeModeledFdReadTimerRemainingTime;
+}
+type NativeModeledFdWriteTargetResource = "reopened-offset-file";
+interface NativeModeledFdWriteState {
+    kind: "fd-write-complete";
+    syscallName: "write" | "pwrite64" | "writev";
+    argumentSource: "proc-syscall" | "registers";
+    fd: number;
+    bufferPointer: string;
+    countBytes: number;
+    iovPointer?: string;
+    iovCount?: 1;
+    bufferMapping: string;
+    resourceId: string;
+    targetResource: NativeModeledFdWriteTargetResource;
+    targetBufferPointer: string;
+    fileOffset: number;
+}
 type NativeSleepTimerModelResult = {
     state: "modeled";
     timer: NativeModeledSleepTimerState;
@@ -2728,17 +4570,60 @@ type NativePpollTimeoutModelResult = {
     state: "missing";
     refusal: NativeProcessImageRefusal;
 };
-interface NativeActiveSleepTimerContinuation {
-    threadId: string;
-    syscallClass: Extract<NativeActiveSyscallClass, "sleep-timer">;
-    action: "defer-target-resume";
-    syscall: NativeThreadState["syscall"];
-    metadata: {
-        remainingTime: NativeModeledSleepTimerRemainingTime;
-        sleepTimer: NativeModeledSleepTimerState;
-        policy: "conservative-target-timer-rearm-required";
-    };
-}
+type NativeFdReadModelResult = {
+    state: "modeled";
+    read: NativeModeledFdReadState;
+} | {
+    state: "missing";
+    refusal: NativeProcessImageRefusal;
+};
+interface NativeModeledPingSocketRecvmsgState {
+    kind: "ping-socket-recvmsg-wait";
+    syscallName: "recvmsg";
+    argumentSource: "proc-syscall" | "registers";
+    sourceFd: number;
+    targetFd: number;
+    messagePointer: string;
+    flags: 0;
+    namePointer: string;
+    nameLengthBytes: number;
+    iovPointer: string;
+    iovCount: 1;
+    iovBasePointer: string;
+    iovLengthBytes: number;
+    controlPointer: string;
+    controlLengthBytes: number;
+    messageFlags: 0;
+    resourceId: string;
+    receiveQueue: "empty";
+    inFlightPackets: "none";
+    signalTimer: "no-pending-signal-frame-target-wait-preserved";
+}
+type NativeFdWriteModelResult = {
+    state: "modeled";
+    write: NativeModeledFdWriteState;
+} | {
+    state: "missing";
+    refusal: NativeProcessImageRefusal;
+};
+type NativePingSocketRecvmsgModelResult = {
+    state: "modeled";
+    recvmsg: NativeModeledPingSocketRecvmsgState;
+} | {
+    state: "missing";
+    refusal: NativeProcessImageRefusal;
+};
+interface NativeActiveSleepTimerContinuation {
+    threadId: string;
+    syscallClass: Extract<NativeActiveSyscallClass, "sleep-timer">;
+    action: "defer-target-resume";
+    syscall: NativeThreadState["syscall"];
+    metadata: {
+        remainingTime: NativeModeledSleepTimerRemainingTime;
+        sleepTimer: NativeModeledSleepTimerState;
+        policy: "conservative-target-timer-rearm-required";
+    };
+}
 interface NativeActivePpollTimeoutContinuation {
     threadId: string;
     syscallClass: Extract<NativeActiveSyscallClass, "poll-timeout">;
@@ -2750,7 +4635,37 @@ interface NativeActivePpollTimeoutContinuation {
         policy: "conservative-target-ppoll-timeout-rearm-required";
     };
 }
-type NativeActiveSyscallContinuation = NativeActiveSleepTimerContinuation | NativeActivePpollTimeoutContinuation;
+interface NativeActiveFdReadContinuation {
+    threadId: string;
+    syscallClass: Extract<NativeActiveSyscallClass, "fd-blocking">;
+    action: "defer-target-resume";
+    syscall: NativeThreadState["syscall"];
+    metadata: {
+        fdRead: NativeModeledFdReadState;
+        policy: "conservative-target-fd-read-block-preserved";
+    };
+}
+interface NativeActiveFdWriteContinuation {
+    threadId: string;
+    syscallClass: Extract<NativeActiveSyscallClass, "fd-blocking">;
+    action: "defer-target-resume";
+    syscall: NativeThreadState["syscall"];
+    metadata: {
+        fdWrite: NativeModeledFdWriteState;
+        policy: "conservative-target-fd-write-completed-from-buffer";
+    };
+}
+interface NativeActivePingSocketRecvmsgContinuation {
+    threadId: string;
+    syscallClass: Extract<NativeActiveSyscallClass, "fd-blocking">;
+    action: "defer-target-resume";
+    syscall: NativeThreadState["syscall"];
+    metadata: {
+        pingSocketRecvmsg: NativeModeledPingSocketRecvmsgState;
+        policy: "conservative-target-ping-socket-recvmsg-wait-preserved";
+    };
+}
+type NativeActiveSyscallContinuation = NativeActiveSleepTimerContinuation | NativeActivePpollTimeoutContinuation | NativeActiveFdReadContinuation | NativeActiveFdWriteContinuation | NativeActivePingSocketRecvmsgContinuation;
 interface NativeActiveSyscallClassification {
     threadId: string;
     state: NativeThreadState["syscall"]["state"];
@@ -2768,11 +4683,15 @@ interface NativeActiveSyscallClassificationResult {
 }
 declare function classifyNativeActiveSyscalls(threads: NativeThreadState[], options?: NativeActiveSyscallPolicyOptions): NativeActiveSyscallClassificationResult;
 declare function classifyNativeThreadSyscall(thread: NativeThreadState, options?: NativeActiveSyscallPolicyOptions): NativeActiveSyscallClassification;
-declare function modelNativePpollTimeoutState(thread: NativeThreadState, documents?: NativeProcessImageDocuments): NativePpollTimeoutModelResult;
+declare function modelNativePpollTimeoutState(thread: NativeThreadState, documents?: NativeProcessImageDocuments, fdPolicy?: NativePollTimeoutFdPolicy): NativePpollTimeoutModelResult;
+declare function modelNativeFdReadState(thread: NativeThreadState, documents?: NativeProcessImageDocuments, resourcePolicy?: NativeFdReadResourcePolicy): NativeFdReadModelResult;
+declare function modelNativeFdWriteState(thread: NativeThreadState, documents?: NativeProcessImageDocuments, resourcePolicy?: NativeFdWriteResourcePolicy): NativeFdWriteModelResult;
+declare function modelNativePingSocketRecvmsgState(thread: NativeThreadState, documents?: NativeProcessImageDocuments, sourceFd?: number, targetFd?: number): NativePingSocketRecvmsgModelResult;
 declare function modelNativeSleepTimerState(thread: NativeThreadState, documents?: NativeProcessImageDocuments): NativeSleepTimerModelResult;
 
 /** Shared descriptors for generated target-native synthetic continuations. */
 
+declare const NATIVE_SYNTHETIC_SYSCALL_EINTR_EXIT_STATUS = 110;
 declare const NATIVE_SYNTHETIC_SYSCALL_RESTART_EXIT_STATUS = 111;
 declare const NATIVE_SYNTHETIC_SYSCALL_UNMODELED_RETURN_EXIT_STATUS = 112;
 type NativeSyntheticContinuationTargetArch = "amd64";
@@ -2780,7 +4699,7 @@ type NativeSyntheticContinuationByteSource = "generated-target-native-amd64-sysc
 type NativeSyntheticContinuationByteEncoding = "amd64-machine-code";
 type NativeSyntheticContinuationSyscallAbi = "linux-amd64";
 type NativeSyntheticContinuationRegisterSetupAbi = "linux-amd64-syscall";
-type NativeSyntheticContinuationFailureKind = "signal-restart-unsupported" | "syscall-return-unmodeled";
+type NativeSyntheticContinuationFailureKind = "signal-interrupted-unsupported" | "signal-restart-unsupported" | "syscall-return-unmodeled";
 type NativeSyntheticContinuationFailureExitBucketCondition = "equals-negative-errno" | "restart-like-negative-errno" | "other-negative-errno" | "nonzero-return";
 type NativeSyntheticContinuationRegister = "rax" | "rdi" | "rsi" | "rdx" | "r10" | "r8" | "r9" | "rcx" | "r11";
 type NativeSyntheticContinuationProvenanceSource = "generated-target-native-amd64-syscall-sequence" | "linux-amd64-syscall-abi" | "modeled-source-sleep-timer" | "modeled-source-ppoll-timeout" | "target-caller-frame";
@@ -2831,9 +4750,21 @@ interface NativeSyntheticContinuationFailureExitBucket {
         }[];
     };
 }
+interface NativeSyntheticContinuationRestartContract {
+    mode: "fail-closed";
+    signalMaskAssumption: "source-sigmask-null-or-unmodeled";
+    pendingSignalAssumption: "no-pending-signal-state-modeled";
+    plainEintr: "refuse";
+    restartLikeErrnos: {
+        errno: number;
+        errnoName: string;
+    }[];
+    targetRestartRequirements: string[];
+}
 interface NativeSyntheticContinuationCompletionDescriptor {
     mode: string;
     successExitStatus?: number;
+    restartContract?: NativeSyntheticContinuationRestartContract;
     /** Legacy single-bucket failure status. Prefer failureExitBuckets for new continuations. */
     failureExitStatus?: number;
     /** Legacy single-bucket failure kind. Prefer failureExitBuckets for new continuations. */
@@ -2880,16 +4811,21 @@ declare function buildNativeSyntheticSyscallContinuationDescriptor(request: Nati
 declare function nativeSyntheticContinuationBytesHex(bytes: Uint8Array): string;
 declare function nativeSyntheticContinuationBytesSha256(bytes: Uint8Array): string;
 declare function nativeSyntheticContinuationDescriptorSha256(descriptor: NativeSyntheticSyscallContinuationDescriptorPayload): string;
+declare function nativeSyntheticEintrErrno(): {
+    errno: number;
+    errnoName: string;
+};
 declare function nativeSyntheticRestartLikeErrnos(): {
     errno: number;
     errnoName: string;
 }[];
+declare function nativeSyntheticSyscallRestartContract(): NativeSyntheticContinuationRestartContract;
 declare function nativeSyntheticSyscallFailureExitBuckets(syscallName: string): NativeSyntheticContinuationFailureExitBucket[];
 declare function nativeSyntheticExitProcessSuffix(): number[];
 
 /** Synthetic target-native ppoll timeout syscall continuation generation. */
 
-declare const NATIVE_SYNTHETIC_PPOLL_SYSCALL_BUILD_ID = "machinen-synthetic-ppoll-syscall-v1";
+declare const NATIVE_SYNTHETIC_PPOLL_SYSCALL_BUILD_ID = "machinen-synthetic-ppoll-syscall-v2";
 declare const NATIVE_SYNTHETIC_PPOLL_SYSCALL_LOGICAL_NAME = "machinen-synthetic-ppoll-syscall";
 declare const NATIVE_SYNTHETIC_PPOLL_SYSCALL_PATH = "machinen.synthetic://ppoll-syscall";
 declare const NATIVE_SYNTHETIC_PPOLL_SYSCALL_BASE = "0x700300000000";
@@ -2931,6 +4867,14 @@ interface NativeSyntheticPpollSyscallContinuationProvenance extends NativeSynthe
         pointerRegister: "rdx";
         pointerEncoding: "rip-relative";
     };
+    embeddedPollFds?: {
+        kind: "pollfd-array";
+        offset: number;
+        entries: NativeModeledPpollFdState[];
+        byteOrder: "little-endian";
+        pointerRegister: "rdi";
+        pointerEncoding: "stack-relative";
+    };
     registerSetup: NativeSyntheticPpollSyscallRegisterSetupProvenance;
     stackSetup: NativeSyntheticPpollSyscallStackSetupProvenance;
     completion: NativeSyntheticPpollSyscallCompletionProvenance;
@@ -2938,6 +4882,7 @@ interface NativeSyntheticPpollSyscallContinuationProvenance extends NativeSynthe
 interface NativeSyntheticPpollSyscallContinuationRequest {
     threadId: string;
     remainingTime: NativeModeledPpollTimeoutRemainingTime;
+    ppollTimeout?: NativeModeledPpollTimeoutState;
     targetAddress?: string;
     completionMode?: NativeSyntheticPpollCompletionMode;
 }
@@ -2950,8 +4895,9 @@ interface NativeSyntheticPpollSyscallContinuation {
     syscall: {
         name: "ppoll";
         number: 271;
-        fdsPointer: "0x0";
-        nfds: 0;
+        fdsPointer: "0x0" | "stack-relative-pollfd-array";
+        nfds: 0 | 1;
+        pollFds?: NativeModeledPpollFdState[];
         timeoutPointerEncoding: "rip-relative-timespec";
         sigmaskPointer: "0x0";
         sigsetSize: 0;
@@ -2976,10 +4922,11 @@ declare function buildNativeSyntheticPpollSyscallContinuation(request: NativeSyn
 
 /** Synthetic target-native sleep syscall continuation generation. */
 
-declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_BUILD_ID = "machinen-synthetic-sleep-syscall-v3";
+declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_BUILD_ID = "machinen-synthetic-sleep-syscall-v4";
 declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_LOGICAL_NAME = "machinen-synthetic-sleep-syscall";
 declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_PATH = "machinen.synthetic://sleep-syscall";
 declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_BASE = "0x700200000000";
+declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_EINTR_EXIT_STATUS = 110;
 declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_RESTART_EXIT_STATUS = 111;
 declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_UNMODELED_RETURN_EXIT_STATUS = 112;
 declare const NATIVE_SYNTHETIC_SLEEP_SYSCALL_FAILURE_EXIT_STATUS = 111;
@@ -3209,7 +5156,40 @@ interface NativeStackTranslationResult {
     relocations: NativeMemoryRelocation[];
     refusals: NativeProcessImageRefusal[];
 }
+interface NativeStackPointerRange {
+    id: string;
+    targetBase: string;
+    targetLimit: string;
+}
+interface NativeStackWindowMaterializationRequest extends NativeStackTranslationRequest {
+    sourceStackBase: string;
+    sourceStackLimit: string;
+    targetStackLimit: string;
+    guardBelowAddress: string;
+    guardAboveAddress: string;
+    pointerRanges: NativeStackPointerRange[];
+}
+interface NativeStackWindowMaterializationPlan {
+    state: "materialized" | "refused";
+    stackMapping: string;
+    sourceWindow: {
+        base: string;
+        limit: string;
+    };
+    targetWindow: {
+        base: string;
+        limit: string;
+        sizeBytes: number;
+    };
+    guards: {
+        below: string;
+        above: string;
+    };
+    relocations: NativeMemoryRelocation[];
+    refusals: NativeProcessImageRefusal[];
+}
 declare function translateNativeStack(request: NativeStackTranslationRequest): NativeStackTranslationResult;
+declare function planNativeStackWindowMaterialization(request: NativeStackWindowMaterializationRequest): NativeStackWindowMaterializationPlan;
 
 /** DWARF/eh-frame based native stack-frame discovery. */
 
@@ -3471,6 +5451,145 @@ interface NativeSyntheticTargetCallerFramePlanResult {
 }
 declare function planNativeSyntheticTargetCallerFrame(request: NativeSyntheticTargetCallerFramePlanRequest): NativeSyntheticTargetCallerFramePlanResult;
 
+type NativeSignalBlockedMaskPolicy = "require-empty" | "restore-safe-mask";
+interface NativeSignalRestorePolicyRequest {
+    thread: NativeThreadState;
+    blockedMaskPolicy?: NativeSignalBlockedMaskPolicy;
+}
+type NativeSignalRestorePolicyResult = {
+    state: "accepted";
+    threadId: string;
+    blockedMaskPolicy: NativeSignalBlockedMaskPolicy;
+    targetBlockedMasks: string[];
+    refusals: [];
+} | {
+    state: "refused";
+    threadId: string;
+    refusals: NativeProcessImageRefusal[];
+};
+declare function planNativeSignalRestorePolicy(request: NativeSignalRestorePolicyRequest): NativeSignalRestorePolicyResult;
+declare function safeSignalRestoreRefusal(request: NativeSignalRestorePolicyRequest): NativeProcessImageRefusal | undefined;
+
+type NativeTlsTargetAccessPolicy = "not-required" | "segment-bases-provided" | "target-tcb-materialized" | "target-tcb-required";
+type NativeTlsSegmentBaseHandoffResult = {
+    state: "accepted";
+    threadId: string;
+    sourceArch: "arm64";
+    sourceRegister: "arm64-tpidr-el0";
+    sourceThreadPointer: string;
+    targetArch: "amd64";
+    targetSegmentBases: {
+        fsBase: string;
+        gsBase: string;
+        accessPolicy: Exclude<NativeTlsTargetAccessPolicy, "target-tcb-required">;
+    };
+    refusals: [];
+} | {
+    state: "refused";
+    threadId: string;
+    refusals: NativeProcessImageRefusal[];
+};
+interface NativeTlsSegmentBaseHandoffRequest {
+    threadId: string;
+    sourceArch: NativeProcessImageArchitecture;
+    targetArch: NativeProcessImageArchitecture;
+    sourceThreadPointer?: string;
+    sourceRegister?: NativeTlsThreadPointerRegister;
+    targetFsBase?: string;
+    targetGsBase?: string;
+    targetAccessPolicy?: NativeTlsTargetAccessPolicy;
+    capturedTargetSegmentBases?: NativeTlsAmd64SegmentBases;
+}
+interface NativeThreadTlsPolicyRequest {
+    thread: NativeThreadState;
+    targetArch?: NativeProcessImageArchitecture;
+    targetFsBase?: string;
+    targetGsBase?: string;
+    targetAccessPolicy?: NativeTlsTargetAccessPolicy;
+}
+declare function planNativeTlsSegmentBaseHandoff(request: NativeTlsSegmentBaseHandoffRequest): NativeTlsSegmentBaseHandoffResult;
+declare function safeTlsSegmentBaseRefusal(request: NativeThreadTlsPolicyRequest): NativeProcessImageRefusal | undefined;
+
+type NativeThreadRestorePlan = {
+    state: "accepted";
+    threadId: string;
+    targetThreadCount: 1;
+    activeSyscallContinuations: NativeActiveSyscallContinuation[];
+    signalRestore: {
+        blockedMasks: string[];
+    };
+    refusals: [];
+} | {
+    state: "refused";
+    targetThreadCount: number;
+    refusals: NativeProcessImageRefusal[];
+};
+interface NativeThreadRestorePlanRequest {
+    threads: NativeThreadState[];
+    mappings?: NativeMemoryMapping[];
+    resources?: NativeProcessResource[];
+    tls?: {
+        targetFsBase?: string;
+        targetGsBase?: string;
+        targetAccessPolicy?: NativeTlsTargetAccessPolicy;
+    };
+    activeSyscall?: NativeActiveSyscallPolicyOptions;
+    signal?: {
+        blockedMaskPolicy?: NativeSignalBlockedMaskPolicy;
+    };
+}
+declare function planNativeThreadRestoreBoundary(request: NativeThreadRestorePlanRequest): NativeThreadRestorePlan;
+
+type NativeControlledTwoThreadRestorePlan = {
+    state: "accepted";
+    targetThreadCount: 2;
+    threadIds: [string, string];
+    threadPlans: [
+        Extract<NativeThreadRestorePlan, {
+            state: "accepted";
+        }>,
+        Extract<NativeThreadRestorePlan, {
+            state: "accepted";
+        }>
+    ];
+    refusals: [];
+} | {
+    state: "refused";
+    targetThreadCount: number;
+    refusals: NativeProcessImageRefusal[];
+};
+interface NativeControlledTwoThreadRestorePlanRequest {
+    threads: NativeThreadState[];
+    mappings: NativeMemoryMapping[];
+    resources?: NativeProcessResource[];
+    activeSyscall?: NativeActiveSyscallPolicyOptions;
+    signal?: {
+        blockedMaskPolicy?: NativeSignalBlockedMaskPolicy;
+    };
+}
+declare function planNativeControlledTwoThreadRestoreBoundary(request: NativeControlledTwoThreadRestorePlanRequest): NativeControlledTwoThreadRestorePlan;
+
+interface NativeSimdFpuLiveSubsetPolicy {
+    state: "refuse-all-live-subsets";
+    acceptedSubsets: [];
+    refusalCode: "simd-fpu-state-unsupported";
+    reason: string;
+}
+declare const NATIVE_SIMD_FPU_LIVE_SUBSET_POLICY: NativeSimdFpuLiveSubsetPolicy;
+declare function planNativeSimdFpuLiveSubsetPolicy(): NativeSimdFpuLiveSubsetPolicy;
+type NativeSimdFpuRestorePolicyResult = {
+    state: "accepted";
+    threadId: string;
+    policy: "not-live";
+    refusals: [];
+} | {
+    state: "refused";
+    threadId: string;
+    refusals: NativeProcessImageRefusal[];
+};
+declare function planNativeSimdFpuRestorePolicy(thread: NativeThreadState): NativeSimdFpuRestorePolicyResult;
+declare function safeSimdFpuRefusal(thread: NativeThreadState): NativeProcessImageRefusal | undefined;
+
 /** Target-native module byte materialization for real utility continuation. */
 
 interface NativeTargetModuleByteMaterializationRequest {
@@ -3749,12 +5868,21 @@ interface NativeMappingMaterializationStep {
         offset: number;
         sizeBytes: number;
     };
+    privateWritable?: {
+        guardMappings: string[];
+    };
     refusal?: NativeProcessImageRefusal;
 }
+interface NativePrivateWritableGuardRequest {
+    mapping: string;
+    belowMapping?: string;
+    aboveMapping?: string;
+}
 interface NativeMappingMaterializationRequest {
     mappings: NativeMemoryMapping[];
     memorySizeBytes: number;
     targetFileBuildIds?: Record<string, string>;
+    privateWritableGuards?: NativePrivateWritableGuardRequest[];
 }
 interface NativeMappingMaterializationResult {
     steps: NativeMappingMaterializationStep[];
@@ -3762,6 +5890,119 @@ interface NativeMappingMaterializationResult {
 }
 declare function planNativeMappingMaterialization(request: NativeMappingMaterializationRequest): NativeMappingMaterializationResult;
 
+interface NativeReturnChainFrame {
+    id: string;
+    framePointer: string;
+    canonicalFrameAddress: string;
+    returnAddressSlot: string;
+    returnAddress: string;
+    unwindId: string;
+    callerFramePointer?: string;
+}
+interface NativeReturnChainPlanRequest {
+    targetStackBase: string;
+    targetStackLimit: string;
+    maxFrames: number;
+    frames: NativeReturnChainFrame[];
+}
+interface NativeReturnChainPlanFrame extends NativeReturnChainFrame {
+    index: number;
+    framePointer: string;
+    canonicalFrameAddress: string;
+    returnAddressSlot: string;
+    returnAddress: string;
+    callerFramePointer?: string;
+}
+interface NativeReturnChainPlan {
+    state: "materialized" | "refused";
+    targetStack: {
+        base: string;
+        limit: string;
+    };
+    frames: NativeReturnChainPlanFrame[];
+    refusals: NativeProcessImageRefusal[];
+}
+declare function planNativeReturnChain(request: NativeReturnChainPlanRequest): NativeReturnChainPlan;
+
+interface NativeMachineRestorePlanRequest {
+    thread: NativeThreadRestorePlanRequest;
+    stackWindow?: NativeStackWindowMaterializationRequest;
+    returnChain?: NativeReturnChainPlanRequest;
+    mappings?: NativeMappingMaterializationRequest;
+}
+type NativeMachineRestorePlan = {
+    state: "accepted";
+    thread: Extract<NativeThreadRestorePlan, {
+        state: "accepted";
+    }>;
+    stackWindow?: NativeStackWindowMaterializationPlan & {
+        state: "materialized";
+    };
+    returnChain?: NativeReturnChainPlan & {
+        state: "materialized";
+    };
+    mappings?: NativeMappingMaterializationResult;
+    refusals: [];
+} | {
+    state: "refused";
+    thread: NativeThreadRestorePlan;
+    stackWindow?: NativeStackWindowMaterializationPlan;
+    returnChain?: NativeReturnChainPlan;
+    mappings?: NativeMappingMaterializationResult;
+    refusals: NativeProcessImageRefusal[];
+};
+declare function planNativeMachineRestore(request: NativeMachineRestorePlanRequest): NativeMachineRestorePlan;
+
+declare const NATIVE_MACHINE_RESTORE_DESCRIPTOR_FORMAT_VERSION = 1;
+declare const NATIVE_MACHINE_RESTORE_DESCRIPTOR_KIND = "machinen.native-machine-restore";
+interface NativeMachineRestoreDescriptor {
+    formatVersion: typeof NATIVE_MACHINE_RESTORE_DESCRIPTOR_FORMAT_VERSION;
+    kind: typeof NATIVE_MACHINE_RESTORE_DESCRIPTOR_KIND;
+    thread: {
+        id: string;
+        targetThreadCount: number;
+    };
+    signal: {
+        blockedMasks: string[];
+    };
+    activeSyscalls: NativeActiveSyscallContinuation[];
+    stackWindow?: {
+        stackMapping: string;
+        sourceWindow: {
+            base: string;
+            limit: string;
+        };
+        targetWindow: {
+            base: string;
+            limit: string;
+            sizeBytes: number;
+        };
+        guards: {
+            below: string;
+            above: string;
+        };
+        relocationCount: number;
+    };
+    returnChain?: {
+        targetStack: {
+            base: string;
+            limit: string;
+        };
+        frames: NativeReturnChainPlanFrame[];
+    };
+    mappings?: {
+        steps: NativeMappingMaterializationStep[];
+    };
+}
+declare class NativeMachineRestoreDescriptorValidationError extends Error {
+    readonly refusals: NativeProcessImageRefusal[];
+    constructor(message: string, refusals?: NativeProcessImageRefusal[]);
+}
+declare function buildNativeMachineRestoreDescriptor(plan: NativeMachineRestorePlan): NativeMachineRestoreDescriptor;
+declare function serializeNativeMachineRestoreDescriptor(descriptor: NativeMachineRestoreDescriptor): string;
+declare function parseNativeMachineRestoreDescriptor(text: string): NativeMachineRestoreDescriptor;
+declare function validateNativeMachineRestoreDescriptor(descriptor: NativeMachineRestoreDescriptor): NativeMachineRestoreDescriptor;
+
 /** Register/TLS/syscall-state translation rules for native process images. */
 
 interface NativeRegisterTranslationRequest {
@@ -3775,6 +6016,7 @@ interface NativeContinuationTarget {
     targetIp: string;
     targetSp: string;
     targetTls: string;
+    targetTlsAccessPolicy?: NativeTlsTargetAccessPolicy;
     targetRegisterOverrides?: Partial<Pick<NativeAmd64Registers, "rax" | "rbx" | "rcx" | "rdx" | "rsi" | "rdi" | "rbp" | "r8" | "r9" | "r10" | "r11" | "r12" | "r13" | "r14" | "r15">>;
 }
 interface NativeRegisterTranslationResult {
@@ -3785,6 +6027,546 @@ interface NativeRegisterTranslationResult {
 }
 declare function translateNativeRegisterState(request: NativeRegisterTranslationRequest): NativeRegisterTranslationResult;
 
+interface NativeReturnChainFrameWrite {
+    frameId: string;
+    targetAddress: string;
+    value: string;
+    bytes: string;
+    kind: "caller-frame-pointer" | "return-address";
+}
+type NativeReturnChainMaterialization = {
+    state: "materialized";
+    initialFramePointer: string;
+    targetStack: NativeReturnChainPlan["targetStack"];
+    writes: NativeReturnChainFrameWrite[];
+    refusals: [];
+} | {
+    state: "refused";
+    refusals: NativeProcessImageRefusal[];
+};
+declare function materializeNativeReturnChainFrames(plan: NativeReturnChainPlan): NativeReturnChainMaterialization;
+
+interface NativeStackWindowWrite {
+    mapping: string;
+    targetAddress: string;
+    offset: number;
+    sizeBytes: 8;
+    value: string;
+    bytes: string;
+    kind: NativeMemoryRelocation["kind"];
+}
+interface NativeStackWindowGuardMapping {
+    targetStart: string;
+    sizeBytes: number;
+    placement: "below" | "above";
+}
+type NativeStackWindowMaterializedWrites = {
+    state: "materialized";
+    stackMapping: string;
+    targetWindow: NativeStackWindowMaterializationPlan["targetWindow"];
+    writes: NativeStackWindowWrite[];
+    guards: NativeStackWindowGuardMapping[];
+    refusals: [];
+} | {
+    state: "refused";
+    stackMapping: string;
+    refusals: NativeProcessImageRefusal[];
+};
+declare function materializeNativeStackWindowWrites(plan: NativeStackWindowMaterializationPlan): NativeStackWindowMaterializedWrites;
+
+type TargetGuestActiveSyscallRestoreStep = {
+    action: "rearm-sleep-timer";
+    threadId: string;
+    syscallName: string;
+    remainingTime: {
+        seconds: string;
+        nanoseconds: number;
+    };
+    resumeMode: "defer-target-resume";
+} | {
+    action: "rearm-ppoll-timeout";
+    threadId: string;
+    remainingTime: {
+        seconds: string;
+        nanoseconds: number;
+    };
+    nfds: 0 | 1;
+    resources: NativeModeledPpollTargetResource[];
+    resumeMode: "defer-target-resume";
+} | {
+    action: "restore-fd-read-block";
+    threadId: string;
+    fd: number;
+    countBytes: number;
+    resource: Exclude<NativeModeledFdReadTargetResource, "reopened-offset-file">;
+    remainingTime?: {
+        seconds: string;
+        nanoseconds: number;
+    };
+    resumeMode: "defer-target-resume";
+} | {
+    action: "complete-fd-read-from-file";
+    threadId: string;
+    fd: number;
+    countBytes: number;
+    targetBufferPointer: string;
+    fileOffset: number;
+    resumeMode: "defer-target-resume";
+} | {
+    action: "complete-fd-write-to-file";
+    threadId: string;
+    fd: number;
+    countBytes: number;
+    targetBufferPointer: string;
+    fileOffset: number;
+    resumeMode: "defer-target-resume";
+} | {
+    action: "restore-ping-socket-recvmsg-wait";
+    threadId: string;
+    fd: number;
+    sourceFd: number;
+    messagePointer: string;
+    iovLengthBytes: number;
+    controlLengthBytes: number;
+    receiveQueue: NativeModeledPingSocketRecvmsgState["receiveQueue"];
+    inFlightPackets: NativeModeledPingSocketRecvmsgState["inFlightPackets"];
+    signalTimer: NativeModeledPingSocketRecvmsgState["signalTimer"];
+    resumeMode: "defer-target-resume";
+};
+type TargetGuestActiveSyscallRestorePlan = {
+    state: "planned";
+    steps: TargetGuestActiveSyscallRestoreStep[];
+    refusals: [];
+} | {
+    state: "refused";
+    steps: [];
+    refusals: NativeProcessImageRefusal[];
+};
+declare function planTargetGuestActiveSyscallRestore(classification: NativeActiveSyscallClassificationResult): TargetGuestActiveSyscallRestorePlan;
+
+interface TargetGuestExecutableMappingStep {
+    action: "map-target-executable";
+    mapping: string;
+    targetStart: string;
+    sizeBytes: number;
+    permissions: NativeMemoryMapping["permissions"];
+    path: string;
+    fileOffset: number;
+    buildId?: string;
+    sha256?: string;
+    sourceTextReusedAsTargetCode: false;
+}
+interface TargetGuestExecutableMaterializationPlan {
+    state: "planned" | "refused";
+    steps: TargetGuestExecutableMappingStep[];
+    refusals: NativeProcessImageRefusal[];
+}
+declare function planTargetGuestExecutableMaterialization(steps: NativeMappingMaterializationStep[]): TargetGuestExecutableMaterializationPlan;
+
+type TargetGuestMemoryMaterializationKind = "copy-captured-bytes" | "recreate-guard";
+interface TargetGuestMemoryMaterializationEntryBase {
+    kind: TargetGuestMemoryMaterializationKind;
+    mapping: string;
+    targetStart: string;
+    sizeBytes: number;
+    permissions: string;
+    provenance: "native-process-image" | "guard-protection";
+}
+interface TargetGuestCopyCapturedBytesEntry extends TargetGuestMemoryMaterializationEntryBase {
+    kind: "copy-captured-bytes";
+    sourceFile: string;
+    sourceOffset: number;
+    provenance: "native-process-image";
+}
+interface TargetGuestRecreateGuardEntry extends TargetGuestMemoryMaterializationEntryBase {
+    kind: "recreate-guard";
+    provenance: "guard-protection";
+}
+type TargetGuestMemoryMaterializationEntry = TargetGuestCopyCapturedBytesEntry | TargetGuestRecreateGuardEntry;
+interface TargetGuestMemoryMaterializationRequest {
+    mappings: NativeMemoryMapping[];
+    memorySizeBytes: number;
+    memoryFile: string;
+}
+interface TargetGuestMemoryMaterializationResult {
+    entries: TargetGuestMemoryMaterializationEntry[];
+    refusals: NativeProcessImageRefusal[];
+}
+declare function planTargetGuestMemoryMaterialization(request: TargetGuestMemoryMaterializationRequest): TargetGuestMemoryMaterializationResult;
+
+type TargetGuestPrivateMemoryRestoreStep = {
+    action: "mmap-private-writable";
+    mapping: string;
+    targetStart: string;
+    sizeBytes: number;
+    permissions: string;
+} | {
+    action: "copy-captured-bytes";
+    mapping: string;
+    sourceFile: string;
+    sourceOffset: number;
+    targetStart: string;
+    sizeBytes: number;
+} | {
+    action: "mprotect-final";
+    mapping: string;
+    targetStart: string;
+    sizeBytes: number;
+    permissions: string;
+} | {
+    action: "mmap-guard";
+    mapping: string;
+    targetStart: string;
+    sizeBytes: number;
+    permissions: "---p";
+};
+interface TargetGuestPrivateMemoryRestorePlan {
+    state: "planned" | "refused";
+    steps: TargetGuestPrivateMemoryRestoreStep[];
+    refusals: NativeProcessImageRefusal[];
+}
+declare function planTargetGuestPrivateMemoryRestore(entries: TargetGuestMemoryMaterializationEntry[]): TargetGuestPrivateMemoryRestorePlan;
+
+type TargetGuestProcessContextRestoreMode = "metadata-only" | "apply-target-env-cwd" | "apply-target-visible-context" | "apply-target-initial-stack";
+type TargetGuestProcessContextRestoreStep = {
+    action: "record-argv";
+    argc: number;
+    argvBytes: number;
+    argvSha256: string;
+} | {
+    action: "materialize-argv";
+    argc: number;
+    argvSha256: string;
+    tokenIndex: number;
+    tokenHex: string;
+    tokenSha256: string;
+} | {
+    action: "set-argv-entry";
+    index: number;
+    valueHex: string;
+    valueSha256: string;
+} | {
+    action: "record-env";
+    envCount: number;
+    envBytes: number;
+    envSha256: string;
+} | {
+    action: "clear-env";
+    envCount: number;
+    envSha256: string;
+} | {
+    action: "set-env";
+    keyHex: string;
+    valueHex: string;
+    valueSha256: string;
+} | {
+    action: "verify-env";
+    envCount: number;
+    envSha256: string;
+} | {
+    action: "verify-env-value";
+    keyHex: string;
+    valueHex: string;
+    valueSha256: string;
+} | {
+    action: "record-cwd";
+    cwdHex: string;
+    cwdSha256: string;
+} | {
+    action: "chdir";
+    cwdHex: string;
+    cwdSha256: string;
+} | {
+    action: "verify-cwd";
+    cwdHex: string;
+    cwdSha256: string;
+} | {
+    action: "record-auxv";
+    auxvBytes: number;
+    auxvSha256: string;
+} | {
+    action: "verify-auxv-selected";
+    pageSize: number;
+    clockTick: number;
+    auxvSha256: string;
+} | {
+    action: "record-auxv-policy";
+    mode: "selected-safe-only";
+    materializedKeys: string;
+    refusedKeys: string;
+    auxvSha256: string;
+} | {
+    action: "materialize-initial-stack";
+    targetStart: string;
+    sizeBytes: number;
+    argc: number;
+    envCount: number;
+    pageSize: number;
+    clockTick: number;
+    argvSha256: string;
+    envSha256: string;
+} | {
+    action: "verify-initial-stack";
+    targetStart: string;
+    argc: number;
+    envCount: number;
+};
+type TargetGuestProcessContextRestorePlan = {
+    state: "planned";
+    mode: TargetGuestProcessContextRestoreMode;
+    steps: TargetGuestProcessContextRestoreStep[];
+} | {
+    state: "refused";
+    refusals: NativeProcessImageRefusal[];
+};
+interface TargetGuestProcessContextRestoreOptions {
+    mode?: TargetGuestProcessContextRestoreMode;
+    maxArgvEntries?: number;
+    maxEnvEntries?: number;
+    maxStringBytes?: number;
+    maxAuxvBytes?: number;
+    initialStackTargetStart?: string;
+    initialStackSizeBytes?: number;
+}
+declare function planTargetGuestProcessContextRestore(documents: NativeProcessImageDocuments, options?: TargetGuestProcessContextRestoreOptions): TargetGuestProcessContextRestorePlan;
+
+type TargetGuestSignalRestoreStep = {
+    action: "save-loader-signal-mask";
+    threadId: string;
+} | {
+    action: "sigprocmask-set-blocked";
+    threadId: string;
+    targetBlockedMasks: string[];
+} | {
+    action: "verify-blocked-signal-mask";
+    threadId: string;
+    targetBlockedMasks: string[];
+} | {
+    action: "restore-loader-signal-mask";
+    threadId: string;
+};
+type TargetGuestSignalRestorePlan = {
+    state: "planned";
+    threadId: string;
+    targetBlockedMasks: string[];
+    steps: TargetGuestSignalRestoreStep[];
+    refusals: [];
+} | {
+    state: "refused";
+    threadId: string;
+    refusals: NativeProcessImageRefusal[];
+};
+declare function planTargetGuestSignalRestore(policy: NativeSignalRestorePolicyResult): TargetGuestSignalRestorePlan;
+
+interface TargetGuestTwoThreadBinding {
+    threadId: string;
+    stackBase: string;
+    stackLimit: string;
+    registers: Record<string, string>;
+}
+interface TargetGuestTwoThreadSpawnStep {
+    action: "spawn-target-thread";
+    threadId: string;
+    stackBase: string;
+    stackLimit: string;
+    registers: Record<string, string>;
+}
+type TargetGuestTwoThreadRestorePlan = {
+    state: "planned";
+    targetThreadCount: 2;
+    steps: [TargetGuestTwoThreadSpawnStep, TargetGuestTwoThreadSpawnStep];
+    refusals: [];
+} | {
+    state: "refused";
+    targetThreadCount: number;
+    steps: [];
+    refusals: NativeProcessImageRefusal[];
+};
+declare function planTargetGuestTwoThreadRestore(boundary: NativeControlledTwoThreadRestorePlan, bindings: TargetGuestTwoThreadBinding[]): TargetGuestTwoThreadRestorePlan;
+
+declare const TARGET_GUEST_RESTORE_DESCRIPTOR_KIND = "machinen.target-guest-restore";
+type TargetGuestRestoreLoaderRefusalCode = "target-guest-loader-descriptor-invalid" | "target-guest-loader-target-arch-unsupported" | "target-guest-loader-resource-unsupported" | "target-guest-loader-invalid-fd" | "target-guest-loader-invalid-continuation" | "target-guest-loader-memory-unsupported" | "target-guest-loader-frame-unsupported";
+declare class TargetGuestRestoreLoaderValidationError extends Error {
+    readonly code: TargetGuestRestoreLoaderRefusalCode;
+    constructor(code: TargetGuestRestoreLoaderRefusalCode, message: string);
+}
+interface TargetGuestEpollWatchRecipe {
+    fd: number;
+    events: number;
+    data: string;
+}
+type TargetGuestRestoreResourceRecipe = {
+    kind: "close-fd";
+    fd: number;
+    reason?: string;
+} | {
+    kind: "inherit-stdio";
+    fd: 1 | 2;
+    stream: "stdout" | "stderr";
+    closeOnExec?: boolean;
+} | {
+    kind: "reopen-file";
+    fd: number;
+    path: string;
+    offset: number;
+    access: 0 | 1 | 2;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-empty-pipe";
+    readFd: number;
+    writeFd?: number;
+    initialBytesHex?: string;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-empty-eventfd";
+    fd: number;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-eventfd";
+    fd: number;
+    initialValue: string;
+    duplicateFd?: number;
+    expectedRefusalCode?: string;
+    expectedRefusalReason?: string;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-timerfd";
+    fd: number;
+    clockId?: number;
+    settimeFlags?: number;
+    valueSeconds?: number;
+    valueNanoseconds?: number;
+    intervalSeconds?: number;
+    intervalNanoseconds?: number;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-signalfd";
+    fd: number;
+    signalMask: string;
+    flags: number;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-epoll";
+    fd: number;
+    watches: TargetGuestEpollWatchRecipe[];
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-tcp-listener";
+    fd: number;
+    port: number;
+    backlog: number;
+    reuseAddr?: boolean;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-tcp-active-broker";
+    fd: number;
+    brokerFd: number;
+    port: number;
+    initialPeerBytes: string;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-raw-icmp";
+    fd: number;
+    identifier: number;
+    sequence: number;
+    closeOnExec?: boolean;
+} | {
+    kind: "synthetic-ping-socket";
+    fd: number;
+    identifier: number;
+    sequence: number;
+    uid: number;
+    gid: number;
+    pingGroupRangeStart: number;
+    pingGroupRangeEnd: number;
+    adoptCredentials?: boolean;
+    expectedRefusalCode?: string;
+    expectedRefusalReason?: string;
+    closeOnExec?: boolean;
+};
+type TargetGuestRestoreResumeMode = "translated-frame";
+type TargetGuestResumeRegisterName = "rax" | "rdi" | "rsi" | "rdx" | "rcx" | "r8" | "r9" | "r10" | "r11";
+type TargetGuestResumeRegisters = Record<TargetGuestResumeRegisterName, string>;
+interface TargetGuestRestoreContinuationDescriptor {
+    codeFile: string;
+    fileOffset: number;
+    codeSize: number;
+    targetAddress: string;
+    argument0?: string;
+    stateReportAddress?: string;
+    targetFsBase?: string;
+    translatedReturnAddress?: string;
+    resumeMode?: TargetGuestRestoreResumeMode;
+    resumeRflags?: string;
+    resumeRegisters?: TargetGuestResumeRegisters;
+    timeoutSeconds: number;
+    stackTargetStart: string;
+    stackSize: number;
+    stackPointer: string;
+}
+interface TargetGuestTranslatedFrameDescriptor {
+    kind: "single-target-caller-frame";
+    framePointer: string;
+    canonicalFrameAddress: string;
+    returnAddressSlot: string;
+    returnAddress: string;
+    unwindId: string;
+    calleeSaved: TargetGuestTranslatedFrameRegister[];
+    slots: TargetGuestTranslatedFrameSlot[];
+}
+type TargetGuestTranslatedFrameRegisterName = "rbx" | "r12" | "r13" | "r14" | "r15";
+interface TargetGuestTranslatedFrameRegister {
+    register: TargetGuestTranslatedFrameRegisterName;
+    value: string;
+}
+interface TargetGuestTranslatedFrameSlot {
+    offset: number;
+    value: string;
+    classification: "non-pointer-data";
+}
+type TargetGuestNativeRestoreStep = {
+    section: "stack-window-write";
+    write: NativeStackWindowWrite;
+} | {
+    section: "stack-window-guard";
+    guard: NativeStackWindowGuardMapping;
+} | {
+    section: "return-chain-write";
+    write: NativeReturnChainFrameWrite;
+} | {
+    section: "private-memory";
+    step: TargetGuestPrivateMemoryRestoreStep;
+} | {
+    section: "executable-mapping";
+    step: TargetGuestExecutableMappingStep;
+} | {
+    section: "process-context";
+    step: TargetGuestProcessContextRestoreStep;
+} | {
+    section: "signal-restore";
+    step: TargetGuestSignalRestoreStep;
+} | {
+    section: "active-syscall";
+    step: TargetGuestActiveSyscallRestoreStep;
+} | {
+    section: "thread-spawn";
+    step: TargetGuestTwoThreadSpawnStep;
+};
+interface TargetGuestRestoreDescriptor {
+    kind: typeof TARGET_GUEST_RESTORE_DESCRIPTOR_KIND;
+    targetArch: "amd64";
+    continuation: TargetGuestRestoreContinuationDescriptor;
+    translatedFrame?: TargetGuestTranslatedFrameDescriptor;
+    resources: TargetGuestRestoreResourceRecipe[];
+    memory: TargetGuestMemoryMaterializationEntry[];
+    nativeRestore?: TargetGuestNativeRestoreStep[];
+}
+declare function serializeTargetGuestRestoreDescriptor(descriptor: TargetGuestRestoreDescriptor): string;
+declare function parseTargetGuestRestoreDescriptor(text: string): TargetGuestRestoreDescriptor;
+declare function validateTargetGuestRestoreDescriptor(descriptor: TargetGuestRestoreDescriptor): TargetGuestRestoreDescriptor;
+declare function buildNativeActualResumeTrampolineArgs(descriptor: TargetGuestRestoreDescriptor): string[];
+declare function buildTargetGuestRestoreLoaderArgv(descriptorPath: string, trampolinePath: string): string[];
+
 /** Kernel-resource recipes and refusals for native process restore. */
 
 interface NativeInheritedStdioPolicy {
@@ -3794,12 +6576,980 @@ interface NativeResourceTranslationRequest {
     resources: NativeProcessResource[];
     hostCapabilities?: string[];
     inheritedStdio?: NativeInheritedStdioPolicy;
+    syntheticEmptyPipeFds?: number[];
+    syntheticEmptyEventFds?: number[];
+    syntheticTimerFds?: number[];
 }
 interface NativeResourceTranslationResult {
     resources: NativeProcessResource[];
     refusals: NativeProcessImageRefusal[];
 }
+type NativeTargetFdTableEntryKind = "close-fd" | "inherit-stdio" | "reopen-file" | "synthetic-empty-pipe-read-end" | "synthetic-empty-pipe-write-end" | "synthetic-empty-eventfd" | "synthetic-eventfd" | "synthetic-timerfd" | "synthetic-signalfd" | "synthetic-epoll" | "synthetic-tcp-listener" | "synthetic-tcp-active-broker" | "synthetic-raw-icmp" | "synthetic-ping-socket" | "refused";
+interface NativeTargetFdTableEntry {
+    targetFd: number;
+    capturedFd?: number;
+    resourceId?: string;
+    resourceKind?: NativeProcessResource["kind"];
+    kind: NativeTargetFdTableEntryKind;
+    closeOnExec: boolean;
+    action: "materialize" | "close" | "refuse";
+    source: "captured-resource" | "missing-captured-fd";
+    recipe?: Record<string, unknown>;
+    targetGuestRecipe?: TargetGuestRestoreResourceRecipe;
+    refusal?: NativeProcessImageRefusal;
+    provenance: {
+        resourceId?: string;
+        capturedFd?: number;
+        targetFd: number;
+        flags?: string[];
+        reason: string;
+    };
+}
+interface NativeTargetFdTablePlanRequest extends NativeResourceTranslationRequest {
+    expectedFds?: number[];
+}
+interface NativeTargetFdTablePlan {
+    entries: NativeTargetFdTableEntry[];
+    resources: NativeProcessResource[];
+    targetGuestResources: TargetGuestRestoreResourceRecipe[];
+    refusals: NativeProcessImageRefusal[];
+}
 declare function translateNativeResources(request: NativeResourceTranslationRequest): NativeResourceTranslationResult;
+declare function planNativeTargetFdTable(request: NativeTargetFdTablePlanRequest): NativeTargetFdTablePlan;
+
+declare const ARCHITECTURE_PORTABLE_SNAPSHOT_GAUNTLET_KIND: "machinen.architecture-portable-snapshot.final-proof-gauntlet";
+declare const ARCHITECTURE_PORTABLE_SNAPSHOT_GAUNTLET_ROW_KIND: "machinen.architecture-portable-snapshot.final-proof-gauntlet-row";
+declare const architecturePortableSnapshotGauntletEvidenceStatuses: readonly ["support", "proof", "stretch-demo", "refusal", "skipped"];
+declare const architecturePortableSnapshotTargetExecutions: readonly ["native", "accelerated", "emulated", "not-applicable"];
+declare const architecturePortableSnapshotEvidenceCategories: readonly ["supported-semantic-restart", "supported-semantic-continuation", "runtime-aware-proof", "native/process-proof", "unsupported"];
+declare const architecturePortableSnapshotProductSupportStates: readonly ["supported", "not-yet-supported", "unsupported"];
+type ArchitecturePortableSnapshotGauntletEvidenceStatus = (typeof architecturePortableSnapshotGauntletEvidenceStatuses)[number];
+type ArchitecturePortableSnapshotTargetExecution = (typeof architecturePortableSnapshotTargetExecutions)[number];
+type ArchitecturePortableSnapshotEvidenceCategory = (typeof architecturePortableSnapshotEvidenceCategories)[number];
+type ArchitecturePortableSnapshotProductSupport = (typeof architecturePortableSnapshotProductSupportStates)[number];
+interface ArchitecturePortableSnapshotGauntletRowInput {
+    claimId: string;
+    claimName: string;
+    evidenceStatus: ArchitecturePortableSnapshotGauntletEvidenceStatus;
+    sourceArch: string;
+    targetArch: string;
+    hostArch: string;
+    providerMode: string;
+    targetExecution: ArchitecturePortableSnapshotTargetExecution;
+    evidenceCategory: ArchitecturePortableSnapshotEvidenceCategory;
+    productSupport: ArchitecturePortableSnapshotProductSupport;
+    implementationLevel: string;
+    graduationTargetLevel: string;
+    stateModel: string;
+    stateDecisions: string[];
+    verifierCommand: string;
+    verifierOutput: string;
+    artifactDigests: Record<string, string>;
+    provenance: Record<string, unknown>;
+    migrationCompleted: boolean;
+    refusalCode?: string;
+    remediation?: string;
+}
+interface ArchitecturePortableSnapshotGauntletRow extends ArchitecturePortableSnapshotGauntletRowInput {
+    kind: typeof ARCHITECTURE_PORTABLE_SNAPSHOT_GAUNTLET_ROW_KIND;
+}
+interface ArchitecturePortableSnapshotGauntletSummary {
+    kind: typeof ARCHITECTURE_PORTABLE_SNAPSHOT_GAUNTLET_KIND;
+    state: "completed" | "failed";
+    pass: boolean;
+    rowCount: number;
+    rows: ArchitecturePortableSnapshotGauntletRow[];
+    byEvidenceStatus: Record<ArchitecturePortableSnapshotGauntletEvidenceStatus, number>;
+    failures: string[];
+}
+declare function buildArchitecturePortableSnapshotGauntletRow(input: ArchitecturePortableSnapshotGauntletRowInput): ArchitecturePortableSnapshotGauntletRow;
+declare function summarizeArchitecturePortableSnapshotGauntletRows(rows: ArchitecturePortableSnapshotGauntletRow[]): ArchitecturePortableSnapshotGauntletSummary;
+declare function validateArchitecturePortableSnapshotGauntletRows(rows: ArchitecturePortableSnapshotGauntletRow[]): string[];
+declare function validateArchitecturePortableSnapshotGauntletSchema(rows: ArchitecturePortableSnapshotGauntletRow[]): string[];
+declare function validateArchitecturePortableSnapshotGauntletInvariants(rows: ArchitecturePortableSnapshotGauntletRow[]): string[];
+declare const requiredArchitecturePortableSnapshotClaimIds: readonly ["opposite-isa-vm-execution", "guest-checkpoint-c-simple", "guest-checkpoint-jvm-simple", "portable-snapshot-guest-checkpoint-composition", "advanced-linux-seccomp", "advanced-linux-ebpf", "advanced-linux-namespace-cgroup-capability", "nested-virtualization-stretch-proof", "native-register-translation", "native-stack-return-chain-translation", "native-private-memory-materialization", "native-executable-target-module-materialization", "native-target-restore-loader", "native-tls-simd-fpu-policy", "native-signal-policy", "native-active-syscall-policy", "native-thread-policy", "native-mapping-refusals", "native-resource-refusals"];
+declare function stableGauntletDigest(value: unknown): string;
+
+declare const NESTED_VIRTUALIZATION_STRETCH_PROOF_KIND: "machinen.architecture-portable-snapshot.nested-virtualization-stretch-proof";
+declare const nestedVirtualizationStretchProofClassifications: readonly ["stretch-demo", "refused", "skipped"];
+declare const nestedVirtualizationStretchProofRefusalCodes: readonly ["nested-virtualization-unavailable", "nested-smoke-failed", "nested-verifier-ambiguous", "nested-snapshot-fork-unsafe"];
+type NestedVirtualizationStretchProofClassification = (typeof nestedVirtualizationStretchProofClassifications)[number];
+type NestedVirtualizationStretchProofRefusalCode = (typeof nestedVirtualizationStretchProofRefusalCodes)[number];
+interface NestedVirtualizationStretchProofInput {
+    classification: NestedVirtualizationStretchProofClassification;
+    l0HostArch: string;
+    l1GuestArch: string;
+    l2GuestArch: string;
+    providerMode: string;
+    accelerated: boolean;
+    emulated: boolean;
+    nestedVerifierOutput: string;
+    refusalCode?: NestedVirtualizationStretchProofRefusalCode;
+    remediation?: string;
+    snapshotForkRefusalCode: string;
+    snapshotForkRemediation: string;
+    evidence?: Record<string, unknown>;
+}
+interface NestedVirtualizationStretchProofRow extends NestedVirtualizationStretchProofInput {
+    kind: typeof NESTED_VIRTUALIZATION_STRETCH_PROOF_KIND;
+    migrationCompleted: false;
+    scope: {
+        productSupportClaimed: false;
+        portableSnapshotRequirement: false;
+        providerSnapshotForkSafe: false;
+    };
+}
+interface NestedVirtualizationStretchProofSummary {
+    kind: "machinen.architecture-portable-snapshot.nested-virtualization-stretch-proof-summary";
+    state: "completed" | "failed";
+    pass: boolean;
+    rows: NestedVirtualizationStretchProofRow[];
+    rowCount: number;
+    failures: string[];
+}
+declare function buildNestedVirtualizationStretchProofRow(input: NestedVirtualizationStretchProofInput): NestedVirtualizationStretchProofRow;
+declare function summarizeNestedVirtualizationStretchProofRows(rows: NestedVirtualizationStretchProofRow[]): NestedVirtualizationStretchProofSummary;
+declare function validateNestedVirtualizationStretchProofRows(rows: NestedVirtualizationStretchProofRow[]): string[];
+
+interface NestedVirtProbeHost {
+    platform: NodeJS.Platform;
+    arch: NodeJS.Architecture;
+    existsSync(path: string): boolean;
+    readText(path: string): string;
+    execFileSync(file: string, args: string[]): string;
+}
+interface NestedVirtProbeResult {
+    supported: boolean;
+    reason?: string;
+}
+declare function probeNestedVirtualization(host?: NestedVirtProbeHost): NestedVirtProbeResult;
+
+declare const ADVANCED_LINUX_FACILITY_PROBE_KIND: "machinen.architecture-portable-snapshot.advanced-linux-facility-probe";
+declare const advancedLinuxFacilityProbeFacilities: readonly ["seccomp", "ebpf", "namespace", "cgroup", "capability"];
+declare const advancedLinuxFacilityProbeClassifications: readonly ["product-supported", "proof-only-feasibility", "stretch-demo", "refused"];
+declare const advancedLinuxFacilityProbeRefusalCodes: readonly ["kernel-feature-unavailable", "insufficient-privileges", "unsafe-bpf-state-unsupported", "namespace-cgroup-mismatch", "capability-mismatch", "facility-verifier-ambiguous"];
+type AdvancedLinuxFacilityProbeFacility = (typeof advancedLinuxFacilityProbeFacilities)[number];
+type AdvancedLinuxFacilityProbeClassification = (typeof advancedLinuxFacilityProbeClassifications)[number];
+type AdvancedLinuxFacilityProbeRefusalCode = (typeof advancedLinuxFacilityProbeRefusalCodes)[number];
+type AdvancedLinuxFacilityProbeStateModel = "preserved" | "recreated" | "proven-irrelevant" | "refused";
+interface AdvancedLinuxFacilityProbeInput {
+    facility: AdvancedLinuxFacilityProbeFacility;
+    stateModel: AdvancedLinuxFacilityProbeStateModel;
+    sourceArch: string;
+    targetArch: string;
+    kernelVersion: string;
+    requiredCapabilities: string[];
+    verifierOutput: string;
+    classification: AdvancedLinuxFacilityProbeClassification;
+    migrationCompleted?: boolean;
+    refusalCode?: AdvancedLinuxFacilityProbeRefusalCode;
+    remediation?: string;
+    evidence?: Record<string, unknown>;
+}
+interface AdvancedLinuxFacilityProbeRow extends AdvancedLinuxFacilityProbeInput {
+    kind: typeof ADVANCED_LINUX_FACILITY_PROBE_KIND;
+    migrationCompleted: boolean;
+    scope: {
+        productSupportClaimed: boolean;
+        crossIsaKernelStateReplayClaimed: false;
+    };
+}
+interface AdvancedLinuxFacilityProbeSummary {
+    kind: "machinen.architecture-portable-snapshot.advanced-linux-facility-probe-matrix";
+    state: "completed" | "failed";
+    pass: boolean;
+    rows: AdvancedLinuxFacilityProbeRow[];
+    rowCount: number;
+    failures: string[];
+}
+declare function buildAdvancedLinuxFacilityProbeRow(input: AdvancedLinuxFacilityProbeInput): AdvancedLinuxFacilityProbeRow;
+declare function summarizeAdvancedLinuxFacilityProbeRows(rows: AdvancedLinuxFacilityProbeRow[]): AdvancedLinuxFacilityProbeSummary;
+declare function validateAdvancedLinuxFacilityProbeRows(rows: AdvancedLinuxFacilityProbeRow[]): string[];
+
+declare const RUNTIME_CONFIDENCE_PROFILE_KIND: "machinen.architecture-portable-snapshot.runtime-confidence-profile";
+declare const runtimeConfidenceClassifications: readonly ["product-supported", "proof-only-feasibility", "stretch-demo", "refused"];
+declare const runtimeConfidenceRefusalCodes: readonly ["active-sockets-unsupported", "native-library-ambiguity", "unmodeled-signal-or-timer-state", "jvm-private-jit-state-unsupported", "unsupported-process-topology", "source-target-abi-mismatch", "missing-target-runtime-or-dynamic-library-provenance", "target-verifier-missing-or-ambiguous"];
+type RuntimeConfidenceRuntime = "c" | "java";
+type RuntimeConfidenceClassification = (typeof runtimeConfidenceClassifications)[number];
+type RuntimeConfidenceRefusalCode = (typeof runtimeConfidenceRefusalCodes)[number];
+type RuntimeConfidenceStateModel = "preserved" | "recreated" | "drained" | "dropped-irrelevant" | "logically-restored" | "refused";
+type RuntimeConfidenceArch = "arm64" | "amd64";
+interface RuntimeConfidenceProfileInput {
+    runtime: RuntimeConfidenceRuntime;
+    profile: string;
+    classification: RuntimeConfidenceClassification;
+    sourceArch: RuntimeConfidenceArch;
+    targetArch: RuntimeConfidenceArch;
+    stateModel: RuntimeConfidenceStateModel;
+    artifactDigests: Record<string, string>;
+    runtimeVersion: string;
+    verifierOutput: string;
+    migrationCompleted?: boolean;
+    refusalCode?: RuntimeConfidenceRefusalCode;
+    remediation?: string;
+    evidence?: Record<string, unknown>;
+}
+interface RuntimeConfidenceProfileRow extends RuntimeConfidenceProfileInput {
+    kind: typeof RUNTIME_CONFIDENCE_PROFILE_KIND;
+    migrationCompleted: boolean;
+    scope: {
+        targetNativeVerifierRequired: true;
+        crossIsaRegisterReplayClaimed: false;
+        productSupportClaimed: boolean;
+    };
+}
+interface RuntimeConfidenceProfileSummary {
+    kind: "machinen.architecture-portable-snapshot.runtime-confidence-profile-matrix";
+    state: "completed" | "failed";
+    pass: boolean;
+    rows: RuntimeConfidenceProfileRow[];
+    rowCount: number;
+    byRuntime: Record<RuntimeConfidenceRuntime, number>;
+    byClassification: Record<RuntimeConfidenceClassification, number>;
+    failures: string[];
+}
+declare function buildRuntimeConfidenceProfileRow(input: RuntimeConfidenceProfileInput): RuntimeConfidenceProfileRow;
+declare function buildRuntimeConfidenceProfileMatrix(): RuntimeConfidenceProfileSummary;
+declare function summarizeRuntimeConfidenceProfiles(rows: RuntimeConfidenceProfileRow[]): RuntimeConfidenceProfileSummary;
+declare function validateRuntimeConfidenceProfiles(rows: RuntimeConfidenceProfileRow[]): string[];
+declare function runtimeConfidenceProfileFixtures(): RuntimeConfidenceProfileRow[];
+
+declare const PORTABLE_SNAPSHOT_GUEST_CHECKPOINT_COMPOSITION_KIND: "machinen.architecture-portable-snapshot.portable-snapshot-guest-checkpoint-composition";
+declare const portableSnapshotGuestCheckpointCompositionRefusalCodes: readonly ["guest-checkpoint-capability-unavailable", "guest-checkpoint-storage-unsupported-or-dirty", "cross-isa-checkpoint-image-restore-unsupported", "machinen-restore-path-unsupported", "composition-verifier-missing-or-ambiguous", "stored-checkpoint-image-unreadable-after-restore"];
+type PortableSnapshotGuestCheckpointCompositionRefusalCode = (typeof portableSnapshotGuestCheckpointCompositionRefusalCodes)[number];
+type PortableSnapshotGuestCheckpointCompositionState = "completed" | "refused" | "skipped";
+type PortableSnapshotGuestCheckpointMachinenStateModel = "same-arch-vmstate" | "cross-arch-semantic-restore" | "unsupported-cross-isa-checkpoint-replay" | "other-supported";
+interface PortableSnapshotGuestCheckpointCompositionInput {
+    sourceArch: string;
+    targetArch: string;
+    machinenStateModel: PortableSnapshotGuestCheckpointMachinenStateModel;
+    guestCheckpointVersion: string;
+    preSnapshotGuestCheckpointVerifier: string;
+    postRestoreGuestCheckpointVerifier: string;
+    storedCheckpointImageDigest: string;
+    storedCheckpointImageReadableAfterRestore: boolean;
+    migrationCompleted?: boolean;
+    refusalCode?: PortableSnapshotGuestCheckpointCompositionRefusalCode;
+    remediation?: string;
+    evidence?: Record<string, unknown>;
+}
+interface PortableSnapshotGuestCheckpointCompositionRow extends PortableSnapshotGuestCheckpointCompositionInput {
+    kind: typeof PORTABLE_SNAPSHOT_GUEST_CHECKPOINT_COMPOSITION_KIND;
+    state: PortableSnapshotGuestCheckpointCompositionState;
+    migrationCompleted: boolean;
+    scope: {
+        guestCheckpointSameIsaOnly: true;
+        crossIsaCheckpointImageRestoreClaimed: false;
+        machinenRestoreRequired: true;
+    };
+}
+interface PortableSnapshotGuestCheckpointCompositionSummary {
+    kind: "machinen.architecture-portable-snapshot.portable-snapshot-guest-checkpoint-composition-smoke";
+    state: "completed" | "failed";
+    pass: boolean;
+    rows: PortableSnapshotGuestCheckpointCompositionRow[];
+    completedRows: number;
+    refusedRows: number;
+    failures: string[];
+}
+declare function buildPortableSnapshotGuestCheckpointCompositionRow(input: PortableSnapshotGuestCheckpointCompositionInput): PortableSnapshotGuestCheckpointCompositionRow;
+declare function summarizePortableSnapshotGuestCheckpointCompositionRows(rows: PortableSnapshotGuestCheckpointCompositionRow[]): PortableSnapshotGuestCheckpointCompositionSummary;
+declare function validatePortableSnapshotGuestCheckpointCompositionRows(rows: PortableSnapshotGuestCheckpointCompositionRow[]): string[];
+
+declare const GUEST_CHECKPOINT_SUBSTRATE_KIND: "machinen.architecture-portable-snapshot.guest-checkpoint-substrate";
+declare const guestCheckpointSubstrateRefusalCodes: readonly ["guest-checkpoint-check-unavailable", "c-checkpoint-dump-restore-failed", "jvm-runtime-unavailable", "jvm-checkpoint-runtime-state-unsupported", "jvm-checkpoint-dump-restore-failed"];
+type GuestCheckpointSubstrateProfile = "c-simple" | "jvm-simple";
+type GuestCheckpointSubstrateState = "completed" | "refused" | "skipped";
+type GuestCheckpointSubstrateRefusalCode = (typeof guestCheckpointSubstrateRefusalCodes)[number];
+interface GuestCheckpointSubstrateInput {
+    guestArch: string;
+    kernelVersion: string;
+    checkpointToolVersion: string;
+    kernelFeatureProbeOutput: string;
+    profile: GuestCheckpointSubstrateProfile;
+    checkpointLog: string;
+    restoreLog: string;
+    verifierOutput: string;
+    state?: GuestCheckpointSubstrateState;
+    refusalCode?: GuestCheckpointSubstrateRefusalCode;
+    remediation?: string;
+    evidence?: Record<string, unknown>;
+}
+interface GuestCheckpointSubstrateRow {
+    kind: typeof GUEST_CHECKPOINT_SUBSTRATE_KIND;
+    guestArch: string;
+    kernelVersion: string;
+    checkpointToolVersion: string;
+    kernelFeatureProbeOutput: string;
+    profile: GuestCheckpointSubstrateProfile;
+    checkpointLog: string;
+    restoreLog: string;
+    verifierOutput: string;
+    state: GuestCheckpointSubstrateState;
+    refusalCode?: GuestCheckpointSubstrateRefusalCode;
+    remediation?: string;
+    evidence: Record<string, unknown>;
+    scope: {
+        sameGuest: true;
+        sameIsa: true;
+        crossIsaCheckpointReplay: false;
+        sourceIsaEmulationUsed: false;
+    };
+}
+interface GuestCheckpointSubstrateSummary {
+    kind: "machinen.architecture-portable-snapshot.guest-checkpoint-substrate-smoke";
+    state: "completed" | "failed";
+    pass: boolean;
+    rows: GuestCheckpointSubstrateRow[];
+    completedRows: number;
+    refusedRows: number;
+    skippedRows: number;
+    failures: string[];
+}
+declare function buildGuestCheckpointSubstrateRow(input: GuestCheckpointSubstrateInput): GuestCheckpointSubstrateRow;
+declare function summarizeGuestCheckpointSubstrateRows(rows: GuestCheckpointSubstrateRow[]): GuestCheckpointSubstrateSummary;
+declare function validateGuestCheckpointSubstrateRows(rows: GuestCheckpointSubstrateRow[]): string[];
+
+declare const STATEFUL_DATABASE_RESTORE_KIND: "machinen.architecture-portable-snapshot.stateful-database-restore";
+declare const statefulDatabaseRestoreRefusalCodes: readonly ["postgres-active-transaction-unsupported", "postgres-active-session-unsupported", "postgres-dirty-wal-boundary-unsupported", "postgres-host-mounted-data-dir-ambiguous", "postgres-physical-data-dir-cross-isa-unsupported", "postgres-target-verifier-mismatch", "postgres-extension-native-state-unsupported", "sqlite-dirty-rollback-journal-unsupported", "sqlite-dirty-wal-checkpoint-unsupported", "sqlite-active-writer-transaction-unsupported", "sqlite-mmap-or-lock-state-unsupported", "sqlite-target-verifier-mismatch"];
+type StatefulDatabaseRestoreRefusalCode = (typeof statefulDatabaseRestoreRefusalCodes)[number];
+type StatefulDatabaseRestoreArch = "arm64" | "amd64";
+type StatefulDatabaseRestoreDatabase = "postgresql" | "sqlite";
+type StatefulDatabaseRestoreStateModel = "logical-dump" | "checkpoint" | "rollback-journal" | "wal-checkpoint";
+type StatefulDatabaseRestoreState = "completed" | "refused";
+interface StatefulDatabaseRestoreInput {
+    database: StatefulDatabaseRestoreDatabase;
+    stateModel: StatefulDatabaseRestoreStateModel;
+    sourceArch: StatefulDatabaseRestoreArch;
+    targetArch: StatefulDatabaseRestoreArch;
+    databaseVersion: string;
+    artifactBytes: Buffer | string;
+    logicalData: Buffer | string;
+    sourceVerifierOutput: string;
+    targetVerifierOutput: string;
+    postgres?: {
+        activeTransactions?: number;
+        activeSessions?: number;
+        dirtyWal?: boolean;
+        hostMountedDataDir?: boolean;
+        physicalDataDirCopy?: boolean;
+        extensionNativeState?: boolean;
+        checkpointLsn?: string;
+    };
+    sqlite?: {
+        journalPolicy?: "rollback-clean-close" | "wal-checkpoint-truncate";
+        dirtyRollbackJournal?: boolean;
+        dirtyWal?: boolean;
+        activeWriterTransaction?: boolean;
+        mmapOrLockState?: boolean;
+    };
+}
+interface StatefulDatabaseRestoreSummary {
+    kind: typeof STATEFUL_DATABASE_RESTORE_KIND;
+    database: StatefulDatabaseRestoreDatabase;
+    stateModel: StatefulDatabaseRestoreStateModel;
+    sourceArch: StatefulDatabaseRestoreArch;
+    targetArch: StatefulDatabaseRestoreArch;
+    databaseVersion: string;
+    artifactDigest: string;
+    logicalDataDigest: string;
+    targetVerifierOutput: string;
+    migrationCompleted: boolean;
+    state: StatefulDatabaseRestoreState;
+    targetVerifierResult: "passed" | "failed" | "not-run";
+    refusalCode?: StatefulDatabaseRestoreRefusalCode;
+    remediation?: string;
+    evidence: Record<string, unknown>;
+    shortcutInspection: {
+        sourceIsaEmulationUsed: false;
+        sourceTextReusedAsTargetCode: false;
+        sidecarRuntimeUsed: false;
+        metadataOnlyShortcutAccepted: false;
+    };
+}
+declare function buildStatefulDatabaseRestoreSummary(input: StatefulDatabaseRestoreInput): StatefulDatabaseRestoreSummary;
+declare function postgresLogicalRestoreInput(input: Omit<StatefulDatabaseRestoreInput, "database" | "stateModel">): StatefulDatabaseRestoreInput;
+declare function sqliteRollbackJournalRestoreInput(input: Omit<StatefulDatabaseRestoreInput, "database" | "stateModel">): StatefulDatabaseRestoreInput;
+declare function sqliteWalCheckpointRestoreInput(input: Omit<StatefulDatabaseRestoreInput, "database" | "stateModel">): StatefulDatabaseRestoreInput;
+
+declare const OPPOSITE_ISA_VM_EXECUTION_KIND: "machinen.architecture-portable-snapshot.opposite-isa-vm-execution";
+declare const oppositeIsaVmExecutionRefusalCodes: readonly ["opposite-isa-provider-unavailable", "opposite-isa-assets-missing", "opposite-isa-not-opposite-route", "opposite-isa-boot-failed", "opposite-isa-guest-uname-mismatch", "opposite-isa-guest-elf-mismatch", "opposite-isa-verifier-incomplete", "opposite-isa-host-sidecar-output"];
+type OppositeIsaVmExecutionRefusalCode = (typeof oppositeIsaVmExecutionRefusalCodes)[number];
+type OppositeIsaVmExecutionArch = "arm64" | "amd64" | "unknown";
+type OppositeIsaVmExecutionState = "completed" | "refused" | "skipped";
+interface OppositeIsaVmExecutionProviderRoute {
+    hostArch: OppositeIsaVmExecutionArch;
+    guestArch: OppositeIsaVmExecutionArch;
+    providerMode: string;
+    accelerated: boolean;
+    emulated: boolean;
+    available: boolean;
+    unavailableReason?: OppositeIsaVmExecutionRefusalCode;
+    remediation?: string;
+}
+interface OppositeIsaVmExecutionEvidence {
+    hostArch: OppositeIsaVmExecutionArch;
+    guestArch: OppositeIsaVmExecutionArch;
+    providerMode: string;
+    accelerated: boolean;
+    emulated: boolean;
+    kernelVersion?: string | null;
+    rootfsDigest?: string | null;
+    guestUnameMachine?: string | null;
+    guestElfMachine?: string | null;
+    verifierOutput?: string | null;
+    verifierSource: "guest-exec" | "host-sidecar" | "unknown";
+    routeAvailable?: boolean;
+    unavailableReason?: OppositeIsaVmExecutionRefusalCode;
+    remediation?: string;
+}
+interface OppositeIsaVmExecutionSummary {
+    kind: typeof OPPOSITE_ISA_VM_EXECUTION_KIND;
+    hostArch: OppositeIsaVmExecutionArch;
+    guestArch: OppositeIsaVmExecutionArch;
+    providerMode: string;
+    accelerated: boolean;
+    emulated: boolean;
+    kernelVersion: string | null;
+    rootfsDigest: string | null;
+    guestUnameMachine: string | null;
+    guestElfMachine: string | null;
+    verifierOutput: string;
+    state: OppositeIsaVmExecutionState;
+    refusalCode?: OppositeIsaVmExecutionRefusalCode;
+    remediation?: string;
+}
+declare function hostArchitectureFromNode(arch?: string): OppositeIsaVmExecutionArch;
+declare function oppositeGuestArchitecture(hostArch: OppositeIsaVmExecutionArch): OppositeIsaVmExecutionArch;
+declare function normalizeGuestMachine(value: string | null | undefined): OppositeIsaVmExecutionArch;
+declare function classifyOppositeIsaProviderRoute(input: {
+    hostArch?: OppositeIsaVmExecutionArch;
+    guestArch: OppositeIsaVmExecutionArch;
+    platform?: NodeJS.Platform;
+    hasKvm?: boolean;
+    emulationAvailable?: boolean;
+}): OppositeIsaVmExecutionProviderRoute;
+declare function buildOppositeIsaVmExecutionSummary(evidence: OppositeIsaVmExecutionEvidence): OppositeIsaVmExecutionSummary;
+
+/** Portable cross-ISA machine snapshot boundary metadata. */
+
+declare const PORTABLE_MACHINE_SNAPSHOT_FORMAT_VERSION = 1;
+declare const PORTABLE_MACHINE_SNAPSHOT_FILES: {
+    readonly manifest: "portable-machine.json";
+    readonly nativeProcessImage: "native-process";
+};
+declare const portableMachineSnapshotArchitectures: readonly ["arm64", "amd64"];
+type PortableMachineSnapshotArchitecture = (typeof portableMachineSnapshotArchitectures)[number];
+declare const portableMachineSnapshotRefusalCodes: readonly ["cross-isa-vmstate-restore-unsupported", "raw-vcpu-state-unsupported", "raw-kernel-state-unsupported", "raw-device-state-unsupported", "target-isa-vm-restore-loader-missing", "portable-process-image-missing"];
+type PortableMachineSnapshotRefusalCode = (typeof portableMachineSnapshotRefusalCodes)[number];
+interface PortableMachineSnapshotRefusal {
+    code: PortableMachineSnapshotRefusalCode;
+    message: string;
+    detail?: Record<string, unknown>;
+}
+interface PortableMachineSnapshotRefusals {
+    vocabularyVersion: 1;
+    refusals: PortableMachineSnapshotRefusal[];
+}
+interface PortableMachineSnapshotDocuments {
+    rootDir?: string;
+    manifest: PortableMachineSnapshotManifest;
+    nativeProcessImage: NativeProcessImageDocuments;
+}
+interface PortableMachineSnapshotManifest {
+    formatVersion: 1;
+    kind: "machinen.portable-machine-snapshot";
+    source: {
+        guestArch: PortableMachineSnapshotArchitecture;
+        vmstate: {
+            rawRestore: "refused";
+            refusalCode: "cross-isa-vmstate-restore-unsupported";
+            reason: string;
+        };
+        kernelState: "not-translated";
+        deviceState: "not-translated";
+    };
+    target: {
+        guestArch: PortableMachineSnapshotArchitecture;
+        mode: "target-isa-vm-process-restore";
+        execution: "target-native";
+    };
+    payload: {
+        nativeProcessImage: {
+            kind: "machinen.native-process-image";
+            path: string;
+        };
+        resourceModel: "explicit-recipes-only";
+    };
+    refusals: PortableMachineSnapshotRefusals;
+}
+declare const portableMachineSnapshotManifestSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://machinen.dev/schemas/portable-machine-snapshot/manifest.schema.json";
+    readonly title: "Machinen portable machine snapshot manifest";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["formatVersion", "kind", "source", "target", "payload", "refusals"];
+    readonly properties: {
+        readonly formatVersion: {
+            readonly const: 1;
+        };
+        readonly kind: {
+            readonly const: "machinen.portable-machine-snapshot";
+        };
+        readonly source: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["guestArch", "vmstate", "kernelState", "deviceState"];
+            readonly properties: {
+                readonly guestArch: {
+                    readonly enum: readonly ["arm64", "amd64"];
+                };
+                readonly vmstate: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["rawRestore", "refusalCode", "reason"];
+                    readonly properties: {
+                        readonly rawRestore: {
+                            readonly const: "refused";
+                        };
+                        readonly refusalCode: {
+                            readonly const: "cross-isa-vmstate-restore-unsupported";
+                        };
+                        readonly reason: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly kernelState: {
+                    readonly const: "not-translated";
+                };
+                readonly deviceState: {
+                    readonly const: "not-translated";
+                };
+            };
+        };
+        readonly target: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["guestArch", "mode", "execution"];
+            readonly properties: {
+                readonly guestArch: {
+                    readonly enum: readonly ["arm64", "amd64"];
+                };
+                readonly mode: {
+                    readonly const: "target-isa-vm-process-restore";
+                };
+                readonly execution: {
+                    readonly const: "target-native";
+                };
+            };
+        };
+        readonly payload: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["nativeProcessImage", "resourceModel"];
+            readonly properties: {
+                readonly nativeProcessImage: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "path"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "machinen.native-process-image";
+                        };
+                        readonly path: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly resourceModel: {
+                    readonly const: "explicit-recipes-only";
+                };
+            };
+        };
+        readonly refusals: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["vocabularyVersion", "refusals"];
+            readonly properties: {
+                readonly vocabularyVersion: {
+                    readonly const: 1;
+                };
+                readonly refusals: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["code", "message"];
+                        readonly properties: {
+                            readonly code: {
+                                readonly enum: readonly ["cross-isa-vmstate-restore-unsupported", "raw-vcpu-state-unsupported", "raw-kernel-state-unsupported", "raw-device-state-unsupported", "target-isa-vm-restore-loader-missing", "portable-process-image-missing"];
+                            };
+                            readonly message: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly detail: {
+                                readonly type: "object";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+declare class PortableMachineSnapshotValidationError extends Error {
+    constructor(message: string);
+}
+declare function isPortableMachineSnapshotBundle(rootDir: string): boolean;
+declare function validatePortableMachineSnapshotBundle(rootDir: string): PortableMachineSnapshotDocuments;
+declare function buildPortableMachineSnapshotManifestFromNativeProcessImage(nativeProcessImage: NativeProcessImageDocuments, nativeProcessPath?: "native-process"): PortableMachineSnapshotManifest;
+declare function crossIsaVmstateRestoreRefusal(sourceArch: string, targetArch: string): PortableMachineSnapshotRefusal;
+declare function validatePortableMachineSnapshotManifest(input: unknown): PortableMachineSnapshotManifest;
+
+declare const MOVE_DESCRIPTOR_FORMAT_VERSION: 1;
+declare const MOVE_REFUSAL_CODE: "move-unproven-state-class";
+type MoveProcessStateClass = "process-identity" | "argv-env-cwd" | "open-files" | "sockets" | "threads" | "unknown";
+interface MovePidGraphNode {
+    pid: number;
+    ppid: number | undefined;
+    command: string;
+    argv: string[];
+    cwd: string | undefined;
+    exe?: string;
+}
+interface MovePidGraphEdge {
+    fromPid: number;
+    toPid: number;
+    kind: "parent-child";
+}
+interface MoveRefusalEvidence {
+    stateClass: MoveProcessStateClass;
+    reason: string;
+    evidence: string;
+    nextAction: string;
+}
+interface MovePidGraph {
+    formatVersion: typeof MOVE_DESCRIPTOR_FORMAT_VERSION;
+    kind: "machinen.move.pid-graph";
+    rootPid: number | undefined;
+    scannedAt: string;
+    nodes: MovePidGraphNode[];
+    edges: MovePidGraphEdge[];
+    translatedStateClasses: MoveProcessStateClass[];
+    refusedStateClasses: MoveRefusalEvidence[];
+}
+interface MoveDescriptor extends Omit<MovePidGraph, "kind"> {
+    kind: "machinen.move.descriptor";
+    target: "cross-isa-target-native-pid-translation";
+    productSurface: "machinen move";
+    resourcePlan?: {
+        kind: "machinen.move.resource-plan";
+        source: "guest-procfs" | "host-procfs";
+        sourceArch?: NativeProcessImageArchitecture;
+        resources: NativeProcessResource[];
+        fdTableEntries: NativeTargetFdTableEntry[];
+        targetGuestResources: TargetGuestRestoreResourceRecipe[];
+        refusals: NativeProcessImageRefusal[];
+        acceptedSubsets: string[];
+        capture?: {
+            sourceVm?: {
+                pid: number;
+                name?: string;
+            };
+            executablePackage?: {
+                path: string;
+                realPath?: string;
+                packageName?: string;
+                version?: string;
+                architecture?: string;
+            };
+            pingState?: {
+                ntransmitted: number;
+                nreceived: number;
+                nerrors: number;
+                lastSequence?: number;
+            };
+            safeBoundary?: {
+                state: "sleep-timer" | "pre-send-icmp" | "refused";
+                detail: string;
+            };
+            freeze?: {
+                state: "ptrace-attached" | "refused";
+                detail: string;
+            };
+            tasks?: number;
+            wchan?: string;
+            syscall?: string;
+            maps?: string[];
+            registers?: Record<string, unknown>;
+        };
+    };
+    nativeContinuation?: {
+        kind: "machinen.move.native-continuation";
+        bundlePath: ".";
+        activeSyscallPlan: "active-syscall-plan.json";
+        state: "planned" | "refused";
+        refusals: NativeProcessImageRefusal[];
+    };
+}
+interface MoveSaveResult {
+    accepted: boolean;
+    descriptorPath: string;
+    descriptor: MoveDescriptor;
+    refusalCode?: typeof MOVE_REFUSAL_CODE;
+    issueReport?: MoveIssueReport;
+}
+interface MoveIssueReport {
+    title: string;
+    body: string;
+    repository: string;
+}
+declare function scanMovePidGraph(rootPid?: number): MovePidGraph;
+declare function createMoveDescriptor(pid: number): MoveDescriptor;
+declare function saveMoveDescriptor(input: {
+    pid: number;
+    outPath: string;
+    issue?: boolean;
+    issueRepo?: string;
+}): MoveSaveResult;
+declare function loadMoveDescriptor(path: string): MoveDescriptor;
+declare function buildMoveIssueReport(descriptor: MoveDescriptor, repository?: string): MoveIssueReport;
+
+declare const PRODUCT_CLAIM_REGISTRY_FORMAT_VERSION: 1;
+declare const productSupportLevels: readonly ["deprecated-cross-isa-level", "level-5-cross-arch-process-continuation"];
+type ProductSupportLevel = (typeof productSupportLevels)[number];
+declare const productClaimStatuses: readonly ["implemented-product-support", "deprecated-legacy-support", "stable-product-refusal", "proof-only-fixture", "obsolete-invalid-claim"];
+type ProductClaimStatus = (typeof productClaimStatuses)[number];
+declare const productClaimFamilies: readonly ["postgresql", "nodejs", "go", "python-ruby-jvm", "stateful-services", "foundation-native", "native-linux-resource", "network-ping-socket", "unknown"];
+type ProductClaimFamily = (typeof productClaimFamilies)[number];
+declare const PRODUCT_CLAIM_PROOF_ONLY_REFUSAL_CODE: "product-surface-not-implemented";
+interface ProductClaimObservableStateDecision {
+    name: string;
+    decision: "preserved" | "recreated" | "drained" | "dropped-irrelevant" | "logically-restored" | "refused";
+    rationale: string;
+}
+interface ProductClaimProofProfileInput {
+    name: string;
+    description?: string;
+    expectedResult?: "success" | "refusal" | string;
+    supportStatus?: string;
+    unsafeStateFamily?: string;
+    expectedRefusalCode?: string;
+    capabilities?: string[];
+    refusesCapabilities?: string[];
+    refusalSupportContract?: {
+        currentRefusalCode?: string;
+        graduationRequires?: string[];
+    };
+    checkedSummary?: string;
+    sourceFixture?: string;
+    productSupportLevel?: ProductSupportLevel;
+    observableStateDecisions?: ProductClaimObservableStateDecision[];
+}
+interface ProductClaimEntry {
+    name: string;
+    family: ProductClaimFamily;
+    runtime?: string;
+    resourceFamily?: string;
+    architectureRoutes: Array<"arm64->amd64" | "amd64->arm64" | "amd64<->arm64">;
+    productStatus: ProductClaimStatus;
+    supportLevel: ProductSupportLevel;
+    supportLevelName: string;
+    proofStatus: string;
+    expectedResult: "success" | "refusal" | "unknown";
+    sourceGoal?: string;
+    unsafeStateFamily?: string;
+    refusalCode?: string;
+    productRefusalCode?: string;
+    migrationCompleted: boolean;
+    descriptorRequired: boolean;
+    targetNativeVerifierRequired: boolean;
+    proofOnly: boolean;
+    checkedSummary?: string;
+    sourceFixture?: string;
+    graduationRequirements: string[];
+    observableStateDecisions: ProductClaimObservableStateDecision[];
+    message: string;
+}
+interface ProductClaimRegistry {
+    kind: "machinen.product-claim-registry";
+    formatVersion: typeof PRODUCT_CLAIM_REGISTRY_FORMAT_VERSION;
+    entries: ProductClaimEntry[];
+    summary: ProductClaimRegistrySummary;
+}
+interface ProductClaimRegistrySummary {
+    total: number;
+    byStatus: Record<ProductClaimStatus, number>;
+    byFamily: Record<ProductClaimFamily, number>;
+    implementedProductSupport: number;
+    deprecatedLegacySupport: number;
+    stableProductRefusals: number;
+    proofOnlyFixtures: number;
+    obsoleteInvalidClaims: number;
+}
+interface ProductClaimRegistryFilter {
+    status?: ProductClaimStatus;
+    family?: ProductClaimFamily;
+    runtime?: string;
+    resourceFamily?: string;
+    profile?: string;
+    refusalCode?: string;
+    supportLevel?: ProductSupportLevel;
+}
+declare function buildProductClaimRegistry(proofProfiles: ProductClaimProofProfileInput[]): ProductClaimRegistry;
+declare function productClaimEntryFromProofProfile(profile: ProductClaimProofProfileInput): ProductClaimEntry;
+declare function summarizeProductClaimRegistry(entries: ProductClaimEntry[]): ProductClaimRegistrySummary;
+declare function filterProductClaimRegistry(entries: ProductClaimEntry[], filter: ProductClaimRegistryFilter): ProductClaimEntry[];
+declare function productClaimRefusalSummary(entry: ProductClaimEntry): {
+    state: "refused";
+    targetState: "refused";
+    migrationCompleted: false;
+    expectedRefusalCode: string;
+    message: string;
+    graduationRequirements: string[];
+} | undefined;
+
+type TargetNativeConsumptionStatus = "passed" | "failed";
+interface TargetNativeConsumptionEvent {
+    status?: TargetNativeConsumptionStatus;
+}
+interface TargetNativeConsumptionEvents {
+    nativeStackWindowMaterialization?: TargetNativeConsumptionEvent;
+    nativePrivateMemoryRestore?: TargetNativeConsumptionEvent;
+    nativeExecutableMapping?: TargetNativeConsumptionEvent;
+    nativeProcessContextRestore?: TargetNativeConsumptionEvent;
+    nativeSignalRestore?: TargetNativeConsumptionEvent;
+    nativeActiveSyscallRestore?: TargetNativeConsumptionEvent;
+    nativeThreadRestore?: TargetNativeConsumptionEvent;
+}
+declare function parseTargetNativeConsumptionEvents(actualResumeEvent: Record<string, unknown> | undefined): TargetNativeConsumptionEvents;
+declare function targetNativeConsumptionFields(events: TargetNativeConsumptionEvents): {
+    targetStackWindowMaterializationResult?: TargetNativeConsumptionStatus;
+    targetPrivateMemoryRestoreResult?: TargetNativeConsumptionStatus;
+    targetExecutableMappingResult?: TargetNativeConsumptionStatus;
+    targetProcessContextRestoreResult?: TargetNativeConsumptionStatus;
+    targetSignalRestoreResult?: TargetNativeConsumptionStatus;
+    targetActiveSyscallRestoreResult?: TargetNativeConsumptionStatus;
+    targetThreadRestoreResult?: TargetNativeConsumptionStatus;
+};
+declare function targetNativeConsumptionPassed(events: TargetNativeConsumptionEvents): boolean;
+
+type PortableMachineVmRestoreProofState = "ready" | "skipped" | "refused" | "completed";
+interface PortableMachineVmRestoreProofRequest {
+    bundleDir?: string;
+    targetCodeFile?: string;
+    targetImage?: string;
+}
+type PortableMachineTargetVerifierResult = "pending" | "passed" | "failed";
+type PortableMachineTargetContinuationKind = "generated-verifier" | "real-utility";
+type PortableMachineTargetStateConsumptionResult = "pending" | "passed" | "failed";
+type PortableMachineTargetNativePlanConsumptionResult = "pending" | "passed" | "failed";
+type PortableMachineTargetReturnChainResult = "pending" | "passed" | "failed";
+type PortableMachineTargetFrameRestoreResult = "pending" | "passed" | "failed";
+type PortableMachineTargetRegisterRestoreResult = "pending" | "passed" | "failed";
+type PortableMachineTargetRflagsRestoreResult = "pending" | "passed" | "failed";
+type PortableMachineTargetTlsRestoreResult = "pending" | "passed" | "failed";
+type PortableMachineTargetThreadRestoreResult = "accepted" | "refused" | "passed" | "failed";
+type PortableMachineTargetResumePathResult = "pending" | "passed" | "failed";
+interface PortableMachineTargetResourceStatus {
+    kind: string;
+    status: "passed" | "failed";
+}
+interface PortableMachineTargetRestoreObservation {
+    targetVerifierResult?: PortableMachineTargetVerifierResult;
+    targetStateConsumptionResult?: PortableMachineTargetStateConsumptionResult;
+    targetResourceStatuses?: PortableMachineTargetResourceStatus[];
+    targetStackWindowMaterializationResult?: PortableMachineTargetNativePlanConsumptionResult;
+    targetPrivateMemoryRestoreResult?: PortableMachineTargetNativePlanConsumptionResult;
+    targetExecutableMappingResult?: PortableMachineTargetNativePlanConsumptionResult;
+    targetProcessContextRestoreResult?: PortableMachineTargetNativePlanConsumptionResult;
+    targetSignalRestoreResult?: PortableMachineTargetNativePlanConsumptionResult;
+    targetActiveSyscallRestoreResult?: PortableMachineTargetNativePlanConsumptionResult;
+    targetReturnChainResult?: PortableMachineTargetReturnChainResult;
+    targetTranslatedReturnAddress?: string;
+    targetFrameRestoreResult?: PortableMachineTargetFrameRestoreResult;
+    targetTranslatedFramePointer?: string;
+    targetRegisterRestoreResult?: PortableMachineTargetRegisterRestoreResult;
+    targetRflagsRestoreResult?: PortableMachineTargetRflagsRestoreResult;
+    targetTlsRestoreResult?: PortableMachineTargetTlsRestoreResult;
+    targetThreadRestoreResult?: PortableMachineTargetThreadRestoreResult;
+    targetThreadRestoreThreadId?: string;
+    targetResumePathResult?: PortableMachineTargetResumePathResult;
+    targetResumePathMode?: string;
+}
+interface PortableMachineVmRestoreProofPlan extends PortableMachineTargetRestoreObservation {
+    phase: "portable-machine-vm-restore-proof";
+    state: PortableMachineVmRestoreProofState;
+    portableMachineBundle?: string;
+    targetCodeFile?: string;
+    targetImage?: string;
+    sourceGuestArch?: "arm64";
+    targetGuestArch?: "amd64";
+    targetVmRequired: true;
+    targetNativeCompletionRequired: true;
+    migrationCompleted: boolean;
+    descriptorGateCompleted: boolean;
+    descriptorMemoryEntryCount?: number;
+    descriptorFdRecipeCount?: number;
+    descriptorResourceKinds?: string[];
+    targetContinuationKind?: PortableMachineTargetContinuationKind;
+    targetContinuationStatus?: string;
+    targetContinuationReturnValue?: string;
+    targetModuleBytesSource?: string;
+    sourceTextReusedAsTargetCode: false;
+    sourceIsaEmulationUsed: false;
+    sidecarRuntimeUsed: false;
+    refusal?: {
+        code: string;
+        message: string;
+    };
+    skipReason?: string;
+}
+interface PortableMachineVmRestoreTargetResult extends PortableMachineTargetRestoreObservation {
+    exitCode: number;
+    migrationCompleted?: boolean;
+    descriptorGateCompleted?: boolean;
+    actualResumeEvent?: {
+        status?: string;
+        returnValue?: string;
+    };
+    sourceTextReusedAsTargetCode?: boolean;
+    sourceIsaEmulationUsed?: boolean;
+    sidecarRuntimeUsed?: boolean;
+}
+interface PortableMachineTargetRestoreDescriptorRequest {
+    continuation: TargetGuestRestoreContinuationDescriptor;
+    translatedFrame?: TargetGuestTranslatedFrameDescriptor;
+    fdTable: NativeTargetFdTablePlan;
+    memory: TargetGuestMemoryMaterializationResult;
+    nativeRestore?: TargetGuestNativeRestoreStep[];
+}
+type PortableMachineTargetRestoreDescriptorPlan = {
+    state: "ready";
+    descriptor: TargetGuestRestoreDescriptor;
+    refusals: [];
+    memoryEntryCount: number;
+    fdRecipeCount: number;
+    sourceTextReusedAsTargetCode: false;
+    sourceIsaEmulationUsed: false;
+    sidecarRuntimeUsed: false;
+} | {
+    state: "refused";
+    refusals: NativeProcessImageRefusal[];
+    memoryEntryCount: number;
+    fdRecipeCount: number;
+    sourceTextReusedAsTargetCode: false;
+    sourceIsaEmulationUsed: false;
+    sidecarRuntimeUsed: false;
+};
+declare function planPortableMachineTargetRestoreDescriptor(request: PortableMachineTargetRestoreDescriptorRequest): PortableMachineTargetRestoreDescriptorPlan;
+declare function planPortableMachineVmRestoreProof(request: PortableMachineVmRestoreProofRequest): PortableMachineVmRestoreProofPlan;
+declare function completePortableMachineVmRestoreProof(plan: PortableMachineVmRestoreProofPlan, result: PortableMachineVmRestoreTargetResult): PortableMachineVmRestoreProofPlan;
 
 /**
  * Bytes of memory the OS reports as available right now. "Available"
@@ -3914,4 +7664,4 @@ interface BalloonCounters {
  */
 declare function readBalloonStats(path: string): BalloonCounters | null;
 
-export { type AttachOptions, type BalloonCounters, BootError, type BootOptions, CacheError, type CheckForkBackpressureOptions, type ChunkLogEvent, DEFAULT_FREE_MEMORY_THRESHOLD, type EnsureMountDiskImageOptions, type EnsureMountDiskImageResult, type EnsureMountDiskUpperOptions, type EnsureMountDiskUpperResult, type EnsureRootfsImageOptions, ErrorCode, ExecError, FilesError, type ForkOptions, type GcResult, GvproxyError, type ImageConfig, type LogEvent, MachinenError, type MachinenErrorOptions, type MemoryStats, MkinitramfsError, MountError, NATIVE_PROCESS_IMAGE_FILES, NATIVE_PROCESS_IMAGE_FORMAT_VERSION, NATIVE_SYNTHETIC_PPOLL_SYSCALL_BASE, NATIVE_SYNTHETIC_PPOLL_SYSCALL_BUILD_ID, NATIVE_SYNTHETIC_PPOLL_SYSCALL_LOGICAL_NAME, NATIVE_SYNTHETIC_PPOLL_SYSCALL_PATH, NATIVE_SYNTHETIC_SLEEP_SYSCALL_BASE, NATIVE_SYNTHETIC_SLEEP_SYSCALL_BUILD_ID, NATIVE_SYNTHETIC_SLEEP_SYSCALL_FAILURE_EXIT_STATUS, NATIVE_SYNTHETIC_SLEEP_SYSCALL_LOGICAL_NAME, NATIVE_SYNTHETIC_SLEEP_SYSCALL_PATH, NATIVE_SYNTHETIC_SLEEP_SYSCALL_RESTART_EXIT_STATUS, NATIVE_SYNTHETIC_SLEEP_SYSCALL_UNMODELED_RETURN_EXIT_STATUS, NATIVE_SYNTHETIC_SYSCALL_RESTART_EXIT_STATUS, NATIVE_SYNTHETIC_SYSCALL_UNMODELED_RETURN_EXIT_STATUS, type NativeActivePpollTimeoutContinuation, type NativeActiveSleepTimerContinuation, type NativeActiveSyscallClass, type NativeActiveSyscallClassification, type NativeActiveSyscallClassificationResult, type NativeActiveSyscallContinuation, type NativeActiveSyscallPolicyOptions, type NativeActualRealUtilityContinuationBoundary, type NativeActualRealUtilityContinuationPlan, type NativeActualRealUtilityContinuationRequest, type NativeActualTargetModuleInventoryRequest, type NativeActualTargetModuleInventoryResult, type NativeAmd64Registers, type NativeArm64Registers, type NativeCodeLocationMapping, type NativeCodeMapRequest, type NativeCodeMapResult, type NativeCodeModule, type NativeCodeSymbol, type NativeContinuationTarget, type NativeDebugAddressTranslation, type NativeDebugMemoryField, type NativeDebugMemoryFieldClassification, type NativeDebugMemoryMetadataSource, type NativeDebugMemoryObject, type NativeDebugMemoryPointerClassificationRequest, type NativeDebugMemoryPointerClassificationResult, type NativeDiscoveredUnwindFrame, type NativeEhFrameTextParseRequest, type NativeEhFrameTextParseResult, type NativeInheritedStdioPolicy, type NativeMappingMaterializationAction, type NativeMappingMaterializationRequest, type NativeMappingMaterializationResult, type NativeMappingMaterializationStep, type NativeMemoryMapping, type NativeMemoryMappingKind, type NativeMemoryRelocation, type NativeMemoryTranslationRequest, type NativeMemoryTranslationResult, type NativeMemoryWord, type NativeModeledPpollTimeoutRemainingTime, type NativeModeledPpollTimeoutState, type NativeModeledSleepTimerRemainingTime, type NativeModeledSleepTimerState, type NativePollTimeoutSyscallPolicy, type NativePpollTimeoutModelResult, type NativeProcessImageArchitecture, type NativeProcessImageDocumentInput, type NativeProcessImageDocuments, type NativeProcessImageJsonSchema, type NativeProcessImageManifest, type NativeProcessImageMappings, type NativeProcessImageRefusal, type NativeProcessImageRefusalCode, type NativeProcessImageRefusals, type NativeProcessImageResources, type NativeProcessImageThreads, type NativeProcessImageTranslation, NativeProcessImageValidationError, type NativeProcessResource, type NativeProcessResourceKind, type NativeRealUtilityCodeLocationRequest, type NativeRealUtilityCodeLocationResult, type NativeRealUtilityContinuationBoundary, type NativeRealUtilityContinuationPlan, type NativeRealUtilityContinuationRequest, type NativeRealUtilityContinuationStrategy, type NativeRealUtilityDeferredActiveSyscallLanding, type NativeRealUtilityExecutableRange, type NativeRealUtilityModuleExpectation, type NativeRealUtilityResolvedLocation, type NativeRealUtilitySemanticContinuationSelection, type NativeRealUtilitySourceModule, type NativeRealUtilitySyntheticContinuationSelection, type NativeRealUtilityTargetContinuationKind, type NativeRealUtilityTargetModule, type NativeRealUtilityTargetSemanticContinuation, type NativeRegisterState, type NativeRegisterTranslationRequest, type NativeRegisterTranslationResult, type NativeResourceTranslationRequest, type NativeResourceTranslationResult, type NativeSleepTimerDuration, type NativeSleepTimerModelResult, type NativeSleepTimerSyscallPolicy, type NativeStackFrame, type NativeStackSlot, type NativeStackTranslationRequest, type NativeStackTranslationResult, type NativeSyntheticContinuationByteEncoding, type NativeSyntheticContinuationByteSource, type NativeSyntheticContinuationCompletionDescriptor, type NativeSyntheticContinuationFailureExitBucket, type NativeSyntheticContinuationFailureExitBucketCondition, type NativeSyntheticContinuationFailureKind, type NativeSyntheticContinuationProvenanceSource, type NativeSyntheticContinuationRegister, type NativeSyntheticContinuationRegisterSetupAbi, type NativeSyntheticContinuationRegisterSetupDescriptor, type NativeSyntheticContinuationStackSetupDescriptor, type NativeSyntheticContinuationSyscallAbi, type NativeSyntheticContinuationTargetArch, type NativeSyntheticPpollCompletionMode, type NativeSyntheticPpollSyscallArgumentProvenance, type NativeSyntheticPpollSyscallCompletionProvenance, type NativeSyntheticPpollSyscallContinuation, type NativeSyntheticPpollSyscallContinuationProvenance, type NativeSyntheticPpollSyscallContinuationRequest, type NativeSyntheticPpollSyscallContinuationResult, type NativeSyntheticPpollSyscallProvenanceSource, type NativeSyntheticPpollSyscallRegisterSetupProvenance, type NativeSyntheticPpollSyscallStackSetupProvenance, type NativeSyntheticSleepCompletionMode, type NativeSyntheticSleepSyscallArgumentProvenance, type NativeSyntheticSleepSyscallCompletionProvenance, type NativeSyntheticSleepSyscallContinuation, type NativeSyntheticSleepSyscallContinuationProvenance, type NativeSyntheticSleepSyscallContinuationRequest, type NativeSyntheticSleepSyscallContinuationResult, type NativeSyntheticSleepSyscallProvenanceSource, type NativeSyntheticSleepSyscallRegisterSetupProvenance, type NativeSyntheticSleepSyscallStackSetupProvenance, type NativeSyntheticSyscallArgumentDescriptor, type NativeSyntheticSyscallContinuationDescriptor, type NativeSyntheticSyscallContinuationDescriptorPayload, type NativeSyntheticSyscallContinuationDescriptorRequest, type NativeSyntheticSyscallDescriptor, type NativeSyntheticTargetCallerFrame, type NativeSyntheticTargetCallerFramePlanRequest, type NativeSyntheticTargetCallerFramePlanResult, type NativeSyntheticTargetCallerFramePolicy, type NativeSyntheticTargetCallerFrameSlot, type NativeSyntheticTargetCallerFrameStatePolicy, type NativeTargetCalleeSavedPolicy, type NativeTargetCalleeSavedSlot, type NativeTargetEhFrameTextParseRequest, type NativeTargetEhFrameTextParseResult, type NativeTargetFrameRegisterValue, type NativeTargetFrameStateMaterialization, type NativeTargetFrameStateMaterializationRequest, type NativeTargetFrameStateMaterializationResult, type NativeTargetFrameStateRegister, type NativeTargetFrameStateRequirement, type NativeTargetFrameStateValueSource, type NativeTargetLandingDisassemblyProvenance, type NativeTargetLandingFdeProvenance, type NativeTargetLandingInstructionBoundary, type NativeTargetLandingInstructionBoundaryState, type NativeTargetLandingModuleProvenance, type NativeTargetLandingSectionProvenance, type NativeTargetLandingSymbolProvenance, type NativeTargetModuleByteMaterialization, type NativeTargetModuleByteMaterializationRequest, type NativeTargetModuleByteMaterializationResult, type NativeTargetResumeExecutionAttempt, type NativeTargetResumeExecutionAttemptStatus, type NativeTargetResumeExecutionMode, type NativeTargetResumeExecutionPlan, type NativeTargetResumeExecutionPlanRequest, type NativeTargetResumeExecutionPlanResult, type NativeTargetResumeExecutor, type NativeTargetResumeFaultBoundary, type NativeTargetResumeFaultClassification, type NativeTargetResumeFaultClassificationOptions, type NativeTargetResumeFaultClassificationResult, type NativeTargetResumeFaultRegisters, type NativeTargetResumeLandingInspectionRequest, type NativeTargetResumeLandingProvenance, type NativeTargetUnwindFrameMatch, type NativeTargetUnwindFrameRule, type NativeTargetUnwindMatchRequest, type NativeTargetUnwindMatchResult, type NativeTargetUnwindRegister, type NativeThreadState, type NativeThreadTranslation, type NativeUnwindFrameDiscoveryRequest, type NativeUnwindFrameDiscoveryResult, type NativeUnwindFrameRule, type NativeUnwindMetadataKind, type NativeUnwindRegister, type NativeUnwindStackWord, type OnLog, type OnOutputListener, type PackBundleOptions, type PackMinimalOptions, type PackRootfsOptions, type PackTinyBundleOptions, type PackWorkspaceOptions, ParseError, type PhaseLogEvent, type PidStatus, ProvisionError, type ProvisionOptions, type ProvisionResult, type PtyBootOptions, type PtyVmHandle, type RegistryEntry, RegistryError, type RestoreOptions, type RssTarget, type RunGcOptions, STATS_FILE_SIZE, type SandboxEntry, SandboxError, Sandboxes, SecretsError, type SnapshotEngine, SnapshotError, type SnapshotFileIdentity, type SnapshotMeta, type SnapshotOptions, type SnapshotResult, Supervisor, type SupervisorOptions, type VmHandle, type VmstateBackend, type VmstateSnapshotMeta, VsockExec, type VsockExecOptions, type VsockExecPtyHandle, type VsockExecPtyOptions, type VsockExecPtyResult, type VsockExecResult, VsockFiles, type VsockFilesOptions, VsockSecrets, type VsockSecretsOptions, VsockWinsize, type VsockWinsizeOptions, WinsizeError, type WriteFileOptions, _internal, assertNativeProcessImageDocuments, attach, autoSizeMemoryMib, boot, bootPty, bootSnapshotPath, buildMachinenConfig, buildNativeCodeMap, buildNativeSyntheticPpollSyscallContinuation, buildNativeSyntheticSleepSyscallContinuation, buildNativeSyntheticSyscallContinuationDescriptor, buildWriteFileCmd, buildWriteFileCmds, checkForkBackpressure, classifyNativeActiveSyscalls, classifyNativeDebugMemoryPointers, classifyNativeTargetResumeExecutionAttempt, classifyNativeThreadSyscall, detachedLogRoot, discoverNativeUnwindFrames, ensureMountDiskImage, ensureMountDiskUpper, ensureRootfsImage, formatMachinenError, inspectNativeTargetResumeLanding, inventoryNativeActualTargetModules, inventoryNativeSourceCodeModules, isMachinenError, isNativeProcessImageBundle, list, markMountDiskImageClean, markRootfsImageClean, matchNativeTargetUnwindFrame, materializeNativeTargetModuleBytes, measureFirstByte, packBundle as mkinitramfsBundle, cli as mkinitramfsCli, packMinimal as mkinitramfsMinimal, packRootfs as mkinitramfsRootfs, packTinyBundle as mkinitramfsTinyBundle, packWorkspace as mkinitramfsWorkspace, modelNativePpollTimeoutState, modelNativeSleepTimerState, mountdiskImgCacheDir, nativeProcessImageArchitectures, nativeProcessImageRefusalCodes, nativeProcessImageSchemas, nativeSyntheticContinuationBytesHex, nativeSyntheticContinuationBytesSha256, nativeSyntheticContinuationDescriptorSha256, nativeSyntheticExitProcessSuffix, nativeSyntheticRestartLikeErrnos, nativeSyntheticSyscallFailureExitBuckets, nativeTargetResumeLandingRefusals, nativeUnwindReturnAddressSlot, parseNativeEhFrameText, parseNativeTargetEhFrameText, planNativeActualRealUtilityContinuationAttempt, planNativeMappingMaterialization, planNativeRealUtilityContinuationAttempt, planNativeSyntheticTargetCallerFrame, planNativeTargetFrameStateMaterialization, planNativeTargetResumeExecution, provision, readBalloonStats, readHostFreeBytes, readHostRssBytes, readHostRssBytesMulti, readHostTotalBytes, registryRoot, resolveBaseDtb, resolveBaseKernel, resolveBaseRootfs, resolveMke2fs, resolveMksquashfs, resolveNativeRealUtilityCodeLocations, resolveVmmBinary, restore, rootfsImgCacheDir, runGc, translateNativeMemory, translateNativeRegisterState, translateNativeResources, translateNativeStack, validateNativeProcessImageBundle, validateNativeProcessImageDocuments, validatePid, warmImageConfigCache, writeBootSnapshot };
+export { ADVANCED_LINUX_FACILITY_PROBE_KIND, ARCHITECTURE_PORTABLE_SNAPSHOT_GAUNTLET_KIND, ARCHITECTURE_PORTABLE_SNAPSHOT_GAUNTLET_ROW_KIND, type AdvancedLinuxFacilityProbeClassification, type AdvancedLinuxFacilityProbeFacility, type AdvancedLinuxFacilityProbeInput, type AdvancedLinuxFacilityProbeRefusalCode, type AdvancedLinuxFacilityProbeRow, type AdvancedLinuxFacilityProbeStateModel, type AdvancedLinuxFacilityProbeSummary, type ArchitecturePortableSnapshotEvidenceCategory, type ArchitecturePortableSnapshotGauntletEvidenceStatus, type ArchitecturePortableSnapshotGauntletRow, type ArchitecturePortableSnapshotGauntletRowInput, type ArchitecturePortableSnapshotGauntletSummary, type ArchitecturePortableSnapshotProductSupport, type ArchitecturePortableSnapshotTargetExecution, type AttachOptions, type BalloonCounters, BootError, type BootOptions, CacheError, type CheckForkBackpressureOptions, type ChunkLogEvent, type CreateNodeLevel5DeclaredSubsetCaptureInput, DEFAULT_FREE_MEMORY_THRESHOLD, DEFAULT_NODE_LEVEL5_PRODUCT_SNAPSHOT_DIRECTION, type EnsureMountDiskImageOptions, type EnsureMountDiskImageResult, type EnsureMountDiskUpperOptions, type EnsureMountDiskUpperResult, type EnsureRootfsImageOptions, ErrorCode, ExecError, FilesError, type ForkOptions, GUEST_CHECKPOINT_SUBSTRATE_KIND, type GcResult, type GuestCheckpointSubstrateInput, type GuestCheckpointSubstrateProfile, type GuestCheckpointSubstrateRefusalCode, type GuestCheckpointSubstrateRow, type GuestCheckpointSubstrateState, type GuestCheckpointSubstrateSummary, GvproxyError, type ImageConfig, LEVEL5_RUNTIME_ADAPTER_SUBSTRATE_FORMAT_VERSION, type Level5AdapterDetectInput, type Level5AdapterDetection, type Level5AdapterOperation, type Level5ArchitectureMetadata, type Level5ArtifactEnvelope, type Level5EvidenceStatus, type Level5GraduationTargetLevel, type Level5ImplementationLevel, type Level5ProductSupport, type Level5QuiesceResult, type Level5RefusalEnvelope, type Level5RestorePlan, type Level5RuntimeAdapter, type Level5RuntimeAdapterMatch, type Level5RuntimeAdapterRegistry, type Level5RuntimeAdapterRegistrySummary, type Level5RuntimeFamily, type Level5StatusFields, type Level5SubstrateRefusalCode, type Level5ValidationResult, type Level5VerifierEvidence, type LogEvent, MOVE_DESCRIPTOR_FORMAT_VERSION, MOVE_REFUSAL_CODE, MachinenError, type MachinenErrorOptions, type MemoryStats, MkinitramfsError, MountError, type MoveDescriptor, type MoveIssueReport, type MovePidGraph, type MovePidGraphEdge, type MovePidGraphNode, type MoveProcessStateClass, type MoveRefusalEvidence, type MoveSaveResult, NATIVE_MACHINE_RESTORE_DESCRIPTOR_FORMAT_VERSION, NATIVE_MACHINE_RESTORE_DESCRIPTOR_KIND, NATIVE_PROCESS_IMAGE_FILES, NATIVE_PROCESS_IMAGE_FORMAT_VERSION, NATIVE_SIMD_FPU_LIVE_SUBSET_POLICY, NATIVE_SYNTHETIC_PPOLL_SYSCALL_BASE, NATIVE_SYNTHETIC_PPOLL_SYSCALL_BUILD_ID, NATIVE_SYNTHETIC_PPOLL_SYSCALL_LOGICAL_NAME, NATIVE_SYNTHETIC_PPOLL_SYSCALL_PATH, NATIVE_SYNTHETIC_SLEEP_SYSCALL_BASE, NATIVE_SYNTHETIC_SLEEP_SYSCALL_BUILD_ID, NATIVE_SYNTHETIC_SLEEP_SYSCALL_EINTR_EXIT_STATUS, NATIVE_SYNTHETIC_SLEEP_SYSCALL_FAILURE_EXIT_STATUS, NATIVE_SYNTHETIC_SLEEP_SYSCALL_LOGICAL_NAME, NATIVE_SYNTHETIC_SLEEP_SYSCALL_PATH, NATIVE_SYNTHETIC_SLEEP_SYSCALL_RESTART_EXIT_STATUS, NATIVE_SYNTHETIC_SLEEP_SYSCALL_UNMODELED_RETURN_EXIT_STATUS, NATIVE_SYNTHETIC_SYSCALL_EINTR_EXIT_STATUS, NATIVE_SYNTHETIC_SYSCALL_RESTART_EXIT_STATUS, NATIVE_SYNTHETIC_SYSCALL_UNMODELED_RETURN_EXIT_STATUS, NESTED_VIRTUALIZATION_STRETCH_PROOF_KIND, NODE_LEVEL5_APP_SUPPORT_MATRIX_KIND, NODE_LEVEL5_APP_SUPPORT_MATRIX_VERSION, NODE_LEVEL5_DECLARED_SUBSET_FORMAT_VERSION, NODE_LEVEL5_DECLARED_SUBSET_MANIFEST, NODE_LEVEL5_DECLARED_SUBSET_RESTORE_SUMMARY, NODE_LEVEL5_GENERIC_VM_CORPUS_REPORT_KIND, NODE_LEVEL5_GENERIC_VM_CORPUS_REPORT_VERSION, NODE_LEVEL5_GENERIC_VM_REFUSAL_ARTIFACTS_REPORT_KIND, NODE_LEVEL5_GENERIC_VM_REFUSAL_ARTIFACTS_REPORT_VERSION, NODE_LEVEL5_GENERIC_VM_RETAINED_EVIDENCE_REPORT_KIND, NODE_LEVEL5_GENERIC_VM_RETAINED_EVIDENCE_REPORT_VERSION, NODE_LEVEL5_GENERIC_VM_ROW_ARTIFACTS_REPORT_KIND, NODE_LEVEL5_GENERIC_VM_ROW_ARTIFACTS_REPORT_VERSION, NODE_LEVEL5_HTTP_PROFILE_FORMAT_VERSION, NODE_LEVEL5_HTTP_PROFILE_NAME, NODE_LEVEL5_INSTALLED_THIRD_PARTY_APP_CORPUS_REPORT_KIND, NODE_LEVEL5_INSTALLED_THIRD_PARTY_APP_CORPUS_REPORT_VERSION, NODE_LEVEL5_PRODUCT_BEHAVIORAL_VERIFIER_REPORT_KIND, NODE_LEVEL5_PRODUCT_CAPTURE_REPORT_KIND, NODE_LEVEL5_PRODUCT_DETECTOR_REPORT_KIND, NODE_LEVEL5_PRODUCT_RESTORE_LAUNCH_REPORT_KIND, NODE_LEVEL5_PRODUCT_RESTORE_MATERIALIZATION_REPORT_KIND, NODE_LEVEL5_PRODUCT_SNAPSHOT_KIND, NODE_LEVEL5_PRODUCT_SNAPSHOT_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_20_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_20_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_50_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_50_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_65_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_65_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_80_ARTIFACT_BUNDLE_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_80_HARDENING_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_80_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_80_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_85_CLAIM_READY_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_85_CLAIM_READY_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_85_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_85_READINESS_KIND, NODE_LEVEL5_PRODUCT_SUPPORT_85_READINESS_VERSION, NODE_LEVEL5_PRODUCT_SUPPORT_85_VERSION, NODE_LEVEL5_PRODUCT_TARGET_IDENTITY_KIND, NODE_LEVEL5_PROOF_COMPOSITION_FORMAT_VERSION, NODE_LEVEL5_READINESS_MATRIX_KIND, NODE_LEVEL5_READINESS_MATRIX_VERSION, NODE_LEVEL5_REAL_APP_CORPUS_REPORT_KIND, NODE_LEVEL5_REAL_APP_CORPUS_REPORT_VERSION, NODE_LEVEL5_REAL_APP_REFUSAL_CORPUS_REPORT_KIND, NODE_LEVEL5_REAL_APP_REFUSAL_CORPUS_REPORT_VERSION, NODE_LEVEL5_TARGET_SIDE_PROOF_FORMAT_VERSION, NODE_LEVEL5_THIRD_PARTY_APP_CORPUS_REPORT_KIND, NODE_LEVEL5_THIRD_PARTY_APP_CORPUS_REPORT_VERSION, NODE_PROPER_LEVEL5_HTTP_STATE_POLICY_KIND, NODE_PROPER_LEVEL5_LIBUV_TIMER_RECOVERY_KIND, NODE_PROPER_LEVEL5_SOURCE_INSPECTION_KIND, NODE_PROPER_LEVEL5_V8_CLOSURE_RECOVERY_KIND, NODE_PROPER_LEVEL5_V8_OBJECT_RECOVERY_KIND, type NativeActiveFdReadContinuation, type NativeActiveFdWriteContinuation, type NativeActivePingSocketRecvmsgContinuation, type NativeActivePpollTimeoutContinuation, type NativeActiveSleepTimerContinuation, type NativeActiveSyscallClass, type NativeActiveSyscallClassification, type NativeActiveSyscallClassificationResult, type NativeActiveSyscallContinuation, type NativeActiveSyscallPolicyOptions, type NativeActualRealUtilityContinuationBoundary, type NativeActualRealUtilityContinuationPlan, type NativeActualRealUtilityContinuationRequest, type NativeActualTargetModuleInventoryRequest, type NativeActualTargetModuleInventoryResult, type NativeAmd64Registers, type NativeArm64Registers, type NativeCodeLocationMapping, type NativeCodeMapRequest, type NativeCodeMapResult, type NativeCodeModule, type NativeCodeSymbol, type NativeContinuationTarget, type NativeControlledTwoThreadRestorePlan, type NativeControlledTwoThreadRestorePlanRequest, type NativeDebugAddressTranslation, type NativeDebugMemoryField, type NativeDebugMemoryFieldClassification, type NativeDebugMemoryMetadataSource, type NativeDebugMemoryObject, type NativeDebugMemoryPointerClassificationRequest, type NativeDebugMemoryPointerClassificationResult, type NativeDiscoveredUnwindFrame, type NativeEhFrameTextParseRequest, type NativeEhFrameTextParseResult, type NativeFdReadModelResult, type NativeFdReadPolicy, type NativeFdReadResourcePolicy, type NativeFdWriteModelResult, type NativeFdWritePolicy, type NativeFdWriteResourcePolicy, type NativeInheritedStdioPolicy, type NativeMachineRestoreDescriptor, NativeMachineRestoreDescriptorValidationError, type NativeMachineRestorePlan, type NativeMachineRestorePlanRequest, type NativeMappingMaterializationAction, type NativeMappingMaterializationRequest, type NativeMappingMaterializationResult, type NativeMappingMaterializationStep, type NativeMemoryMapping, type NativeMemoryMappingKind, type NativeMemoryRelocation, type NativeMemoryTranslationRequest, type NativeMemoryTranslationResult, type NativeMemoryWord, type NativeModeledFdReadState, type NativeModeledFdReadTargetResource, type NativeModeledFdReadTimerRemainingTime, type NativeModeledFdWriteState, type NativeModeledFdWriteTargetResource, type NativeModeledPingSocketRecvmsgState, type NativeModeledPpollFdState, type NativeModeledPpollTargetResource, type NativeModeledPpollTimeoutRemainingTime, type NativeModeledPpollTimeoutState, type NativeModeledSleepTimerRemainingTime, type NativeModeledSleepTimerState, type NativePingSocketRecvmsgModelResult, type NativePingSocketRecvmsgPolicy, type NativePollTimeoutFdPolicy, type NativePollTimeoutSyscallPolicy, type NativePpollTimeoutModelResult, type NativePrivateWritableGuardRequest, type NativeProcessImageArchitecture, type NativeProcessImageDocumentInput, type NativeProcessImageDocuments, type NativeProcessImageJsonSchema, type NativeProcessImageManifest, type NativeProcessImageMappings, type NativeProcessImageRefusal, type NativeProcessImageRefusalCode, type NativeProcessImageRefusals, type NativeProcessImageResources, type NativeProcessImageThreads, type NativeProcessImageTranslation, NativeProcessImageValidationError, type NativeProcessResource, type NativeProcessResourceKind, type NativeRealUtilityCodeLocationRequest, type NativeRealUtilityCodeLocationResult, type NativeRealUtilityContinuationBoundary, type NativeRealUtilityContinuationPlan, type NativeRealUtilityContinuationRequest, type NativeRealUtilityContinuationStrategy, type NativeRealUtilityDeferredActiveSyscallLanding, type NativeRealUtilityExecutableRange, type NativeRealUtilityModuleExpectation, type NativeRealUtilityResolvedLocation, type NativeRealUtilitySemanticContinuationSelection, type NativeRealUtilitySourceModule, type NativeRealUtilitySyntheticContinuationSelection, type NativeRealUtilityTargetContinuationKind, type NativeRealUtilityTargetModule, type NativeRealUtilityTargetSemanticContinuation, type NativeRegisterState, type NativeRegisterTranslationRequest, type NativeRegisterTranslationResult, type NativeResourceTranslationRequest, type NativeResourceTranslationResult, type NativeReturnChainFrame, type NativeReturnChainFrameWrite, type NativeReturnChainMaterialization, type NativeReturnChainPlan, type NativeReturnChainPlanFrame, type NativeReturnChainPlanRequest, type NativeSignalBlockedMaskPolicy, type NativeSignalRestorePolicyRequest, type NativeSignalRestorePolicyResult, type NativeSimdFpuLiveSubset, type NativeSimdFpuLiveSubsetPolicy, type NativeSimdFpuRestorePolicyResult, type NativeSimdFpuState, type NativeSleepTimerDuration, type NativeSleepTimerModelResult, type NativeSleepTimerSyscallPolicy, type NativeStackFrame, type NativeStackPointerRange, type NativeStackSlot, type NativeStackTranslationRequest, type NativeStackTranslationResult, type NativeStackWindowGuardMapping, type NativeStackWindowMaterializationPlan, type NativeStackWindowMaterializationRequest, type NativeStackWindowMaterializedWrites, type NativeStackWindowWrite, type NativeSyntheticContinuationByteEncoding, type NativeSyntheticContinuationByteSource, type NativeSyntheticContinuationCompletionDescriptor, type NativeSyntheticContinuationFailureExitBucket, type NativeSyntheticContinuationFailureExitBucketCondition, type NativeSyntheticContinuationFailureKind, type NativeSyntheticContinuationProvenanceSource, type NativeSyntheticContinuationRegister, type NativeSyntheticContinuationRegisterSetupAbi, type NativeSyntheticContinuationRegisterSetupDescriptor, type NativeSyntheticContinuationRestartContract, type NativeSyntheticContinuationStackSetupDescriptor, type NativeSyntheticContinuationSyscallAbi, type NativeSyntheticContinuationTargetArch, type NativeSyntheticPpollCompletionMode, type NativeSyntheticPpollSyscallArgumentProvenance, type NativeSyntheticPpollSyscallCompletionProvenance, type NativeSyntheticPpollSyscallContinuation, type NativeSyntheticPpollSyscallContinuationProvenance, type NativeSyntheticPpollSyscallContinuationRequest, type NativeSyntheticPpollSyscallContinuationResult, type NativeSyntheticPpollSyscallProvenanceSource, type NativeSyntheticPpollSyscallRegisterSetupProvenance, type NativeSyntheticPpollSyscallStackSetupProvenance, type NativeSyntheticSleepCompletionMode, type NativeSyntheticSleepSyscallArgumentProvenance, type NativeSyntheticSleepSyscallCompletionProvenance, type NativeSyntheticSleepSyscallContinuation, type NativeSyntheticSleepSyscallContinuationProvenance, type NativeSyntheticSleepSyscallContinuationRequest, type NativeSyntheticSleepSyscallContinuationResult, type NativeSyntheticSleepSyscallProvenanceSource, type NativeSyntheticSleepSyscallRegisterSetupProvenance, type NativeSyntheticSleepSyscallStackSetupProvenance, type NativeSyntheticSyscallArgumentDescriptor, type NativeSyntheticSyscallContinuationDescriptor, type NativeSyntheticSyscallContinuationDescriptorPayload, type NativeSyntheticSyscallContinuationDescriptorRequest, type NativeSyntheticSyscallDescriptor, type NativeSyntheticTargetCallerFrame, type NativeSyntheticTargetCallerFramePlanRequest, type NativeSyntheticTargetCallerFramePlanResult, type NativeSyntheticTargetCallerFramePolicy, type NativeSyntheticTargetCallerFrameSlot, type NativeSyntheticTargetCallerFrameStatePolicy, type NativeTargetCalleeSavedPolicy, type NativeTargetCalleeSavedSlot, type NativeTargetEhFrameTextParseRequest, type NativeTargetEhFrameTextParseResult, type NativeTargetFdTableEntry, type NativeTargetFdTableEntryKind, type NativeTargetFdTablePlan, type NativeTargetFdTablePlanRequest, type NativeTargetFrameRegisterValue, type NativeTargetFrameStateMaterialization, type NativeTargetFrameStateMaterializationRequest, type NativeTargetFrameStateMaterializationResult, type NativeTargetFrameStateRegister, type NativeTargetFrameStateRequirement, type NativeTargetFrameStateValueSource, type NativeTargetLandingDisassemblyProvenance, type NativeTargetLandingFdeProvenance, type NativeTargetLandingInstructionBoundary, type NativeTargetLandingInstructionBoundaryState, type NativeTargetLandingModuleProvenance, type NativeTargetLandingSectionProvenance, type NativeTargetLandingSymbolProvenance, type NativeTargetModuleByteMaterialization, type NativeTargetModuleByteMaterializationRequest, type NativeTargetModuleByteMaterializationResult, type NativeTargetResumeExecutionAttempt, type NativeTargetResumeExecutionAttemptStatus, type NativeTargetResumeExecutionMode, type NativeTargetResumeExecutionPlan, type NativeTargetResumeExecutionPlanRequest, type NativeTargetResumeExecutionPlanResult, type NativeTargetResumeExecutor, type NativeTargetResumeFaultBoundary, type NativeTargetResumeFaultClassification, type NativeTargetResumeFaultClassificationOptions, type NativeTargetResumeFaultClassificationResult, type NativeTargetResumeFaultRegisters, type NativeTargetResumeLandingInspectionRequest, type NativeTargetResumeLandingProvenance, type NativeTargetUnwindFrameMatch, type NativeTargetUnwindFrameRule, type NativeTargetUnwindMatchRequest, type NativeTargetUnwindMatchResult, type NativeTargetUnwindRegister, type NativeThreadRestorePlan, type NativeThreadRestorePlanRequest, type NativeThreadState, type NativeThreadTlsPolicyRequest, type NativeThreadTranslation, type NativeTlsAmd64SegmentBases, type NativeTlsSegmentBaseHandoffRequest, type NativeTlsSegmentBaseHandoffResult, type NativeTlsTargetAccessPolicy, type NativeTlsThreadPointerRegister, type NativeUnwindFrameDiscoveryRequest, type NativeUnwindFrameDiscoveryResult, type NativeUnwindFrameRule, type NativeUnwindMetadataKind, type NativeUnwindRegister, type NativeUnwindStackWord, type NestedVirtProbeHost, type NestedVirtProbeResult, type NestedVirtualizationStretchProofClassification, type NestedVirtualizationStretchProofInput, type NestedVirtualizationStretchProofRefusalCode, type NestedVirtualizationStretchProofRow, type NestedVirtualizationStretchProofSummary, type NodeLevel5AppCorpusGate, type NodeLevel5AppSupportBoundary, type NodeLevel5AppSupportDirection, type NodeLevel5AppSupportEvidence, type NodeLevel5AppSupportEvidenceKind, type NodeLevel5AppSupportFeatureAssessment, type NodeLevel5AppSupportFeatureName, type NodeLevel5AppSupportFeatureStatus, type NodeLevel5AppSupportFeatures, type NodeLevel5AppSupportFramework, type NodeLevel5AppSupportMatrix, type NodeLevel5AppSupportMatrixRow, type NodeLevel5AppSupportMiddlewareFeature, type NodeLevel5AppSupportProductBehavior, type NodeLevel5AppSupportResponseFeature, type NodeLevel5AppSupportRouteFeature, type NodeLevel5AppSupportStatus, type NodeLevel5CorpusHttpEvidence, type NodeLevel5DeclaredSubsetArchitecture, type NodeLevel5DeclaredSubsetCaptureSummary, type NodeLevel5DeclaredSubsetManifest, type NodeLevel5DeclaredSubsetRefusal, type NodeLevel5DeclaredSubsetRefusalCode, type NodeLevel5DeclaredSubsetRestoreSummary, type NodeLevel5DeclaredSubsetSupportMatrix, type NodeLevel5GenericVmCorpusReport, type NodeLevel5GenericVmCorpusRow, type NodeLevel5GenericVmCorpusVerification, type NodeLevel5GenericVmModuleSystem, type NodeLevel5GenericVmPositiveRow, type NodeLevel5GenericVmRefusalArtifactFile, type NodeLevel5GenericVmRefusalArtifactsReport, type NodeLevel5GenericVmRefusalArtifactsVerification, type NodeLevel5GenericVmRefusalMarker, type NodeLevel5GenericVmRefusalRow, type NodeLevel5GenericVmRetainedEvidenceFile, type NodeLevel5GenericVmRetainedEvidenceReport, type NodeLevel5GenericVmRetainedEvidenceVerification, type NodeLevel5GenericVmRowArtifactFile, type NodeLevel5GenericVmRowArtifactsReport, type NodeLevel5GenericVmRowArtifactsVerification, type NodeLevel5HttpProfileCapture, type NodeLevel5HttpProfileCaptureInput, type NodeLevel5HttpProfileRefusal, type NodeLevel5HttpProfileRefusalCode, type NodeLevel5HttpProfileSelectedState, type NodeLevel5InstalledThirdPartyAppCorpusReport, type NodeLevel5InstalledThirdPartyAppCorpusRow, type NodeLevel5InstalledThirdPartyAppCorpusVerification, type NodeLevel5InstalledThirdPartyAppSource, type NodeLevel5ProductBehavioralVerifierReport, type NodeLevel5ProductCaptureReport, type NodeLevel5ProductDetectedFeature, type NodeLevel5ProductDetectorReport, type NodeLevel5ProductRestoreLaunchReport, type NodeLevel5ProductRestoreMaterializationReport, type NodeLevel5ProductRestoreSummary, type NodeLevel5ProductSnapshotDirection, type NodeLevel5ProductSnapshotManifest, type NodeLevel5ProductSnapshotRefusal, type NodeLevel5ProductSnapshotRefusalCode, type NodeLevel5ProductSnapshotSummary, type NodeLevel5ProductSupport20Matrix, type NodeLevel5ProductSupport50Family, type NodeLevel5ProductSupport50FamilyId, type NodeLevel5ProductSupport50Matrix, type NodeLevel5ProductSupport65Family, type NodeLevel5ProductSupport65FamilyId, type NodeLevel5ProductSupport65Matrix, type NodeLevel5ProductSupport80ArtifactBundle, type NodeLevel5ProductSupport80ArtifactVerification, type NodeLevel5ProductSupport80ClaimRegistry, type NodeLevel5ProductSupport80Family, type NodeLevel5ProductSupport80FamilyId, type NodeLevel5ProductSupport80Matrix, type NodeLevel5ProductSupport80UnsupportedDetector, type NodeLevel5ProductSupport85ClaimReadyGate, type NodeLevel5ProductSupport85ClaimReadyGateId, type NodeLevel5ProductSupport85ClaimReadyGateStatus, type NodeLevel5ProductSupport85ClaimReadyReport, type NodeLevel5ProductSupport85ClaimRegistry, type NodeLevel5ProductSupport85ReadinessGate, type NodeLevel5ProductSupport85ReadinessGateId, type NodeLevel5ProductSupport85ReadinessGateStatus, type NodeLevel5ProductSupport85ReadinessReport, type NodeLevel5ProductSupportDirection, type NodeLevel5ProductSupportFamily, type NodeLevel5ProductSupportFamilyId, type NodeLevel5ProductTargetIdentity, type NodeLevel5ProductUnsupportedNeighbor, type NodeLevel5ProofComposition, type NodeLevel5ProofCompositionInput, type NodeLevel5ProofCompositionRefusal, type NodeLevel5ProofEvidenceCheck, type NodeLevel5ProofIngredient, type NodeLevel5ProofIngredientName, type NodeLevel5ProofRefusalCode, type NodeLevel5ProofRefusalMatrixRow, type NodeLevel5ReadinessGate, type NodeLevel5ReadinessGateStatus, type NodeLevel5ReadinessMatrix, type NodeLevel5RealAppCorpusFramework, type NodeLevel5RealAppCorpusReport, type NodeLevel5RealAppCorpusRow, type NodeLevel5RealAppCorpusVerification, type NodeLevel5RealAppRefusalCorpusReport, type NodeLevel5RealAppRefusalCorpusRow, type NodeLevel5RealAppRefusalCorpusVerification, type NodeLevel5RealAppRefusalMarker, type NodeLevel5RealVmCrossArchEvidence, type NodeLevel5TargetProofEvidence, type NodeLevel5TargetSideProof, type NodeLevel5TargetSideProofInput, type NodeLevel5ThirdPartyAppCorpusReport, type NodeLevel5ThirdPartyAppCorpusRow, type NodeLevel5ThirdPartyAppCorpusVerification, type NodeLevel5ThirdPartyAppSource, type NodeLevel5UnsupportedNeighborGate, type NodeProperLevel5HttpStatePolicyInput, type NodeProperLevel5HttpStatePolicyRefusal, type NodeProperLevel5HttpStatePolicyRefusalCode, type NodeProperLevel5HttpStatePolicyResult, type NodeProperLevel5LibuvTimerCandidate, type NodeProperLevel5LibuvTimerMemoryFragment, type NodeProperLevel5LibuvTimerRecoveryRefusal, type NodeProperLevel5LibuvTimerRecoveryRefusalCode, type NodeProperLevel5LibuvTimerRecoveryResult, type NodeProperLevel5MapKind, type NodeProperLevel5ProcMapEntry, type NodeProperLevel5RawMemoryFragment, type NodeProperLevel5RawV8ContextSmiRecoveryResult, type NodeProperLevel5SourceInspectionInput, type NodeProperLevel5SourceInspectionSummary, type NodeProperLevel5V8ClosureCounterCellCandidate, type NodeProperLevel5V8ClosureRecoveryRefusal, type NodeProperLevel5V8ClosureRecoveryRefusalCode, type NodeProperLevel5V8ClosureRecoveryResult, type NodeProperLevel5V8ObjectCandidate, type NodeProperLevel5V8ObjectMemoryFragment, type NodeProperLevel5V8ObjectRecoveryOptions, type NodeProperLevel5V8ObjectRecoveryRefusal, type NodeProperLevel5V8ObjectRecoveryRefusalCode, type NodeProperLevel5V8ObjectRecoveryResult, OPPOSITE_ISA_VM_EXECUTION_KIND, type OnLog, type OnOutputListener, type OppositeIsaVmExecutionArch, type OppositeIsaVmExecutionEvidence, type OppositeIsaVmExecutionProviderRoute, type OppositeIsaVmExecutionRefusalCode, type OppositeIsaVmExecutionState, type OppositeIsaVmExecutionSummary, PORTABLE_MACHINE_SNAPSHOT_FILES, PORTABLE_MACHINE_SNAPSHOT_FORMAT_VERSION, PORTABLE_SNAPSHOT_GUEST_CHECKPOINT_COMPOSITION_KIND, PRODUCT_CLAIM_PROOF_ONLY_REFUSAL_CODE, PRODUCT_CLAIM_REGISTRY_FORMAT_VERSION, type PackBundleOptions, type PackMinimalOptions, type PackRootfsOptions, type PackTinyBundleOptions, type PackWorkspaceOptions, ParseError, type PhaseLogEvent, type PidStatus, type PortableMachineSnapshotArchitecture, type PortableMachineSnapshotDocuments, type PortableMachineSnapshotManifest, type PortableMachineSnapshotRefusal, type PortableMachineSnapshotRefusalCode, type PortableMachineSnapshotRefusals, PortableMachineSnapshotValidationError, type PortableMachineTargetContinuationKind, type PortableMachineTargetFrameRestoreResult, type PortableMachineTargetNativePlanConsumptionResult, type PortableMachineTargetRegisterRestoreResult, type PortableMachineTargetResourceStatus, type PortableMachineTargetRestoreDescriptorPlan, type PortableMachineTargetRestoreDescriptorRequest, type PortableMachineTargetRestoreObservation, type PortableMachineTargetResumePathResult, type PortableMachineTargetReturnChainResult, type PortableMachineTargetRflagsRestoreResult, type PortableMachineTargetStateConsumptionResult, type PortableMachineTargetThreadRestoreResult, type PortableMachineTargetTlsRestoreResult, type PortableMachineTargetVerifierResult, type PortableMachineVmRestoreProofPlan, type PortableMachineVmRestoreProofRequest, type PortableMachineVmRestoreProofState, type PortableMachineVmRestoreTargetResult, type PortableSnapshotGuestCheckpointCompositionInput, type PortableSnapshotGuestCheckpointCompositionRefusalCode, type PortableSnapshotGuestCheckpointCompositionRow, type PortableSnapshotGuestCheckpointCompositionState, type PortableSnapshotGuestCheckpointCompositionSummary, type PortableSnapshotGuestCheckpointMachinenStateModel, type ProductClaimEntry, type ProductClaimFamily, type ProductClaimObservableStateDecision, type ProductClaimProofProfileInput, type ProductClaimRegistry, type ProductClaimRegistryFilter, type ProductClaimRegistrySummary, type ProductClaimStatus, type ProductSupportLevel, ProvisionError, type ProvisionOptions, type ProvisionResult, type PtyBootOptions, type PtyVmHandle, RUNTIME_CONFIDENCE_PROFILE_KIND, type RegistryEntry, RegistryError, type RestoreNodeLevel5DeclaredSubsetInput, type RestoreOptions, type RssTarget, type RunGcOptions, type RuntimeConfidenceArch, type RuntimeConfidenceClassification, type RuntimeConfidenceProfileInput, type RuntimeConfidenceProfileRow, type RuntimeConfidenceProfileSummary, type RuntimeConfidenceRefusalCode, type RuntimeConfidenceRuntime, type RuntimeConfidenceStateModel, STATEFUL_DATABASE_RESTORE_KIND, STATS_FILE_SIZE, type SandboxEntry, SandboxError, Sandboxes, SecretsError, type SnapshotEngine, SnapshotError, type SnapshotFileIdentity, type SnapshotMeta, type SnapshotOptions, type SnapshotResult, type StatefulDatabaseRestoreArch, type StatefulDatabaseRestoreDatabase, type StatefulDatabaseRestoreInput, type StatefulDatabaseRestoreRefusalCode, type StatefulDatabaseRestoreState, type StatefulDatabaseRestoreStateModel, type StatefulDatabaseRestoreSummary, Supervisor, type SupervisorOptions, TARGET_GUEST_RESTORE_DESCRIPTOR_KIND, type TargetGuestActiveSyscallRestorePlan, type TargetGuestActiveSyscallRestoreStep, type TargetGuestCopyCapturedBytesEntry, type TargetGuestEpollWatchRecipe, type TargetGuestExecutableMappingStep, type TargetGuestExecutableMaterializationPlan, type TargetGuestMemoryMaterializationEntry, type TargetGuestMemoryMaterializationKind, type TargetGuestMemoryMaterializationRequest, type TargetGuestMemoryMaterializationResult, type TargetGuestNativeRestoreStep, type TargetGuestPrivateMemoryRestorePlan, type TargetGuestPrivateMemoryRestoreStep, type TargetGuestProcessContextRestoreMode, type TargetGuestProcessContextRestoreOptions, type TargetGuestProcessContextRestorePlan, type TargetGuestProcessContextRestoreStep, type TargetGuestRecreateGuardEntry, type TargetGuestRestoreContinuationDescriptor, type TargetGuestRestoreDescriptor, type TargetGuestRestoreLoaderRefusalCode, TargetGuestRestoreLoaderValidationError, type TargetGuestRestoreResourceRecipe, type TargetGuestRestoreResumeMode, type TargetGuestResumeRegisterName, type TargetGuestResumeRegisters, type TargetGuestSignalRestorePlan, type TargetGuestSignalRestoreStep, type TargetGuestTranslatedFrameDescriptor, type TargetGuestTranslatedFrameRegister, type TargetGuestTranslatedFrameRegisterName, type TargetGuestTranslatedFrameSlot, type TargetGuestTwoThreadBinding, type TargetGuestTwoThreadRestorePlan, type TargetGuestTwoThreadSpawnStep, type TargetNativeConsumptionEvent, type TargetNativeConsumptionEvents, type TargetNativeConsumptionStatus, type VmHandle, type VmstateBackend, type VmstateSnapshotMeta, VsockExec, type VsockExecOptions, type VsockExecPtyHandle, type VsockExecPtyOptions, type VsockExecPtyResult, type VsockExecResult, VsockFiles, type VsockFilesOptions, VsockSecrets, type VsockSecretsOptions, VsockWinsize, type VsockWinsizeOptions, WinsizeError, type WriteFileOptions, _internal, advancedLinuxFacilityProbeClassifications, advancedLinuxFacilityProbeFacilities, advancedLinuxFacilityProbeRefusalCodes, architecturePortableSnapshotEvidenceCategories, architecturePortableSnapshotGauntletEvidenceStatuses, architecturePortableSnapshotProductSupportStates, architecturePortableSnapshotTargetExecutions, assertNativeProcessImageDocuments, assertNodeLevel5ProductSupport20MatrixComplete, assertNodeLevel5ProductSupport50MatrixComplete, assertNodeLevel5ProductSupport65MatrixComplete, assertNodeLevel5ProductSupport80HardeningComplete, assertNodeLevel5ProductSupport80MatrixComplete, assertNodeLevel5ReadinessMatrixComplete, attach, autoSizeMemoryMib, boot, bootPty, bootSnapshotPath, buildAdvancedLinuxFacilityProbeRow, buildArchitecturePortableSnapshotGauntletRow, buildGuestCheckpointSubstrateRow, buildLevel5ProofOnlyStatus, buildLevel5RefusalEnvelope, buildLevel5RuntimeAdapterRegistrySummary, buildMachinenConfig, buildMoveIssueReport, buildNativeActualResumeTrampolineArgs, buildNativeCodeMap, buildNativeMachineRestoreDescriptor, buildNativeSyntheticPpollSyscallContinuation, buildNativeSyntheticSleepSyscallContinuation, buildNativeSyntheticSyscallContinuationDescriptor, buildNestedVirtualizationStretchProofRow, buildNodeLevel5AppSupportMatrix, buildNodeLevel5HttpProfileCapture, buildNodeLevel5ProofComposition, buildOppositeIsaVmExecutionSummary, buildPortableMachineSnapshotManifestFromNativeProcessImage, buildPortableSnapshotGuestCheckpointCompositionRow, buildProductClaimRegistry, buildRuntimeConfidenceProfileMatrix, buildRuntimeConfidenceProfileRow, buildStatefulDatabaseRestoreSummary, buildTargetGuestRestoreLoaderArgv, buildWriteFileCmd, buildWriteFileCmds, checkForkBackpressure, classifyNativeActiveSyscalls, classifyNativeDebugMemoryPointers, classifyNativeTargetResumeExecutionAttempt, classifyNativeThreadSyscall, classifyNodeProperLevel5HttpStatePolicy, classifyOppositeIsaProviderRoute, completePortableMachineVmRestoreProof, createLevel5RuntimeAdapterRegistry, createMoveDescriptor, createNodeLevel5DeclaredSubsetCapture, createNodeLevel5GenericVmCorpusReport, createNodeLevel5GenericVmRefusalArtifactsReport, createNodeLevel5GenericVmRetainedEvidenceReport, createNodeLevel5GenericVmRowArtifactsReport, createNodeLevel5InstalledThirdPartyAppCorpusReport, createNodeLevel5ProductSnapshot, createNodeLevel5ProductSupport80ArtifactBundle, createNodeLevel5RealAppCorpusReport, createNodeLevel5RealAppRefusalCorpusReport, createNodeLevel5ThirdPartyAppCorpusReport, crossIsaVmstateRestoreRefusal, detachedLogRoot, detectNodeLevel5ProductSnapshotApp, discoverNativeUnwindFrames, ensureMountDiskImage, ensureMountDiskUpper, ensureRootfsImage, evaluateNodeLevel5ProductSupport85ClaimReady, evaluateNodeLevel5ProductSupport85Readiness, filterProductClaimRegistry, formatMachinenError, guestCheckpointSubstrateRefusalCodes, hostArchitectureFromNode, inspectNativeTargetResumeLanding, inventoryNativeActualTargetModules, inventoryNativeSourceCodeModules, isMachinenError, isNativeProcessImageBundle, isNodeLevel5DeclaredSubsetManifest, isNodeLevel5ProductSnapshotBundle, isPortableMachineSnapshotBundle, isSupportedNodeLevel5HttpSelectedState, level5SubstrateRefusalCodes, list, loadMoveDescriptor, loadNodeLevel5GenericVmCorpusReport, loadNodeLevel5GenericVmRefusalArtifactsReport, loadNodeLevel5GenericVmRetainedEvidenceReport, loadNodeLevel5GenericVmRowArtifactsReport, loadNodeLevel5InstalledThirdPartyAppCorpusReport, loadNodeLevel5ProductSupport80ArtifactBundle, loadNodeLevel5ProductSupport85ReadinessReport, loadNodeLevel5RealAppCorpusReport, loadNodeLevel5RealAppRefusalCorpusReport, loadNodeLevel5ThirdPartyAppCorpusReport, markMountDiskImageClean, markRootfsImageClean, matchNativeTargetUnwindFrame, materializeNativeReturnChainFrames, materializeNativeStackWindowWrites, materializeNativeTargetModuleBytes, measureFirstByte, packBundle as mkinitramfsBundle, cli as mkinitramfsCli, packMinimal as mkinitramfsMinimal, packRootfs as mkinitramfsRootfs, packTinyBundle as mkinitramfsTinyBundle, packWorkspace as mkinitramfsWorkspace, modelNativeFdReadState, modelNativeFdWriteState, modelNativePingSocketRecvmsgState, modelNativePpollTimeoutState, modelNativeSleepTimerState, mountdiskImgCacheDir, nativeProcessImageArchitectures, nativeProcessImageRefusalCodes, nativeProcessImageSchemas, nativeSyntheticContinuationBytesHex, nativeSyntheticContinuationBytesSha256, nativeSyntheticContinuationDescriptorSha256, nativeSyntheticEintrErrno, nativeSyntheticExitProcessSuffix, nativeSyntheticRestartLikeErrnos, nativeSyntheticSyscallFailureExitBuckets, nativeSyntheticSyscallRestartContract, nativeTargetResumeLandingRefusals, nativeUnwindReturnAddressSlot, nestedVirtualizationStretchProofClassifications, nestedVirtualizationStretchProofRefusalCodes, nodeLevel5AppCorpusGates, nodeLevel5DeclaredSubsetRefusalCodes, nodeLevel5DeclaredSubsetSupportMatrix, nodeLevel5FinalAuditGates, nodeLevel5HttpProfileRefusalCodes, nodeLevel5HttpProfileRefusalRows, nodeLevel5NarrowProductReadinessGates, nodeLevel5ProductSupport20Families, nodeLevel5ProductSupport20Matrix, nodeLevel5ProductSupport50ExpandedUnsupportedNeighbors, nodeLevel5ProductSupport50Families, nodeLevel5ProductSupport50Matrix, nodeLevel5ProductSupport50NewFamilies, nodeLevel5ProductSupport65ExpandedUnsupportedNeighbors, nodeLevel5ProductSupport65Families, nodeLevel5ProductSupport65Matrix, nodeLevel5ProductSupport65NewFamilies, nodeLevel5ProductSupport80ClaimRegistry, nodeLevel5ProductSupport80ExpandedUnsupportedNeighbors, nodeLevel5ProductSupport80Families, nodeLevel5ProductSupport80Matrix, nodeLevel5ProductSupport80NewFamilies, nodeLevel5ProductSupport80UnsupportedDetectors, nodeLevel5ProductSupport85ClaimRegistry, nodeLevel5ProductUnsupportedNeighbors, nodeLevel5ProofIngredientNames, nodeLevel5ProofRefusalCodes, nodeLevel5ReadinessMatrix, nodeLevel5UnsupportedNeighborGates, normalizeGuestMachine, notProvenNodeLevel5AppSupportRows, oppositeGuestArchitecture, oppositeIsaVmExecutionRefusalCodes, parseNativeEhFrameText, parseNativeMachineRestoreDescriptor, parseNativeTargetEhFrameText, parseNodeProperLevel5ProcMaps, parseTargetGuestRestoreDescriptor, parseTargetNativeConsumptionEvents, planNativeActualRealUtilityContinuationAttempt, planNativeControlledTwoThreadRestoreBoundary, planNativeMachineRestore, planNativeMappingMaterialization, planNativeRealUtilityContinuationAttempt, planNativeReturnChain, planNativeSignalRestorePolicy, planNativeSimdFpuLiveSubsetPolicy, planNativeSimdFpuRestorePolicy, planNativeStackWindowMaterialization, planNativeSyntheticTargetCallerFrame, planNativeTargetFdTable, planNativeTargetFrameStateMaterialization, planNativeTargetResumeExecution, planNativeThreadRestoreBoundary, planNativeTlsSegmentBaseHandoff, planPortableMachineTargetRestoreDescriptor, planPortableMachineVmRestoreProof, planTargetGuestActiveSyscallRestore, planTargetGuestExecutableMaterialization, planTargetGuestMemoryMaterialization, planTargetGuestPrivateMemoryRestore, planTargetGuestProcessContextRestore, planTargetGuestSignalRestore, planTargetGuestTwoThreadRestore, portableMachineSnapshotArchitectures, portableMachineSnapshotManifestSchema, portableMachineSnapshotRefusalCodes, portableSnapshotGuestCheckpointCompositionRefusalCodes, postgresLogicalRestoreInput, probeNestedVirtualization, productClaimEntryFromProofProfile, productClaimFamilies, productClaimRefusalSummary, productClaimStatuses, productSupportLevels, provision, readBalloonStats, readHostFreeBytes, readHostRssBytes, readHostRssBytesMulti, readHostTotalBytes, recoverNodeProperLevel5LibuvTimerEvidence, recoverNodeProperLevel5RawV8ContextSmiCounter, recoverNodeProperLevel5V8ClosureCounterCell, recoverNodeProperLevel5V8ObjectStateEvidence, refusedNodeLevel5AppSupportRows, registryRoot, requiredArchitecturePortableSnapshotClaimIds, resolveBaseDtb, resolveBaseKernel, resolveBaseRootfs, resolveMke2fs, resolveMksquashfs, resolveNativeRealUtilityCodeLocations, resolveVmmBinary, restore, restoreNodeLevel5DeclaredSubset, restoreNodeLevel5ProductSnapshot, rootfsImgCacheDir, runGc, runNodeLevel5TargetSideProof, runtimeConfidenceClassifications, runtimeConfidenceProfileFixtures, runtimeConfidenceRefusalCodes, safeSignalRestoreRefusal, safeSimdFpuRefusal, safeTlsSegmentBaseRefusal, saveMoveDescriptor, scanMovePidGraph, serializeNativeMachineRestoreDescriptor, serializeTargetGuestRestoreDescriptor, sqliteRollbackJournalRestoreInput, sqliteWalCheckpointRestoreInput, stableGauntletDigest, statefulDatabaseRestoreRefusalCodes, summarizeAdvancedLinuxFacilityProbeRows, summarizeArchitecturePortableSnapshotGauntletRows, summarizeGuestCheckpointSubstrateRows, summarizeNestedVirtualizationStretchProofRows, summarizeNodeProperLevel5SourceInspection, summarizePortableSnapshotGuestCheckpointCompositionRows, summarizeProductClaimRegistry, summarizeRuntimeConfidenceProfiles, supportedNodeLevel5AppSupportRows, targetNativeConsumptionFields, targetNativeConsumptionPassed, translateNativeMemory, translateNativeRegisterState, translateNativeResources, translateNativeStack, validateAdvancedLinuxFacilityProbeRows, validateArchitecturePortableSnapshotGauntletInvariants, validateArchitecturePortableSnapshotGauntletRows, validateArchitecturePortableSnapshotGauntletSchema, validateGuestCheckpointSubstrateRows, validateNativeMachineRestoreDescriptor, validateNativeProcessImageBundle, validateNativeProcessImageDocuments, validateNestedVirtualizationStretchProofRows, validatePid, validatePortableMachineSnapshotBundle, validatePortableMachineSnapshotManifest, validatePortableSnapshotGuestCheckpointCompositionRows, validateRuntimeConfidenceProfiles, validateTargetGuestRestoreDescriptor, verifyNodeLevel5GenericVmCorpusReport, verifyNodeLevel5GenericVmRefusalArtifactsReport, verifyNodeLevel5GenericVmRetainedEvidenceReport, verifyNodeLevel5GenericVmRowArtifactsReport, verifyNodeLevel5InstalledThirdPartyAppCorpusReport, verifyNodeLevel5ProductSupport80ArtifactBundle, verifyNodeLevel5RealAppCorpusReport, verifyNodeLevel5RealAppRefusalCorpusReport, verifyNodeLevel5ThirdPartyAppCorpusReport, warmImageConfigCache, writeBootSnapshot, writeNodeLevel5GenericVmCorpusReport, writeNodeLevel5GenericVmRefusalArtifactsReport, writeNodeLevel5GenericVmRetainedEvidenceReport, writeNodeLevel5GenericVmRowArtifactsReport, writeNodeLevel5InstalledThirdPartyAppCorpusReport, writeNodeLevel5RealAppCorpusReport, writeNodeLevel5RealAppRefusalCorpusReport, writeNodeLevel5ThirdPartyAppCorpusReport };