spawnfile 0.1.12 → 0.1.14

package/dist/cli/statusCommandLive.js

@@ -0,0 +1,188 @@
+import { inspectDockerDeployment, listHomeDeploymentRecords, readHomeDeploymentRecord, readHomeDeploymentReport, recoverDockerDeploymentRecords } from "../deployment/index.js";
+import { extractImageReport, parseDistributionReport, projectImageOrganizationView, renderImageInterface } from "../distribution/index.js";
+import { collectCompiledProbeObservations, collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRegistryDriftObservations, collectRuntimeProbeObservations, createDeploymentSummaries, createStaticStatus, exitCodeForStatus, flattenOrganizationNodes, loadedImageCompileReport, renderStatus, unavailableCompiledProbeFile } from "../status/index.js";
+import { errorExitCode, SpawnfileError } from "../shared/index.js";
+import { statusInputFailure } from "./statusCommandOptions.js";
+export const resolveDeploymentRecords = (records, options) => {
+    if (options.deployment) {
+        const record = records.find((entry) => entry.record.name === options.deployment);
+        return record
+            ? [record]
+            : statusInputFailure(`Unknown deployment "${options.deployment}". Valid deployments: ${records.map((entry) => entry.record.name).sort().join(", ") || "none"}`);
+    }
+    if (options.live && records.length > 1) {
+        return statusInputFailure(`status --live requires --deployment when multiple records exist: ${records.map((entry) => entry.record.name).sort().join(", ")}`);
+    }
+    return records;
+};
+export const inspectDeployments = async (records, handlers, options, timeoutMs) => {
+    if (!options.live) {
+        return new Map();
+    }
+    const inspect = handlers.inspectDockerDeployment ?? inspectDockerDeployment;
+    const inspections = await Promise.all(records.map(async ({ record }) => [
+        record.name,
+        await inspect(record, {
+            dockerCommand: options.dockerCommand,
+            timeoutMs
+        })
+    ]));
+    return new Map(inspections);
+};
+const containsFromView = (view) => flattenOrganizationNodes(view).map((node) => ({ id: node.id, kind: node.kind }));
+const runtimeInstanceIdsFromReport = (loadedReport) => loadedReport.kind === "loaded"
+    ? loadedReport.report.runtimeInstances.map((instance) => instance.id).sort()
+    : [];
+export const recoverContextDeployments = async (input) => {
+    const recover = input.handlers.recoverDockerDeploymentRecords ?? recoverDockerDeploymentRecords;
+    return recover({
+        contains: containsFromView(input.view),
+        context: input.options.context,
+        dockerCommand: input.options.dockerCommand,
+        outputDirectory: input.outputDirectory,
+        projectLabel: input.projectLabel,
+        runtimeInstanceIds: runtimeInstanceIdsFromReport(input.loadedReport),
+        sourceRoot: input.sourceRoot,
+        timeoutMs: input.timeoutMs
+    });
+};
+export const resolveStatusAuthValues = async (records, handlers) => {
+    const values = {};
+    if (!handlers.requireAuthProfile) {
+        return values;
+    }
+    const profileNames = [...new Set(records
+            .map(({ record }) => record.auth_profile)
+            .filter((profileName) => typeof profileName === "string" && profileName.length > 0))];
+    for (const profileName of profileNames) {
+        try {
+            const profile = await handlers.requireAuthProfile(profileName);
+            Object.assign(values, profile.env);
+        }
+        catch {
+            // Missing profile values are reported by the metadata layer as unknown credentials.
+        }
+    }
+    return values;
+};
+/* v8 ignore start -- docker extraction is covered by distribution E2E */
+export const runStaticImageStatus = async (imageRef, options, json) => {
+    try {
+        const inspection = await extractImageReport(imageRef, {
+            dockerCommand: options.dockerCommand,
+            dockerContext: options.context,
+            pull: options.pull
+        });
+        return {
+            exitCode: 0,
+            output: renderImageInterface(inspection.report, { imageRef, json })
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            exitCode: errorExitCode(error)
+        };
+    }
+};
+/* v8 ignore stop */
+export const runHomeDeploymentStatus = async (options, handlers, mode, timeoutMs) => {
+    let records;
+    try {
+        records = await listHomeDeploymentRecords();
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error), exitCode: errorExitCode(error) };
+    }
+    if (!options.deployment) {
+        if (records.length === 0) {
+            return statusInputFailure("No image deployments found in the home store");
+        }
+        if (records.length > 1) {
+            return statusInputFailure(`status --deployment is required: ${records.map((entry) => entry.record.name).sort().join(", ")}`);
+        }
+    }
+    const targetName = options.deployment ?? records[0].record.name;
+    const match = records.find((entry) => entry.record.name === targetName);
+    if (!match) {
+        return statusInputFailure(`Unknown deployment "${targetName}". Valid deployments: ${records.map((entry) => entry.record.name).sort().join(", ") || "none"}`);
+    }
+    let report;
+    try {
+        const record = await readHomeDeploymentRecord(targetName);
+        void record;
+        const raw = await readHomeDeploymentReport(targetName);
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new SpawnfileError("validation_error", `Cached report for "${targetName}" is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        report = parseDistributionReport(parsed);
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error), exitCode: errorExitCode(error) };
+    }
+    const view = projectImageOrganizationView(report, match.record.source.kind === "image"
+        ? match.record.source.ref
+        : targetName);
+    const reportPath = match.path.replace(/record\.json$/, "spawnfile-report.json");
+    const loadedReport = loadedImageCompileReport(report, reportPath);
+    const selectedRecords = [match];
+    const deploymentInspections = await inspectDeployments(selectedRecords, handlers, options, timeoutMs);
+    const recordValues = selectedRecords.map(({ record }) => record);
+    const authValues = options.live ? await resolveStatusAuthValues(selectedRecords, handlers) : {};
+    const collectRuntimeProbes = handlers.collectRuntimeProbeObservations ?? collectRuntimeProbeObservations;
+    const collectMoltnetProbes = handlers.collectMoltnetProbeObservations ?? collectMoltnetProbeObservations;
+    const collectDeploymentLogs = handlers.collectDeploymentLogObservations ?? collectDeploymentLogObservations;
+    const liveObservations = options.live && !options.recover
+        ? [
+            ...await collectRuntimeProbes({
+                deployments: recordValues,
+                inspections: deploymentInspections,
+                loadedReport,
+                timeoutMs
+            }),
+            ...await collectMoltnetProbes({
+                authValues,
+                deployments: recordValues,
+                inspections: deploymentInspections,
+                loadedReport,
+                timeoutMs
+            }),
+            ...(options.logs
+                ? await collectDeploymentLogs({
+                    deployments: recordValues,
+                    dockerCommand: options.dockerCommand,
+                    loadedReport,
+                    timeoutMs
+                })
+                : []),
+            ...(options.pullCheck
+                ? await collectRegistryDriftObservations({
+                    deployments: recordValues,
+                    dockerCommand: options.dockerCommand,
+                    timeoutMs
+                })
+                : [])
+        ]
+        : [];
+    const compiledProbeObservations = await collectCompiledProbeObservations(loadedReport, null, unavailableCompiledProbeFile, handlers.compiledProbeCollectors);
+    const status = createStaticStatus(view, loadedReport, {
+        compiledProbeObservations,
+        deployments: createDeploymentSummaries(selectedRecords, deploymentInspections),
+        inputPath: view.inputPath,
+        live: {
+            context: null,
+            deploymentName: targetName,
+            logs: options.logs ?? false,
+            recover: false,
+            requested: options.live ?? false
+        },
+        liveObservations,
+        outputDirectory: "",
+        selection: null
+    });
+    return { exitCode: exitCodeForStatus(status), output: renderStatus(status, { mode }), status };
+};

package/dist/cli/statusCommandOptions.d.ts

@@ -0,0 +1,40 @@
+import type { CompiledProbeCollectors, StatusCommandResult, StatusOutputMode, StatusSelectorInput } from "../status/index.js";
+import { collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations } from "../status/index.js";
+import { inspectDockerDeployment, recoverDockerDeploymentRecords } from "../deployment/index.js";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export type StatusCommandHandlers = Pick<CliHandlers, "buildOrganizationView"> & Partial<Pick<CliHandlers, "requireAuthProfile">>;
+export interface StatusCommandLiveHandlers {
+    collectDeploymentLogObservations?: typeof collectDeploymentLogObservations;
+    collectMoltnetProbeObservations?: typeof collectMoltnetProbeObservations;
+    collectRuntimeProbeObservations?: typeof collectRuntimeProbeObservations;
+    compiledProbeCollectors?: CompiledProbeCollectors;
+    inspectDockerDeployment?: typeof inspectDockerDeployment;
+    recoverDockerDeploymentRecords?: typeof recoverDockerDeploymentRecords;
+}
+export type StatusCommandHandlersWithLive = StatusCommandHandlers & StatusCommandLiveHandlers;
+export interface StatusCommandOptions {
+    agent?: string;
+    context?: string;
+    deployment?: string;
+    dockerCommand?: string;
+    image?: boolean;
+    json?: boolean;
+    live?: boolean;
+    logs?: boolean;
+    network?: string;
+    out?: string;
+    pretty?: boolean;
+    pull?: boolean;
+    pullCheck?: boolean;
+    quiet?: boolean;
+    recover?: boolean;
+    runtime?: string;
+    team?: string;
+    timeout?: string;
+    watch?: boolean;
+}
+export declare const statusInputFailure: (message: string) => StatusCommandResult;
+export declare const resolveStatusOutputMode: (options: StatusCommandOptions) => StatusOutputMode | StatusCommandResult;
+export declare const resolveStatusSelectorInput: (options: StatusCommandOptions) => StatusSelectorInput | null | StatusCommandResult;
+export declare const resolveStatusTimeoutMs: (options: StatusCommandOptions) => number | undefined | StatusCommandResult;
+export declare const emitStatusOutput: (streams: CliStreams, output: string) => void;

package/dist/cli/statusCommandOptions.js

@@ -0,0 +1,42 @@
+export const statusInputFailure = (message) => ({
+    error: message,
+    exitCode: 2
+});
+export const resolveStatusOutputMode = (options) => {
+    const modes = [
+        ...(options.json ? ["json"] : []),
+        ...(options.pretty ? ["pretty"] : []),
+        ...(options.quiet ? ["quiet"] : [])
+    ];
+    if (modes.length > 1) {
+        return statusInputFailure("Choose only one status output mode: --pretty, --json, or --quiet");
+    }
+    return modes[0] ?? "pretty";
+};
+export const resolveStatusSelectorInput = (options) => {
+    const selectors = [
+        ...(options.agent ? [{ kind: "agent", value: options.agent }] : []),
+        ...(options.team ? [{ kind: "team", value: options.team }] : []),
+        ...(options.network ? [{ kind: "network", value: options.network }] : []),
+        ...(options.runtime ? [{ kind: "runtime", value: options.runtime }] : [])
+    ];
+    if (selectors.length > 1) {
+        return statusInputFailure("Choose only one status selector: --agent, --team, --network, or --runtime");
+    }
+    return selectors[0] ?? null;
+};
+export const resolveStatusTimeoutMs = (options) => {
+    if (!options.timeout) {
+        return undefined;
+    }
+    const parsed = Number(options.timeout);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return statusInputFailure("status --timeout must be a positive integer number of milliseconds");
+    }
+    return parsed;
+};
+export const emitStatusOutput = (streams, output) => {
+    for (const line of output.split("\n")) {
+        streams.stdout(line);
+    }
+};

package/dist/cli/targetCliRoute.d.ts

@@ -0,0 +1,2 @@
+/** Routes only when the first actual target subcommand is lookup_operation. */
+export declare const isTargetLookupInvocation: (raw: readonly unknown[]) => boolean;

package/dist/cli/targetCliRoute.js

@@ -0,0 +1,30 @@
+const MAX_ARGUMENTS = 64;
+const MAX_ARGUMENT_BYTES = 4_096;
+const bounded = (value) => typeof value === "string"
+    && value.length > 0
+    && Buffer.byteLength(value, "utf8") <= MAX_ARGUMENT_BYTES;
+/** Routes only when the first actual target subcommand is lookup_operation. */
+export const isTargetLookupInvocation = (raw) => {
+    if (!Array.isArray(raw) || raw.length < 2 || raw.length > MAX_ARGUMENTS
+        || raw.some((value) => !bounded(value)) || raw[0] !== "target")
+        return false;
+    const argv = raw;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--config") {
+            if (!bounded(argv[index + 1]))
+                return false;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--config=")) {
+            if (token.length === "--config=".length)
+                return false;
+            continue;
+        }
+        if (token.startsWith("-"))
+            return false;
+        return token === "lookup_operation";
+    }
+    return false;
+};

package/dist/cli/targetCommands.d.ts

@@ -0,0 +1,33 @@
+import type { Command } from "commander";
+import { type TargetPublicArtifactSnapshot, type TargetPublicArtifactSnapshotRequest } from "../target/publicArtifactSnapshot.js";
+import { type TargetTopologyActivationResult } from "../target/topologyActivation.js";
+import { type SelectedTargetReceipt, type TargetResourceRequest, type TargetTopologyAttestationRequest } from "../target/contracts.js";
+import { type TargetOperation } from "./targetOperationDispatch.js";
+import { type TargetMutationResult } from "./targetReceiptOutput.js";
+import type { TargetDefaultConfig } from "./targetDefaultConfig.js";
+import { type TargetOperationLookupLoader } from "./targetLookupCommands.js";
+import type { TargetTopologyAttestationResult } from "../target/topologyAttestation.js";
+import { type TargetWorldClockSession } from "./targetWorldClockCommand.js";
+import { type TargetWorldReadinessSession } from "./targetWorldReadinessCommand.js";
+type RequestFor<Operation extends TargetOperation> = Extract<TargetResourceRequest, {
+    operation: Operation;
+}>;
+export type TargetCommandHandlers = {
+    [Operation in TargetOperation]: (request: RequestFor<Operation>) => Promise<Operation extends "select_target" ? SelectedTargetReceipt : TargetMutationResult>;
+};
+export type TargetCommandSessionLoader = (configInput: unknown) => Promise<TargetCommandHandlerSession>;
+export interface TargetCommandHandlerSession extends TargetWorldReadinessSession, TargetWorldClockSession {
+    run<Result>(invoke: (handlers: TargetCommandHandlers) => Promise<Result>): Promise<Result>;
+    activateTopology?(request: TargetTopologyAttestationRequest): Promise<TargetTopologyActivationResult>;
+    attestTopology?(request: TargetTopologyAttestationRequest): Promise<TargetTopologyAttestationResult>;
+    snapshotPublicArtifact?(request: TargetPublicArtifactSnapshotRequest): Promise<TargetPublicArtifactSnapshot>;
+}
+export interface TargetCommandStreams {
+    stderr(message: string): void;
+    stdout(message: string): void;
+}
+type SetTargetCommandExitCode = (exitCode: 1 | 2) => void;
+export declare const registerTargetCommands: (program: Command, session: TargetCommandHandlerSession | TargetCommandSessionLoader, streams: TargetCommandStreams, setExitCode: SetTargetCommandExitCode, lookupLoader?: TargetOperationLookupLoader, worldReadinessSession?: (configInput: unknown) => Promise<TargetWorldReadinessSession & TargetWorldClockSession>) => Command;
+export declare const createProductionTargetCommandSession: (config: TargetDefaultConfig) => TargetCommandHandlerSession;
+export declare const registerProductionTargetCommands: (program: Command, streams: TargetCommandStreams, stdin: AsyncIterable<unknown>, setExitCode: SetTargetCommandExitCode) => void;
+export {};

package/dist/cli/targetCommands.js

@@ -0,0 +1,257 @@
+import { createCanonicalTargetTopologyReceiptBytes, createCanonicalSelectedTargetReceiptBytes, createTargetTopologyReceiptDigest } from "../target/handles.js";
+import { createCanonicalTargetPublicArtifactSnapshotBytes } from "../target/publicArtifactSnapshot.js";
+import { createCanonicalTargetTopologyActivationReceiptBytes, createTargetTopologyActivationReceiptDigest, parseTargetTopologyActivationReceipt } from "../target/topologyActivation.js";
+import { parseSelectedTargetReceipt, parseTargetTopologyReceipt } from "../target/contracts.js";
+import { TARGET_OPERATION_DISPATCH } from "./targetOperationDispatch.js";
+import { emitCanonicalTargetMutationReceipt, formatCaughtTargetCliError, formatTargetCliError } from "./targetReceiptOutput.js";
+import { readTargetRequestFile, readTargetPublicArtifactSnapshotRequestFile, readTargetTopologyAttestationRequestFile } from "./targetRequestFile.js";
+import { readTargetDefaultConfigStdin, readTargetWorldReadinessConfigStdin } from "./targetDefaultConfigStdin.js";
+import { createProductionTargetLookupLoader, registerTargetOperationLookup } from "./targetLookupCommands.js";
+import { registerContainerBundleCommand } from "./containerBundleCommand.js";
+import { registerTargetWorldClockCommand } from "./targetWorldClockCommand.js";
+import { registerTargetWorldReadinessCommand, } from "./targetWorldReadinessCommand.js";
+import { registerTargetComposedPreparationCommand } from "./targetComposedPreparationCommand.js";
+import { createProductionTargetWorldQuerySession } from "./targetDefaultWorldQueries.js";
+const operations = Object.keys(TARGET_OPERATION_DISPATCH);
+const invoke = async (handlers, request) => {
+    const handler = handlers[request.operation];
+    return handler(request);
+};
+const emitSelection = (raw, streams) => {
+    const receipt = parseSelectedTargetReceipt(raw);
+    streams.stdout(createCanonicalSelectedTargetReceiptBytes(receipt));
+};
+const registerOperation = (target, operation, session, streams, setExitCode) => {
+    target.command(operation)
+        .description(`Execute the ${operation} target operation`)
+        .argument("<request-file>", "Strict target-resource request JSON file")
+        .action(async (requestFile) => {
+        let request;
+        try {
+            request = await readTargetRequestFile(requestFile);
+            if (request.operation !== operation)
+                throw new TypeError("operation mismatch");
+        }
+        catch {
+            streams.stderr(formatTargetCliError("request"));
+            setExitCode(2);
+            return;
+        }
+        let activeSession;
+        try {
+            activeSession = typeof session === "function"
+                ? await session(target.opts().config)
+                : session;
+        }
+        catch {
+            streams.stderr("error: Invalid target configuration");
+            setExitCode(2);
+            return;
+        }
+        try {
+            const result = await activeSession.run((handlers) => invoke(handlers, request));
+            if (operation === "select_target") {
+                emitSelection(result, streams);
+            }
+            else {
+                emitCanonicalTargetMutationReceipt(result, streams.stdout);
+            }
+        }
+        catch (error) {
+            streams.stderr(formatCaughtTargetCliError(error, "Target operation crashed"));
+            setExitCode(1);
+        }
+    });
+};
+const emitTopologyReceipt = (raw, streams) => {
+    const receipt = parseTargetTopologyReceipt(raw.receipt);
+    const bytes = createCanonicalTargetTopologyReceiptBytes(receipt);
+    if (typeof raw.receiptBytes !== "string" || raw.receiptBytes !== bytes
+        || receipt.receipt_digest !== createTargetTopologyReceiptDigest(receipt)) {
+        throw new TypeError("Target attestation returned a non-canonical receipt");
+    }
+    streams.stdout(bytes);
+};
+const emitTopologyActivationReceipt = (raw, streams) => {
+    const receipt = parseTargetTopologyActivationReceipt(raw.receipt);
+    const bytes = createCanonicalTargetTopologyActivationReceiptBytes(receipt);
+    if (typeof raw.receiptBytes !== "string" || raw.receiptBytes !== bytes
+        || receipt.receipt_digest !== createTargetTopologyActivationReceiptDigest(receipt)) {
+        throw new TypeError("Target activation returned a non-canonical receipt");
+    }
+    streams.stdout(bytes);
+};
+const registerTopologyActivation = (target, session, streams, setExitCode) => {
+    target.command("activate_topology")
+        .description("Release one exact attested target topology")
+        .argument("<request-file>", "Strict target topology-attestation request JSON file")
+        .action(async (requestFile) => {
+        let request;
+        try {
+            request = await readTargetTopologyAttestationRequestFile(requestFile);
+        }
+        catch {
+            streams.stderr("error: Invalid target activation request");
+            setExitCode(2);
+            return;
+        }
+        let activeSession;
+        try {
+            activeSession = typeof session === "function"
+                ? await session(target.opts().config)
+                : session;
+            if (typeof activeSession.activateTopology !== "function")
+                throw new TypeError();
+        }
+        catch {
+            streams.stderr("error: Invalid target configuration");
+            setExitCode(2);
+            return;
+        }
+        try {
+            emitTopologyActivationReceipt(await activeSession.activateTopology(request), streams);
+        }
+        catch (error) {
+            streams.stderr(formatCaughtTargetCliError(error, "Target topology activation crashed"));
+            setExitCode(1);
+        }
+    });
+};
+const registerTopologyAttestation = (target, session, streams, setExitCode) => {
+    target.command("attest_topology")
+        .description("Attest one exact composed target topology")
+        .argument("<request-file>", "Strict target topology-attestation request JSON file")
+        .action(async (requestFile) => {
+        let request;
+        try {
+            request = await readTargetTopologyAttestationRequestFile(requestFile);
+        }
+        catch {
+            streams.stderr("error: Invalid target attestation request");
+            setExitCode(2);
+            return;
+        }
+        let activeSession;
+        try {
+            activeSession = typeof session === "function"
+                ? await session(target.opts().config)
+                : session;
+            if (typeof activeSession.attestTopology !== "function")
+                throw new TypeError();
+        }
+        catch {
+            streams.stderr("error: Invalid target configuration");
+            setExitCode(2);
+            return;
+        }
+        try {
+            emitTopologyReceipt(await activeSession.attestTopology(request), streams);
+        }
+        catch (error) {
+            streams.stderr(formatCaughtTargetCliError(error, "Target topology attestation crashed"));
+            setExitCode(1);
+        }
+    });
+};
+const registerPublicArtifactSnapshot = (target, session, streams, setExitCode) => {
+    target.command("snapshot_public_artifact")
+        .description("Read one exact bounded public artifact from a world service")
+        .argument("<request-file>", "Strict public artifact snapshot request JSON file")
+        .action(async (requestFile) => {
+        let request;
+        try {
+            request = await readTargetPublicArtifactSnapshotRequestFile(requestFile);
+        }
+        catch {
+            streams.stderr("error: Invalid public artifact snapshot request");
+            setExitCode(2);
+            return;
+        }
+        let activeSession;
+        try {
+            activeSession = typeof session === "function"
+                ? await session(target.opts().config)
+                : session;
+            if (typeof activeSession.snapshotPublicArtifact !== "function")
+                throw new TypeError();
+        }
+        catch {
+            streams.stderr("error: Invalid target configuration");
+            setExitCode(2);
+            return;
+        }
+        try {
+            streams.stdout(createCanonicalTargetPublicArtifactSnapshotBytes(await activeSession.snapshotPublicArtifact(request)));
+        }
+        catch (error) {
+            streams.stderr(formatCaughtTargetCliError(error, "Target public artifact snapshot crashed"));
+            setExitCode(1);
+        }
+    });
+};
+export const registerTargetCommands = (program, session, streams, setExitCode, lookupLoader, worldReadinessSession) => {
+    const target = program.command("target").description("Execute target-resource operations");
+    if (typeof session === "function") {
+        target.requiredOption("--config <config-input>", "Strict target configuration JSON stdin; use -");
+    }
+    for (const operation of operations) {
+        registerOperation(target, operation, session, streams, setExitCode);
+    }
+    registerTargetComposedPreparationCommand(target, session, streams, setExitCode);
+    if (typeof session === "function" || typeof session.attestTopology === "function") {
+        registerTopologyAttestation(target, session, streams, setExitCode);
+    }
+    if (typeof session === "function" || typeof session.snapshotPublicArtifact === "function") {
+        registerPublicArtifactSnapshot(target, session, streams, setExitCode);
+    }
+    if (typeof session === "function" || typeof session.queryWorldReadiness === "function") {
+        registerTargetWorldReadinessCommand(target, worldReadinessSession ?? session, streams, setExitCode);
+    }
+    if (typeof session === "function" || typeof session.queryWorldClock === "function") {
+        registerTargetWorldClockCommand(target, worldReadinessSession ?? session, streams, setExitCode);
+    }
+    if (typeof session === "function" || typeof session.activateTopology === "function") {
+        registerTopologyActivation(target, session, streams, setExitCode);
+    }
+    if (lookupLoader)
+        registerTargetOperationLookup(target, lookupLoader, streams, setExitCode);
+    return target;
+};
+export const createProductionTargetCommandSession = (config) => Object.freeze({
+    activateTopology: async (request) => {
+        const { activateTargetDefaultTopology } = await import("./targetDefaultHandlers.js");
+        return activateTargetDefaultTopology(config, request);
+    },
+    run: async (invokeHandlers) => {
+        const { withTargetDefaultHandlerSession } = await import("./targetDefaultHandlers.js");
+        return withTargetDefaultHandlerSession(config, invokeHandlers);
+    },
+    attestTopology: async (request) => {
+        const { attestTargetDefaultTopology } = await import("./targetDefaultHandlers.js");
+        return attestTargetDefaultTopology(config, request);
+    },
+    queryWorldReadiness: async (request) => {
+        const { queryTargetDefaultWorldReadiness } = await import("./targetDefaultWorldReadiness.js");
+        return queryTargetDefaultWorldReadiness(config, request);
+    },
+    queryWorldClock: async (request) => {
+        const { queryTargetDefaultWorldClock } = await import("./targetDefaultWorldClock.js");
+        return queryTargetDefaultWorldClock(config, request);
+    },
+    snapshotPublicArtifact: async (request) => {
+        const { snapshotTargetDefaultPublicArtifact } = await import("./targetDefaultHandlers.js");
+        return snapshotTargetDefaultPublicArtifact(config, request);
+    }
+});
+export const registerProductionTargetCommands = (program, streams, stdin, setExitCode) => {
+    const target = registerTargetCommands(program, async (configInput) => {
+        if (configInput !== "-")
+            throw new TypeError("Invalid target configuration");
+        return createProductionTargetCommandSession(await readTargetDefaultConfigStdin(stdin));
+    }, streams, setExitCode, createProductionTargetLookupLoader(stdin), async (configInput) => {
+        if (configInput !== "-")
+            throw new TypeError("Invalid target configuration");
+        return createProductionTargetWorldQuerySession(await readTargetWorldReadinessConfigStdin(stdin));
+    });
+    registerContainerBundleCommand(target, stdin, streams, setExitCode);
+};

package/dist/cli/targetComposedPreparationCommand.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { TargetCommandHandlerSession, TargetCommandSessionLoader, TargetCommandStreams } from "./targetCommands.js";
+type SetExitCode = (exitCode: 1 | 2) => void;
+/** Registers the sole aggregate preparation path consumed by Simfile. */
+export declare const registerTargetComposedPreparationCommand: (target: Command, session: TargetCommandHandlerSession | TargetCommandSessionLoader, streams: TargetCommandStreams, setExitCode: SetExitCode) => void;
+export {};

package/dist/cli/targetComposedPreparationCommand.js

@@ -0,0 +1,39 @@
+import { createCanonicalComposedPreparationReceiptBytes, prepareComposedRun, } from "../target/composedPreparation.js";
+import { formatCaughtTargetCliError } from "./targetReceiptOutput.js";
+import { readComposedPreparationRequestFile } from "./targetRequestFile.js";
+/** Registers the sole aggregate preparation path consumed by Simfile. */
+export const registerTargetComposedPreparationCommand = (target, session, streams, setExitCode) => {
+    target.command("prepare_composed_run")
+        .description("Prepare one immutable composed-run target resource set")
+        .argument("<request-file>", "Strict composed-preparation request JSON file")
+        .action(async (requestFile) => {
+        let request;
+        try {
+            request = await readComposedPreparationRequestFile(requestFile);
+        }
+        catch {
+            streams.stderr("error: Invalid composed preparation request");
+            setExitCode(2);
+            return;
+        }
+        let activeSession;
+        try {
+            activeSession = typeof session === "function"
+                ? await session(target.opts().config)
+                : session;
+        }
+        catch {
+            streams.stderr("error: Invalid target configuration");
+            setExitCode(2);
+            return;
+        }
+        try {
+            const receipt = await activeSession.run((handlers) => prepareComposedRun(handlers, request));
+            streams.stdout(createCanonicalComposedPreparationReceiptBytes(receipt));
+        }
+        catch (error) {
+            streams.stderr(formatCaughtTargetCliError(error, "Composed preparation crashed"));
+            setExitCode(1);
+        }
+    });
+};

package/dist/cli/targetDefaultArtifactAuthority.d.ts

@@ -0,0 +1,5 @@
+import type { TargetDefaultConfig } from "./targetDefaultConfig.js";
+import type { DockerArtifactIdentityBinding, DockerArtifactIdentityStore, DockerArtifactMapping } from "../target/dockerArtifactsProvider.js";
+import type { TargetJournalStore } from "../target/journal.js";
+export declare const completedTargetArtifacts: (journal: TargetJournalStore, identities: DockerArtifactIdentityStore) => Promise<readonly DockerArtifactIdentityBinding[]>;
+export declare const exactTargetArtifactMapping: (config: TargetDefaultConfig, binding: DockerArtifactIdentityBinding) => DockerArtifactMapping;