@timurproko/a1 0.2.7-dev.1249 → 0.2.7-dev.1252

package/dist/foundation/launch-guardian/exit-watcher.d.ts

@@ -1,14 +0,0 @@
-import { type ProcessGuardianAddon } from "../process-containment/index.js";
-interface ExitWatcherOptions {
-    readonly guardianPid: number;
-    readonly noticePath: string;
-    readonly encodedModes: string;
-    readonly addonPath: string;
-    readonly runtimePid: number;
-    readonly processGroup: number | null;
-    readonly foregroundGroup: number | null;
-}
-/** Waits outside launch containment, then performs the cleanup its dead guardian could not. */
-export declare function runExitWatcher(arguments_: readonly string[], platform?: NodeJS.Platform, loadAddon?: (path: string) => ProcessGuardianAddon): Promise<number>;
-export declare function exitWatcherArguments(options: ExitWatcherOptions): string[];
-export {};

package/dist/foundation/launch-guardian/exit-watcher.js

@@ -1,103 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { resolve } from "node:path";
-import { loadProcessGuardianAddon } from "../process-containment/index.js";
-/** Waits outside launch containment, then performs the cleanup its dead guardian could not. */
-export async function runExitWatcher(arguments_, platform = process.platform, loadAddon = loadProcessGuardianAddon) {
-    const options = parseArguments(arguments_);
-    const addon = loadAddon(options.addonPath);
-    if (platform === "win32")
-        addon.ignoreConsoleControl();
-    else {
-        process.on("SIGINT", ignoreSignal);
-        process.on("SIGTTOU", ignoreSignal);
-    }
-    try {
-        await addon.waitForProcessExit(options.guardianPid);
-        let cleanupFailure = null;
-        try {
-            if (platform === "win32") {
-                // Rationale: job termination is asynchronous; keep the runtime's final frame ahead of the notice.
-                await Promise.race([
-                    addon.waitForProcessExit(options.runtimePid),
-                    delay(2_000),
-                ]);
-            }
-            else if (options.processGroup !== null) {
-                addon.stopProcessGroup(options.processGroup);
-                if (options.foregroundGroup !== null)
-                    addon.restoreForegroundGroup(options.foregroundGroup);
-            }
-        }
-        catch (error) {
-            cleanupFailure = error;
-        }
-        // Invariant: an armed notice, such as the running-Agent reminder, survives a failed cleanup.
-        addon.deliverExitNotice(options.noticePath, options.encodedModes);
-        if (cleanupFailure !== null)
-            throw cleanupFailure;
-        return 0;
-    }
-    finally {
-        if (platform !== "win32") {
-            process.off("SIGINT", ignoreSignal);
-            process.off("SIGTTOU", ignoreSignal);
-        }
-    }
-}
-export function exitWatcherArguments(options) {
-    return [
-        "--guardian-pid", String(options.guardianPid),
-        "--notice", options.noticePath,
-        "--modes", options.encodedModes,
-        "--addon", options.addonPath,
-        "--runtime-pid", String(options.runtimePid),
-        ...(options.processGroup === null ? [] : ["--process-group", String(options.processGroup)]),
-        ...(options.foregroundGroup === null ? [] : ["--foreground-group", String(options.foregroundGroup)]),
-    ];
-}
-function parseArguments(arguments_) {
-    const values = new Map();
-    for (let index = 0; index < arguments_.length; index += 2) {
-        const name = arguments_[index];
-        const value = arguments_[index + 1];
-        if (!name?.startsWith("--") || value === undefined || values.has(name))
-            throw new TypeError("exit watcher arguments are malformed");
-        values.set(name, value);
-    }
-    const guardianPid = positiveInteger(values.get("--guardian-pid"), "guardian PID");
-    const runtimePid = positiveInteger(values.get("--runtime-pid"), "runtime PID");
-    const noticePath = boundedValue(values.get("--notice"), "notice path");
-    const encodedModes = boundedValue(values.get("--modes"), "terminal modes", 32_768);
-    const addonPath = boundedValue(values.get("--addon"), "addon path");
-    const processGroup = optionalPositiveInteger(values.get("--process-group"), "process group");
-    const foregroundGroup = optionalPositiveInteger(values.get("--foreground-group"), "foreground group");
-    const expected = 5 + (processGroup === null ? 0 : 1) + (foregroundGroup === null ? 0 : 1);
-    if (values.size !== expected)
-        throw new TypeError("exit watcher received an unknown argument");
-    return { guardianPid, noticePath, encodedModes, addonPath, runtimePid, processGroup, foregroundGroup };
-}
-function positiveInteger(value, name) {
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed) || parsed <= 0)
-        throw new TypeError(`exit watcher ${name} must be a positive safe integer`);
-    return parsed;
-}
-function optionalPositiveInteger(value, name) {
-    return value === undefined ? null : positiveInteger(value, name);
-}
-function boundedValue(value, name, limit = 4_096) {
-    if (!value || value.length > limit || value.includes("\0"))
-        throw new TypeError(`exit watcher ${name} is invalid`);
-    return value;
-}
-function delay(milliseconds) {
-    return new Promise(resolvePromise => setTimeout(resolvePromise, milliseconds));
-}
-function ignoreSignal() { }
-const invokedPath = process.argv[1] ? resolve(process.argv[1]) : null;
-if (invokedPath === fileURLToPath(import.meta.url)) {
-    void runExitWatcher(process.argv.slice(2)).then(code => process.exit(code), error => {
-        process.stderr.write(`a1 exit watcher: ${error instanceof Error ? error.message : String(error)}\n`);
-        process.exit(2);
-    });
-}

package/dist/foundation/launch-guardian/index.d.ts

@@ -1,2 +0,0 @@
-export { runLaunchGuardian } from "./main.js";
-export type { LaunchGuardianOptions } from "./main.js";

package/dist/foundation/launch-guardian/index.js

@@ -1 +0,0 @@
-export { runLaunchGuardian } from "./main.js";

package/dist/foundation/launch-guardian/main.d.ts

@@ -1,39 +0,0 @@
-import type { LaunchInstanceStopIntent, LaunchProfileId, SupervisorCommand } from "../lifecycle/index.js";
-import { type SessionSelection } from "../lifecycle/index.js";
-import { type NativeProcessInspector, type ProcessContainment, type ProcessGuardianAddon } from "../process-containment/index.js";
-interface GuardianControl {
-    connect(endpoint: string, timeoutMs?: number): Promise<unknown>;
-    command(command: SupervisorCommand): Promise<{
-        readonly ok: boolean;
-        readonly error?: {
-            readonly code: string;
-            readonly message: string;
-        };
-    }>;
-    on(event: "stopIntent", listener: (intent: LaunchInstanceStopIntent) => void): unknown;
-    on(event: "disconnect", listener: () => void): unknown;
-    off(event: "stopIntent", listener: (intent: LaunchInstanceStopIntent) => void): unknown;
-    off(event: "disconnect", listener: () => void): unknown;
-    close(): void;
-}
-export interface LaunchGuardianRootCommand {
-    readonly executable: string;
-    readonly arguments: readonly string[];
-}
-export interface LaunchGuardianOptions {
-    readonly profileId: LaunchProfileId;
-    readonly releaseRoot: string;
-    readonly uiEntry: string;
-    readonly sessionSelection?: SessionSelection;
-    readonly rootCommand?: LaunchGuardianRootCommand;
-    readonly environment?: NodeJS.ProcessEnv;
-    readonly cwd?: string;
-    readonly helperPath?: string;
-    readonly inspector?: NativeProcessInspector;
-    readonly control?: GuardianControl;
-    readonly containment?: ProcessContainment;
-    readonly addon?: ProcessGuardianAddon;
-    readonly ensureHelper?: (path: string) => Promise<void>;
-}
-export declare function runLaunchGuardian(options: LaunchGuardianOptions): Promise<number>;
-export {};

package/dist/foundation/launch-guardian/main.js

@@ -1,232 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
-import { PRODUCT_TEXT } from "../../product-identity.js";
-import { readLaunchContext } from "../launch-context/index.js";
-import { resolve } from "node:path";
-import { assertLaunchProfileId, resolveCohortEndpoint, resolveProductPaths, sessionSelectionArguments } from "../lifecycle/index.js";
-import { AddonContainment, AddonProcessInspector, closeVerifiedContainment, LinuxNativeProcessInspector, loadProcessGuardianAddon, resolveProcessGuardianPath, verifyProcessGuardianArtifact, } from "../process-containment/index.js";
-import { SupervisorClient } from "../protocol/index.js";
-import { markStartupPhase } from "../startup/index.js";
-import { exitWatcherArguments } from "./exit-watcher.js";
-export async function runLaunchGuardian(options) {
-    assertLaunchProfileId(options.profileId);
-    const sessionArgs = sessionSelectionArguments(options.sessionSelection);
-    if (sessionArgs.length > 0 && options.profileId !== "a1")
-        throw new Error("session selection requires the normal A1 profile");
-    const environment = { ...(options.environment ?? process.env) };
-    const paths = resolveProductPaths(environment);
-    const instanceId = randomUUID();
-    const helperPath = options.helperPath ?? resolveProcessGuardianPath(options.releaseRoot, environment);
-    await (options.ensureHelper ?? verifyProcessGuardianArtifact)(helperPath);
-    // Rationale: tests that inject both process boundaries need no native module; every production
-    // path loads the exact artifact only after its manifest and digest have been verified.
-    const addon = options.addon ?? (options.containment && options.inspector ? null : loadProcessGuardianAddon(helperPath));
-    const inspector = options.inspector ?? platformInspector(requireAddon(addon));
-    const guardianIdentity = await inspector.observe(process.pid);
-    if (!guardianIdentity)
-        throw diagnosticError("launch guardian cannot verify its own native process identity", "PROCESS_IDENTITY_UNAVAILABLE");
-    const context = readLaunchContext(environment);
-    const client = options.control ?? new SupervisorClient(context.releaseId);
-    // Invariant: an instance belongs to the cohort that launched it and talks to that cohort's endpoint
-    // for its whole life, whatever release becomes the active one meanwhile.
-    const releaseId = context.releaseId;
-    const endpoint = releaseId
-        ? resolveCohortEndpoint(paths, releaseId, environment).endpoint
-        : paths.endpoint;
-    await client.connect(endpoint);
-    await markStartupPhase(environment, "guardian-connected");
-    const exitNoticePath = resolve(paths.runtimeDir, "launch-instances", `${instanceId}.exit-notice`);
-    const containment = options.containment ?? new AddonContainment(instanceId, helperPath, exitNoticePath, requireAddon(addon));
-    const stop = stopRequests(client, instanceId);
-    let rootIdentity = null;
-    try {
-        await requireAccepted(client, {
-            type: "create-launch-instance",
-            requestId: randomUUID(),
-            instanceId,
-            profileId: options.profileId,
-            shutdownPolicy: "terminate-tree-on-close",
-            guardianIdentity,
-        });
-        let handle;
-        let encodedModes = null;
-        try {
-            const rootCommand = options.rootCommand ?? { executable: process.execPath, arguments: [options.uiEntry, ...sessionArgs] };
-            encodedModes = addon?.captureTerminalModes() ?? null;
-            handle = await containment.spawn(rootCommand.executable, [...rootCommand.arguments], {
-                cwd: options.cwd ?? process.cwd(),
-                environment: environmentEntries(environment),
-                ...(environment.TERM ? { terminalType: environment.TERM } : {}),
-            });
-            rootIdentity = handle.identity;
-            if (addon && encodedModes !== null) {
-                await startExitWatcher(addon, {
-                    addonPath: helperPath,
-                    noticePath: exitNoticePath,
-                    encodedModes,
-                    runtimePid: handle.identity.pid,
-                    processGroup: handle.processGroup ?? null,
-                    foregroundGroup: handle.foregroundGroup ?? null,
-                });
-            }
-            await requireAccepted(client, {
-                type: "activate-launch-instance",
-                requestId: randomUUID(),
-                instanceId,
-                rootIdentity,
-                containmentIdentity: containment.identity,
-            });
-        }
-        catch (error) {
-            const outcome = failureOutcome(error, "guardian-error");
-            await completeBestEffort(client, instanceId, "completed", outcome);
-            throw error;
-        }
-        const outcome = await Promise.race([
-            handle.outcome,
-            stop.requested.then(async (reason) => {
-                if (reason !== "supervisor-disconnect") {
-                    await requireAccepted(client, {
-                        type: "begin-launch-instance-stop",
-                        requestId: randomUUID(),
-                        instanceId,
-                        reason,
-                    });
-                }
-                if (!rootIdentity)
-                    return failureOutcome(new Error("launch root identity is unavailable"), "cleanup-error");
-                const result = await closeVerifiedContainment(containment, inspector, rootIdentity, reason);
-                await containment.close();
-                if (reason === "supervisor-disconnect" && result.outcome.kind === "stopped") {
-                    return {
-                        kind: "interrupted",
-                        reason,
-                        message: "supervisor disconnected after local launch-instance containment closed",
-                    };
-                }
-                return result.outcome;
-            }),
-        ]);
-        // Invariant: the root removes a clean notice. If it left the notice armed, the guardian claims,
-        // restores, and prints it before closing the native containment handle.
-        if (addon && encodedModes !== null)
-            addon.deliverExitNotice(exitNoticePath, encodedModes);
-        await containment.close();
-        if (outcome.kind !== "interrupted" || outcome.reason !== "supervisor-disconnect") {
-            await completeBestEffort(client, instanceId, outcome.kind === "interrupted" || outcome.kind === "cleanup-error" ? "interrupted" : "completed", outcome);
-        }
-        return exitCode(outcome);
-    }
-    catch (error) {
-        await containment.close().catch(() => undefined);
-        throw error;
-    }
-    finally {
-        stop.dispose();
-        client.close();
-    }
-}
-async function startExitWatcher(addon, options) {
-    const entry = fileURLToPath(new URL("./exit-watcher.js", import.meta.url));
-    const arguments_ = [entry, ...exitWatcherArguments({
-            guardianPid: process.pid,
-            ...options,
-        })];
-    if (process.platform === "win32") {
-        addon.spawnWatcher({ executable: process.execPath, arguments: arguments_ });
-        return;
-    }
-    await new Promise((resolvePromise, rejectPromise) => {
-        const watcher = spawn(process.execPath, arguments_, {
-            stdio: "inherit",
-            detached: false,
-            windowsHide: false,
-        });
-        watcher.once("error", rejectPromise);
-        watcher.once("spawn", () => {
-            watcher.off("error", rejectPromise);
-            watcher.unref();
-            resolvePromise();
-        });
-    });
-}
-function platformInspector(addon) {
-    if (process.platform === "win32")
-        return new AddonProcessInspector(addon, "windows-filetime:");
-    if (process.platform === "linux")
-        return new LinuxNativeProcessInspector();
-    if (process.platform === "darwin")
-        return new AddonProcessInspector(addon, "darwin-proc-start:");
-    throw diagnosticError(`launch-instance process containment is unsupported on ${process.platform}`, "CONTAINMENT_UNSUPPORTED");
-}
-function requireAddon(addon) {
-    if (!addon)
-        throw diagnosticError("process guardian addon is unavailable", "CONTAINMENT_ARTIFACT_MISSING");
-    return addon;
-}
-function stopRequests(client, instanceId) {
-    let resolveStop;
-    let settled = false;
-    const requested = new Promise(resolvePromise => { resolveStop = resolvePromise; });
-    const request = (reason) => {
-        if (settled)
-            return;
-        settled = true;
-        resolveStop(reason);
-    };
-    const onStopIntent = (intent) => {
-        if (intent.instanceId === instanceId)
-            request(intent.reason);
-    };
-    const onDisconnect = () => request("supervisor-disconnect");
-    const onSigterm = () => request("user-request");
-    const onSigint = () => undefined;
-    client.on("stopIntent", onStopIntent);
-    client.on("disconnect", onDisconnect);
-    process.once("SIGTERM", onSigterm);
-    process.on("SIGINT", onSigint);
-    return {
-        requested,
-        dispose() {
-            client.off("stopIntent", onStopIntent);
-            client.off("disconnect", onDisconnect);
-            process.off("SIGTERM", onSigterm);
-            process.off("SIGINT", onSigint);
-        },
-    };
-}
-async function requireAccepted(client, command) {
-    const result = await client.command(command);
-    if (!result.ok)
-        throw diagnosticError(result.error?.message ?? `supervisor rejected ${command.type}`, result.error?.code ?? "SUPERVISOR_REJECTED");
-}
-async function completeBestEffort(client, instanceId, terminalState, outcome) {
-    await requireAccepted(client, {
-        type: "complete-launch-instance",
-        requestId: randomUUID(),
-        instanceId,
-        terminalState,
-        outcome,
-    }).catch(() => undefined);
-}
-function environmentEntries(environment) {
-    return Object.fromEntries(Object.entries(environment).filter((entry) => entry[1] !== undefined));
-}
-function failureOutcome(error, kind) {
-    return {
-        kind,
-        message: error instanceof Error ? error.message : String(error),
-        code: error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : null,
-    };
-}
-function exitCode(outcome) {
-    if (outcome.kind === "exited")
-        return outcome.exitCode;
-    if (outcome.kind === "stopped")
-        return 0;
-    return 1;
-}
-function diagnosticError(message, code) {
-    return Object.assign(new Error(`${PRODUCT_TEXT.displayName}: ${message}`), { code });
-}

package/dist/foundation/lifecycle/commands.d.ts

@@ -1,40 +0,0 @@
-import type { LaunchInstanceId, LaunchInstanceOutcome, LaunchInstanceShutdownPolicy, LaunchInstanceStopReason, ProcessContainmentIdentity } from "./launch-instance.js";
-import type { LaunchProfileId, NativeProcessIdentity, RequestId } from "./model.js";
-export type SupervisorCommand = {
-    readonly type: "create-launch-instance";
-    readonly requestId: RequestId;
-    readonly instanceId: LaunchInstanceId;
-    readonly profileId: LaunchProfileId;
-    readonly shutdownPolicy: LaunchInstanceShutdownPolicy;
-    readonly guardianIdentity: NativeProcessIdentity;
-} | {
-    readonly type: "activate-launch-instance";
-    readonly requestId: RequestId;
-    readonly instanceId: LaunchInstanceId;
-    readonly rootIdentity: NativeProcessIdentity;
-    readonly containmentIdentity: ProcessContainmentIdentity;
-} | {
-    readonly type: "begin-launch-instance-stop";
-    readonly requestId: RequestId;
-    readonly instanceId: LaunchInstanceId;
-    readonly reason: LaunchInstanceStopReason;
-} | {
-    readonly type: "complete-launch-instance";
-    readonly requestId: RequestId;
-    readonly instanceId: LaunchInstanceId;
-    readonly terminalState: "completed" | "interrupted";
-    readonly outcome: LaunchInstanceOutcome;
-} | {
-    readonly type: "reconcile-launch-instance";
-    readonly requestId: RequestId;
-    readonly instanceId: LaunchInstanceId;
-} | {
-    readonly type: "resynchronize";
-    readonly requestId: RequestId;
-};
-export interface LaunchInstanceStopIntent {
-    readonly type: "stop-launch-instance";
-    readonly requestId: RequestId;
-    readonly instanceId: LaunchInstanceId;
-    readonly reason: LaunchInstanceStopReason;
-}

package/dist/foundation/lifecycle/commands.js

@@ -1 +0,0 @@
-export {};

package/dist/foundation/lifecycle/launch-instance.d.ts

@@ -1,46 +0,0 @@
-import type { LaunchProfileId, NativeProcessIdentity } from "./model.js";
-export type LaunchInstanceId = string;
-export type LaunchInstanceState = "requested" | "active" | "stopping" | "completed" | "interrupted";
-export type LaunchInstanceShutdownPolicy = "terminate-tree-on-close";
-export type LaunchInstanceStopReason = "owner-disconnect" | "supervisor-disconnect" | "user-request" | "update";
-export interface ProcessContainmentIdentity {
-    readonly provider: string;
-    readonly token: string;
-}
-export type LaunchInstanceOutcome = {
-    readonly kind: "exited";
-    readonly exitCode: number;
-} | {
-    readonly kind: "signaled";
-    readonly signal: string;
-} | {
-    readonly kind: "stopped";
-    readonly reason: LaunchInstanceStopReason;
-} | {
-    readonly kind: "spawn-error" | "guardian-error" | "cleanup-error";
-    readonly message: string;
-    readonly code: string | null;
-} | {
-    readonly kind: "interrupted";
-    readonly reason: "owner-disconnect" | "supervisor-disconnect" | "guardian-exit" | "legacy-migration";
-    readonly message: string;
-};
-export interface LaunchInstance {
-    readonly id: LaunchInstanceId;
-    readonly ownerClientId: string;
-    readonly profileId: LaunchProfileId;
-    readonly state: LaunchInstanceState;
-    readonly shutdownPolicy: LaunchInstanceShutdownPolicy;
-    readonly guardianIdentity: NativeProcessIdentity;
-    readonly rootIdentity: NativeProcessIdentity | null;
-    readonly containmentIdentity: ProcessContainmentIdentity | null;
-    readonly createdAt: string;
-    readonly activatedAt: string | null;
-    readonly stoppingAt: string | null;
-    readonly completedAt: string | null;
-    readonly outcome: LaunchInstanceOutcome | null;
-}
-export declare function assertLaunchInstance(instance: LaunchInstance): void;
-export declare function assertLaunchInstanceTransition(previous: LaunchInstance, next: LaunchInstance): void;
-export declare function assertProcessContainmentIdentity(identity: ProcessContainmentIdentity): void;
-export declare function assertLaunchInstanceOutcome(outcome: LaunchInstanceOutcome): void;

package/dist/foundation/lifecycle/launch-instance.js

@@ -1,134 +0,0 @@
-import { assertLaunchProfileId, assertNativeProcessIdentity } from "./model.js";
-const ALLOWED_TRANSITIONS = {
-    requested: ["active", "completed", "interrupted"],
-    active: ["stopping", "completed", "interrupted"],
-    stopping: ["completed", "interrupted"],
-    completed: [],
-    interrupted: [],
-};
-export function assertLaunchInstance(instance) {
-    assertIdentifier(instance.id, "launch instance identity");
-    assertIdentifier(instance.ownerClientId, "launch instance owner identity");
-    assertLaunchProfileId(instance.profileId);
-    if (!(instance.state in ALLOWED_TRANSITIONS))
-        throw new TypeError(`invalid launch instance state: ${String(instance.state)}`);
-    if (instance.shutdownPolicy !== "terminate-tree-on-close")
-        throw new TypeError("launch instance shutdown policy must terminate its process tree on close");
-    assertNativeProcessIdentity(instance.guardianIdentity);
-    if (instance.rootIdentity !== null)
-        assertNativeProcessIdentity(instance.rootIdentity);
-    if (instance.containmentIdentity !== null)
-        assertProcessContainmentIdentity(instance.containmentIdentity);
-    assertTimestamp(instance.createdAt, "launch instance creation time");
-    assertOptionalTimestamp(instance.activatedAt, "launch instance activation time");
-    assertOptionalTimestamp(instance.stoppingAt, "launch instance stopping time");
-    assertOptionalTimestamp(instance.completedAt, "launch instance completion time");
-    if (instance.outcome !== null)
-        assertLaunchInstanceOutcome(instance.outcome);
-    if (instance.state === "requested") {
-        if (instance.rootIdentity !== null || instance.containmentIdentity !== null || instance.activatedAt !== null) {
-            throw new TypeError("requested launch instance cannot have active runtime ownership");
-        }
-        if (instance.stoppingAt !== null || instance.completedAt !== null || instance.outcome !== null) {
-            throw new TypeError("requested launch instance cannot have stopping or terminal state");
-        }
-        return;
-    }
-    if (instance.state === "active" || instance.state === "stopping") {
-        if (instance.rootIdentity === null || instance.containmentIdentity === null || instance.activatedAt === null) {
-            throw new TypeError(`${instance.state} launch instance requires root and containment ownership`);
-        }
-        if (instance.completedAt !== null || instance.outcome !== null)
-            throw new TypeError(`${instance.state} launch instance cannot have a terminal outcome`);
-        if (instance.state === "active" && instance.stoppingAt !== null)
-            throw new TypeError("active launch instance cannot have a stopping time");
-        if (instance.state === "stopping" && instance.stoppingAt === null)
-            throw new TypeError("stopping launch instance requires a stopping time");
-        return;
-    }
-    if (instance.completedAt === null || instance.outcome === null)
-        throw new TypeError("terminal launch instance requires completion time and outcome");
-    if (instance.state === "completed" && instance.outcome.kind === "interrupted")
-        throw new TypeError("completed launch instance cannot carry an interrupted outcome");
-    if (instance.state === "interrupted" && instance.outcome.kind !== "interrupted" && instance.outcome.kind !== "cleanup-error") {
-        throw new TypeError("interrupted launch instance requires an interrupted or cleanup-error outcome");
-    }
-}
-export function assertLaunchInstanceTransition(previous, next) {
-    assertLaunchInstance(previous);
-    assertLaunchInstance(next);
-    if (previous.id !== next.id || previous.ownerClientId !== next.ownerClientId || previous.profileId !== next.profileId) {
-        throw new TypeError("launch instance identity and ownership are immutable");
-    }
-    if (previous.shutdownPolicy !== next.shutdownPolicy
-        || !sameProcessIdentity(previous.guardianIdentity, next.guardianIdentity)
-        || previous.createdAt !== next.createdAt) {
-        throw new TypeError("launch instance guardian, policy, and creation identity are immutable");
-    }
-    const allowedTransitions = ALLOWED_TRANSITIONS[previous.state];
-    if (!allowedTransitions.includes(next.state)) {
-        throw new TypeError(`invalid launch instance transition: ${previous.state} -> ${next.state}`);
-    }
-    if (previous.rootIdentity !== null && !sameProcessIdentity(previous.rootIdentity, next.rootIdentity)) {
-        throw new TypeError("launch instance root identity is immutable after activation");
-    }
-    if (previous.containmentIdentity !== null && !sameContainmentIdentity(previous.containmentIdentity, next.containmentIdentity)) {
-        throw new TypeError("launch instance containment identity is immutable after activation");
-    }
-}
-export function assertProcessContainmentIdentity(identity) {
-    assertIdentifier(identity.provider, "process containment provider");
-    assertIdentifier(identity.token, "process containment token");
-}
-export function assertLaunchInstanceOutcome(outcome) {
-    if (outcome.kind === "exited") {
-        if (!Number.isSafeInteger(outcome.exitCode))
-            throw new TypeError("launch instance exit code must be a safe integer");
-        return;
-    }
-    if (outcome.kind === "signaled") {
-        assertIdentifier(outcome.signal, "launch instance signal");
-        return;
-    }
-    if (outcome.kind === "stopped") {
-        if (!["owner-disconnect", "supervisor-disconnect", "user-request", "update"].includes(outcome.reason)) {
-            throw new TypeError("invalid launch instance stop reason");
-        }
-        return;
-    }
-    if (outcome.kind === "interrupted") {
-        if (!["owner-disconnect", "supervisor-disconnect", "guardian-exit", "legacy-migration"].includes(outcome.reason)) {
-            throw new TypeError("invalid launch instance interruption reason");
-        }
-        assertDiagnostic(outcome.message, "launch instance interruption message");
-        return;
-    }
-    if (outcome.kind !== "spawn-error" && outcome.kind !== "guardian-error" && outcome.kind !== "cleanup-error") {
-        throw new TypeError(`invalid launch instance outcome: ${String(outcome.kind)}`);
-    }
-    assertDiagnostic(outcome.message, "launch instance failure message");
-    if (outcome.code !== null)
-        assertIdentifier(outcome.code, "launch instance failure code");
-}
-function sameProcessIdentity(left, right) {
-    return right !== null && left.pid === right.pid && left.startIdentity === right.startIdentity;
-}
-function sameContainmentIdentity(left, right) {
-    return right !== null && left.provider === right.provider && left.token === right.token;
-}
-function assertIdentifier(value, name) {
-    if (!value || value.length > 512 || value.includes("\0"))
-        throw new TypeError(`${name} must be non-empty, bounded, and contain no null byte`);
-}
-function assertDiagnostic(value, name) {
-    if (!value || value.length > 4_096 || value.includes("\0"))
-        throw new TypeError(`${name} must be non-empty, bounded, and contain no null byte`);
-}
-function assertTimestamp(value, name) {
-    if (!value || !Number.isFinite(Date.parse(value)))
-        throw new TypeError(`${name} must be a valid timestamp`);
-}
-function assertOptionalTimestamp(value, name) {
-    if (value !== null)
-        assertTimestamp(value, name);
-}

package/dist/foundation/lifecycle/native-claim-gate.d.ts

@@ -1,5 +0,0 @@
-export interface ClaimGateHandle {
-    release(): void;
-}
-/** No PID-file fallback: only the platform descriptor can prove upgraded-writer exclusion. */
-export declare function tryAcquireClaimGate(path: string): ClaimGateHandle | null;