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

package/dist/features/resident-tab/shortcut-bindings-file.d.ts

@@ -1,8 +0,0 @@
-import type { ShortcutBindings } from "./shortcut-projection.js";
-/** Largest `keybindings.json` the projection reads; a larger file counts as absent. */
-export declare const MAX_SHORTCUT_BINDINGS_BYTES: number;
-/**
- * Reads the user's `keybindings.json` as shortcut bindings, keeping `null` entries so an
- * explicit unbind survives, and treating any unreadable or malformed file as empty.
- */
-export declare function readShortcutBindingsFile(agentDir: string): ShortcutBindings;

package/dist/features/resident-tab/shortcut-bindings-file.js

@@ -1,40 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-/** Largest `keybindings.json` the projection reads; a larger file counts as absent. */
-export const MAX_SHORTCUT_BINDINGS_BYTES = 256 * 1024;
-/**
- * Reads the user's `keybindings.json` as shortcut bindings, keeping `null` entries so an
- * explicit unbind survives, and treating any unreadable or malformed file as empty.
- */
-export function readShortcutBindingsFile(agentDir) {
-    let text;
-    try {
-        text = readFileSync(join(agentDir, "keybindings.json"), "utf8");
-    }
-    catch {
-        return {};
-    }
-    if (text.length > MAX_SHORTCUT_BINDINGS_BYTES)
-        return {};
-    let parsed;
-    try {
-        parsed = JSON.parse(text.replace(/^/u, ""));
-    }
-    catch {
-        return {};
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-        return {};
-    const bindings = {};
-    for (const [action, value] of Object.entries(parsed)) {
-        if (action === "$schema")
-            continue;
-        if (value === null || typeof value === "string") {
-            bindings[action] = value;
-            continue;
-        }
-        if (Array.isArray(value))
-            bindings[action] = value.filter((key) => typeof key === "string");
-    }
-    return bindings;
-}

package/dist/features/resident-tab/shortcut-declarations.d.ts

@@ -1,13 +0,0 @@
-export type ResidentTabAction = "tabs.new" | "tabs.close" | "tabs.rename" | "tabs.settings" | "tabs.changelog" | "tabs.commands" | "tabs.retry" | "tabs.fresh" | "tabs.next" | "tabs.previous" | "tabs.moveRight" | "tabs.moveLeft" | `tabs.jump${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}`;
-export interface ResidentTabShortcut {
-    readonly id: ResidentTabAction;
-    readonly defaultKey: string | null;
-    readonly scope: "global" | "failed-banner";
-    readonly description: string;
-}
-/**
- * The tab shortcut declarations, in the order that decides which action keeps a duplicated key.
- * This module stays dependency-free so startup presentation and the resident projection can
- * read it without loading the component registry.
- */
-export declare const RESIDENT_TAB_SHORTCUTS: readonly ResidentTabShortcut[];

package/dist/features/resident-tab/shortcut-declarations.js

@@ -1,26 +0,0 @@
-const jumps = Array.from({ length: 10 }, (_, index) => ({
-    id: `tabs.jump${index + 1}`,
-    defaultKey: `alt+${(index + 1) % 10}`,
-    scope: "global",
-    description: `View A1 tab ${index + 1}`,
-}));
-/**
- * The tab shortcut declarations, in the order that decides which action keeps a duplicated key.
- * This module stays dependency-free so startup presentation and the resident projection can
- * read it without loading the component registry.
- */
-export const RESIDENT_TAB_SHORTCUTS = Object.freeze([
-    { id: "tabs.new", defaultKey: "alt+a", scope: "global", description: "New A1 tab" },
-    { id: "tabs.close", defaultKey: "alt+w", scope: "global", description: "Close A1 tab" },
-    { id: "tabs.rename", defaultKey: "f2", scope: "global", description: "Rename A1 tab" },
-    { id: "tabs.settings", defaultKey: "alt+,", scope: "global", description: "Open Settings tab" },
-    { id: "tabs.changelog", defaultKey: null, scope: "global", description: "Open Changelog tab" },
-    { id: "tabs.commands", defaultKey: "alt+/", scope: "global", description: "Open command palette" },
-    ...jumps,
-    { id: "tabs.next", defaultKey: null, scope: "global", description: "View next A1 tab" },
-    { id: "tabs.previous", defaultKey: null, scope: "global", description: "View previous A1 tab" },
-    { id: "tabs.moveRight", defaultKey: null, scope: "global", description: "Move A1 tab right" },
-    { id: "tabs.moveLeft", defaultKey: null, scope: "global", description: "Move A1 tab left" },
-    { id: "tabs.retry", defaultKey: "r", scope: "failed-banner", description: "Retry failed A1 tab" },
-    { id: "tabs.fresh", defaultKey: "f", scope: "failed-banner", description: "Start failed A1 tab fresh" },
-]);

package/dist/features/resident-tab/shortcut-projection.d.ts

@@ -1,29 +0,0 @@
-import { type ResidentTabAction } from "./shortcut-declarations.js";
-/** Key assignments as `keybindings.json` and the keybinding manager express them. */
-export type ShortcutBindings = Readonly<Record<string, string | readonly string[] | null | undefined>>;
-export type ResidentTabGlobalAction = Exclude<ResidentTabAction, "tabs.retry" | "tabs.fresh">;
-export interface ResidentTabShortcutConflict {
-    readonly id: ResidentTabGlobalAction;
-    readonly key: string;
-    /** `reserved` keys belong to an A1 action; `duplicate` keys were claimed by an earlier tab action. */
-    readonly reason: "reserved" | "duplicate";
-}
-/** The effective tab shortcuts the resident shell dispatches and every presentation shows. */
-export interface ResidentTabShortcutProjection {
-    readonly assignments: Readonly<Record<ResidentTabGlobalAction, string | null>>;
-    readonly conflicts: readonly ResidentTabShortcutConflict[];
-}
-export interface ResidentTabShortcutInput {
-    /** The user's `keybindings.json`, including any `tabs.*` entries; `null` unbinds an action. */
-    readonly configured?: ShortcutBindings | undefined;
-    /** The effective A1 declarations (defaults plus customization) whose keys tab actions may not take. */
-    readonly reserved?: ShortcutBindings | undefined;
-}
-/** The declarations the projection covers, in the order that decides duplicate claims. */
-export declare const RESIDENT_TAB_GLOBAL_SHORTCUTS: import("./shortcut-declarations.js").ResidentTabShortcut[];
-/**
- * Projects the effective A1 declarations and the user's customization into one tab shortcut
- * assignment per action. A key an A1 action holds after customization never becomes a tab
- * shortcut; between tab actions the earlier declaration keeps a duplicated key.
- */
-export declare function projectResidentTabShortcuts(input?: ResidentTabShortcutInput): ResidentTabShortcutProjection;

package/dist/features/resident-tab/shortcut-projection.js

@@ -1,64 +0,0 @@
-import { RESIDENT_TAB_SHORTCUTS } from "./shortcut-declarations.js";
-/** The declarations the projection covers, in the order that decides duplicate claims. */
-export const RESIDENT_TAB_GLOBAL_SHORTCUTS = RESIDENT_TAB_SHORTCUTS.filter(shortcut => shortcut.scope === "global");
-function normalizeKey(key) {
-    return key.trim().toLowerCase();
-}
-function keysOf(value) {
-    if (value === null || value === undefined)
-        return value;
-    if (typeof value === "string")
-        return [value];
-    return value.filter((key) => typeof key === "string");
-}
-/**
- * Projects the effective A1 declarations and the user's customization into one tab shortcut
- * assignment per action. A key an A1 action holds after customization never becomes a tab
- * shortcut; between tab actions the earlier declaration keeps a duplicated key.
- */
-export function projectResidentTabShortcuts(input = {}) {
-    const configured = input.configured ?? {};
-    const claimedByOwnedActions = new Map();
-    for (const [action, value] of Object.entries(input.reserved ?? {})) {
-        if (action.startsWith("tabs."))
-            continue;
-        claimedByOwnedActions.set(action, keysOf(value) ?? []);
-    }
-    for (const [action, value] of Object.entries(configured)) {
-        if (action.startsWith("tabs.") || action === "$schema")
-            continue;
-        claimedByOwnedActions.set(action, keysOf(value) ?? []);
-    }
-    const reserved = new Set();
-    for (const keys of claimedByOwnedActions.values())
-        for (const key of keys)
-            reserved.add(normalizeKey(key));
-    const claimed = new Set();
-    const conflicts = [];
-    const assignments = {};
-    for (const shortcut of RESIDENT_TAB_GLOBAL_SHORTCUTS) {
-        const id = shortcut.id;
-        const custom = configured[id];
-        const candidates = custom === undefined
-            ? (shortcut.defaultKey === null ? [] : [shortcut.defaultKey])
-            : (keysOf(custom) ?? []);
-        let assigned = null;
-        for (const candidate of candidates.map(normalizeKey)) {
-            if (candidate.length === 0)
-                continue;
-            if (reserved.has(candidate)) {
-                conflicts.push({ id, key: candidate, reason: "reserved" });
-                continue;
-            }
-            if (claimed.has(candidate)) {
-                conflicts.push({ id, key: candidate, reason: "duplicate" });
-                continue;
-            }
-            assigned = candidate;
-            claimed.add(candidate);
-            break;
-        }
-        assignments[id] = assigned;
-    }
-    return { assignments, conflicts };
-}

package/dist/features/resident-tab/status-deriver.d.ts

@@ -1,10 +0,0 @@
-/** How the tab's last agent turn settled; it persists until the next turn starts. */
-export type ResidentTabTurnSettlement = "done" | "aborted" | "error";
-export type ResidentTabDerivedStatus = "starting" | "working" | "needs-input" | "idle" | "failed" | ResidentTabTurnSettlement;
-export interface ResidentTabFacts {
-    readonly lifecycle: string;
-    readonly pendingRequests: number;
-    readonly queuedInput: number;
-    readonly lastTurn?: ResidentTabTurnSettlement;
-}
-export declare function deriveResidentTabStatus(facts: ResidentTabFacts): ResidentTabDerivedStatus;

package/dist/features/resident-tab/status-deriver.js

@@ -1,12 +0,0 @@
-// Invariant: `failed` is reserved for a failed tab lifecycle; a turn that errored reports `error`.
-export function deriveResidentTabStatus(facts) {
-    if (facts.lifecycle === "failed")
-        return "failed";
-    if (facts.pendingRequests > 0)
-        return "needs-input";
-    if (facts.lifecycle === "busy" || facts.queuedInput > 0)
-        return "working";
-    if (facts.lifecycle === "starting")
-        return "starting";
-    return facts.lastTurn ?? "idle";
-}

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;
-}