spawnfile 0.1.12 → 0.1.14

package/dist/cli/targetDefaultJournalAuthority.js

@@ -0,0 +1,135 @@
+import { SELECTED_TARGET_VERSION, parseSelectedTargetReceipt, parseTargetResourceRequest } from "../target/contracts.js";
+import { initializeTargetJournal, openExistingTargetJournalAuthority } from "../target/journal.js";
+import { targetDefaultEnvelope as envelope } from "./targetDefaultEnvelope.js";
+export const TARGET_DEFAULT_AUTHORITIES_ERROR = "Target authority initialization failed";
+const fail = () => { throw new Error(TARGET_DEFAULT_AUTHORITIES_ERROR); };
+const selectedFrom = (request) => parseSelectedTargetReceipt({
+    ...request.selected_target,
+    version: SELECTED_TARGET_VERSION
+});
+const mutation = (raw) => {
+    let request;
+    try {
+        request = parseTargetResourceRequest(raw);
+    }
+    catch {
+        return fail();
+    }
+    if (request.operation === "select_target")
+        return fail();
+    return request;
+};
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const identityKey = (context, request, selected) => [
+    context,
+    request.run_id,
+    request.descriptor_digest,
+    selected.fingerprint,
+    selected.handle
+].join("\0");
+export const createTargetJournalAccess = (config) => {
+    const cache = new Map();
+    const resolveIdentity = async (input) => {
+        if (input.context !== config.context)
+            return fail();
+        let selectedTarget;
+        try {
+            selectedTarget = parseSelectedTargetReceipt({
+                ...input.selectedTarget,
+                version: SELECTED_TARGET_VERSION
+            });
+        }
+        catch {
+            return fail();
+        }
+        const synthetic = {
+            descriptor_digest: input.descriptorDigest,
+            run_id: input.runId,
+            selected_target: {
+                fingerprint: selectedTarget.fingerprint,
+                handle: selectedTarget.handle
+            }
+        };
+        const key = identityKey(config.context, synthetic, selectedTarget);
+        let journal = cache.get(key);
+        if (!journal) {
+            journal = initializeTargetJournal({
+                context: config.context,
+                descriptorDigest: input.descriptorDigest,
+                root: config.paths.journals,
+                runId: input.runId,
+                selectedTarget
+            });
+            cache.set(key, journal);
+            journal.catch(() => { if (cache.get(key) === journal)
+                cache.delete(key); });
+        }
+        const resolved = await journal;
+        const snapshot = await resolved.read();
+        if (snapshot.run_id !== input.runId
+            || snapshot.descriptor_digest !== input.descriptorDigest
+            || !same(snapshot.selected_target, synthetic.selected_target))
+            return fail();
+        return resolved;
+    };
+    const resolveExistingIdentity = async (input) => {
+        if (input.context !== config.context)
+            return fail();
+        let selectedTarget;
+        try {
+            selectedTarget = parseSelectedTargetReceipt({
+                ...input.selectedTarget,
+                version: SELECTED_TARGET_VERSION
+            });
+        }
+        catch {
+            return fail();
+        }
+        const synthetic = {
+            descriptor_digest: input.descriptorDigest,
+            run_id: input.runId,
+            selected_target: { fingerprint: selectedTarget.fingerprint, handle: selectedTarget.handle }
+        };
+        let resolved;
+        try {
+            resolved = await openExistingTargetJournalAuthority({
+                context: config.context,
+                descriptorDigest: input.descriptorDigest,
+                root: config.paths.journals,
+                runId: input.runId,
+                selectedTarget
+            });
+        }
+        catch {
+            return fail();
+        }
+        const snapshot = await resolved.read();
+        if (snapshot.run_id !== input.runId
+            || snapshot.descriptor_digest !== input.descriptorDigest
+            || !same(snapshot.selected_target, synthetic.selected_target))
+            return fail();
+        return resolved;
+    };
+    const resolver = Object.freeze({
+        resolve: async (raw) => {
+            const input = envelope(raw, ["context", "request"]);
+            if (input.context !== config.context)
+                return fail();
+            const request = mutation(input.request);
+            const selectedTarget = selectedFrom(request);
+            if (!same(request.selected_target, {
+                fingerprint: selectedTarget.fingerprint,
+                handle: selectedTarget.handle
+            }))
+                return fail();
+            const resolved = await resolveIdentity({
+                context: input.context,
+                descriptorDigest: request.descriptor_digest,
+                runId: request.run_id,
+                selectedTarget: request.selected_target
+            });
+            return Object.freeze({ journal: resolved, request, selectedTarget });
+        }
+    });
+    return { resolver, resolveExistingIdentity, resolveIdentity };
+};

package/dist/cli/targetDefaultWorldClock.d.ts

@@ -0,0 +1,4 @@
+import { type TargetWorldClockReceipt } from "../target/worldClock.js";
+import type { TargetDefaultWorldReadinessConfig } from "./targetDefaultConfig.js";
+/** Query one recorded world and its immutable activation marker for clock truth. */
+export declare const queryTargetDefaultWorldClock: (config: TargetDefaultWorldReadinessConfig, request: unknown) => Promise<TargetWorldClockReceipt>;

package/dist/cli/targetDefaultWorldClock.js

@@ -0,0 +1,14 @@
+import { createDockerTargetExecutors } from "../target/dockerCommandExecutor.js";
+import { createDockerWorldClockReader } from "../target/dockerWorldClock.js";
+import { initializeWorldServiceAuthorityReader } from "../target/dockerWorldServiceStore.js";
+import { parseTargetWorldClockRequest, } from "../target/worldClock.js";
+/** Query one recorded world and its immutable activation marker for clock truth. */
+export const queryTargetDefaultWorldClock = async (config, request) => {
+    const parsed = parseTargetWorldClockRequest(request);
+    const authorityStore = await initializeWorldServiceAuthorityReader(config.paths.worldAuthority);
+    const executors = createDockerTargetExecutors({ dockerCommand: config.dockerCommand });
+    return createDockerWorldClockReader({
+        authorityStore, context: config.context, contentExecutor: executors.publicArtifact,
+        executor: executors.world, timeoutMs: config.timeoutMs,
+    }).query(parsed);
+};

package/dist/cli/targetDefaultWorldQueries.d.ts

@@ -0,0 +1,5 @@
+import type { TargetDefaultWorldReadinessConfig } from "./targetDefaultConfig.js";
+import type { TargetWorldClockSession } from "./targetWorldClockCommand.js";
+import type { TargetWorldReadinessSession } from "./targetWorldReadinessCommand.js";
+/** Minimal production session shared by the two read-only world queries. */
+export declare const createProductionTargetWorldQuerySession: (config: TargetDefaultWorldReadinessConfig) => TargetWorldReadinessSession & TargetWorldClockSession;

package/dist/cli/targetDefaultWorldQueries.js

@@ -0,0 +1,11 @@
+/** Minimal production session shared by the two read-only world queries. */
+export const createProductionTargetWorldQuerySession = (config) => Object.freeze({
+    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);
+    },
+});

package/dist/cli/targetDefaultWorldReadiness.d.ts

@@ -0,0 +1,4 @@
+import { type TargetWorldReadinessReceipt } from "../target/worldReadiness.js";
+import type { TargetDefaultWorldReadinessConfig } from "./targetDefaultConfig.js";
+/** Query one exact world through its private container-local readiness endpoint. */
+export declare const queryTargetDefaultWorldReadiness: (config: TargetDefaultWorldReadinessConfig, request: unknown) => Promise<TargetWorldReadinessReceipt>;

package/dist/cli/targetDefaultWorldReadiness.js

@@ -0,0 +1,17 @@
+import { createDockerWorldReadinessReader } from "../target/dockerWorldReadiness.js";
+import { createDockerTargetExecutors } from "../target/dockerCommandExecutor.js";
+import { initializeWorldServiceAuthorityReader } from "../target/dockerWorldServiceStore.js";
+import { parseTargetWorldReadinessRequest } from "../target/worldReadiness.js";
+/** Query one exact world through its private container-local readiness endpoint. */
+export const queryTargetDefaultWorldReadiness = async (config, request) => {
+    const parsedRequest = parseTargetWorldReadinessRequest(request);
+    const authorityStore = await initializeWorldServiceAuthorityReader(config.paths.worldAuthority);
+    const executors = createDockerTargetExecutors({ dockerCommand: config.dockerCommand });
+    return createDockerWorldReadinessReader({
+        authorityStore,
+        context: config.context,
+        contentExecutor: executors.publicArtifact,
+        executor: executors.world,
+        timeoutMs: config.timeoutMs
+    }).query(parsedRequest);
+};

package/dist/cli/targetEvidenceHelperResolution.d.ts

@@ -0,0 +1,14 @@
+import { type TargetResourceRequest } from "../target/contracts.js";
+type EvidenceExportRequest = Extract<TargetResourceRequest, {
+    operation: "export_evidence_volume";
+}>;
+type ArtifactResolutionRequest = Extract<TargetResourceRequest, {
+    operation: "resolve_world_artifact";
+}>;
+/**
+ * Derives the target-owned helper admission immediately preceding an evidence
+ * export. The public export revision therefore names the second mutation in
+ * this aggregate operation; recovery reuses the completed admission.
+ */
+export declare const createTargetEvidenceHelperResolutionRequest: (request: EvidenceExportRequest, artifactManifestDigest: string) => ArtifactResolutionRequest;
+export {};

package/dist/cli/targetEvidenceHelperResolution.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+import { parseTargetResourceRequest, } from "../target/contracts.js";
+/**
+ * Derives the target-owned helper admission immediately preceding an evidence
+ * export. The public export revision therefore names the second mutation in
+ * this aggregate operation; recovery reuses the completed admission.
+ */
+export const createTargetEvidenceHelperResolutionRequest = (request, artifactManifestDigest) => {
+    if (request.expected_revision < 1)
+        throw new Error("Target operation mismatch");
+    return parseTargetResourceRequest({
+        artifact_manifest_digest: artifactManifestDigest,
+        descriptor_digest: request.descriptor_digest,
+        expected_revision: request.expected_revision - 1,
+        idempotency_key: `idem_${createHash("sha256")
+            .update("spawnfile.target-evidence-helper-resolution.v1\0", "utf8")
+            .update(request.idempotency_key, "utf8").digest("hex").slice(0, 32)}`,
+        operation: "resolve_world_artifact",
+        run_id: request.run_id,
+        selected_target: request.selected_target,
+        version: "spawnfile.target-resource.request.v1",
+    });
+};

package/dist/cli/targetLookupCli.d.ts

@@ -0,0 +1,3 @@
+import { type TargetLookupCommandStreams } from "./targetLookupCommands.js";
+/** Minimal production entry point for lookup; it loads no mutation/provider defaults. */
+export declare const runTargetLookupCli: (argv: string[], stdin?: AsyncIterable<unknown>, streams?: TargetLookupCommandStreams) => Promise<number>;

package/dist/cli/targetLookupCli.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { createProductionTargetLookupLoader, registerTargetOperationLookup } from "./targetLookupCommands.js";
+const defaultStreams = () => ({
+    stderr: (message) => process.stderr.write(`${message}\n`),
+    stdout: (message) => process.stdout.write(`${message}\n`)
+});
+const commanderError = (error) => typeof error === "object" && error !== null
+    && typeof error.exitCode === "number";
+/** Minimal production entry point for lookup; it loads no mutation/provider defaults. */
+export const runTargetLookupCli = async (argv, stdin = process.stdin, streams = defaultStreams()) => {
+    let exitCode = 0;
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({ writeErr: () => undefined, writeOut: () => undefined });
+    const target = program.command("target").description("Execute target-resource operations");
+    target.requiredOption("--config <config-input>", "Strict target configuration JSON stdin; use -");
+    registerTargetOperationLookup(target, createProductionTargetLookupLoader(stdin), streams, (code) => { exitCode = code; });
+    try {
+        await program.parseAsync(argv, { from: "user" });
+        return exitCode;
+    }
+    catch (error) {
+        if (commanderError(error)) {
+            if (error.exitCode !== 0)
+                streams.stderr("error: Invalid target command");
+            return error.exitCode === 0 ? 0 : 2;
+        }
+        streams.stderr("error: Target operation lookup failed");
+        return 1;
+    }
+};

package/dist/cli/targetLookupCommands.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import { type TargetMutationRequest, type TargetOperationLookup } from "../target/contracts.js";
+export interface TargetLookupCommandStreams {
+    stderr(message: string): void;
+    stdout(message: string): void;
+}
+export type TargetOperationLookupHandler = (request: TargetMutationRequest) => Promise<TargetOperationLookup>;
+export type TargetOperationLookupLoader = (configInput: unknown) => Promise<TargetOperationLookupHandler>;
+type SetExitCode = (exitCode: 1 | 2) => void;
+export declare const registerTargetOperationLookup: (target: Command, loader: TargetOperationLookupLoader, streams: TargetLookupCommandStreams, setExitCode: SetExitCode) => void;
+export declare const createProductionTargetLookupLoader: (stdin: AsyncIterable<unknown>) => TargetOperationLookupLoader;
+export {};

package/dist/cli/targetLookupCommands.js

@@ -0,0 +1,69 @@
+import { parseTargetOperationLookup } from "../target/contracts.js";
+import { createCanonicalTargetOperationLookupBytes, createTargetReceiptDigest, createTargetRequestDigest } from "../target/handles.js";
+import { lookupTargetOperation } from "../target/journal.js";
+import { resolveTargetDefaultJournalRoot } from "../target/journalRoot.js";
+import { readTargetLookupConfigStdin } from "./targetDefaultConfigStdin.js";
+import { readTargetRequestFile } from "./targetRequestFile.js";
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const emitLookup = (raw, request, streams) => {
+    const result = parseTargetOperationLookup(raw);
+    const requestDigest = createTargetRequestDigest(request);
+    if (result.idempotency_key !== request.idempotency_key
+        || result.operation !== request.operation
+        || result.request_digest !== requestDigest)
+        throw new TypeError();
+    if (result.status === "completed"
+        && (result.receipt.receipt_digest !== createTargetReceiptDigest(result.receipt)
+            || result.receipt.descriptor_digest !== request.descriptor_digest
+            || result.receipt.run_id !== request.run_id
+            || !same(result.receipt.selected_target, request.selected_target)
+            || result.receipt.resulting_revision !== request.expected_revision + 1)) {
+        throw new TypeError();
+    }
+    streams.stdout(createCanonicalTargetOperationLookupBytes(result));
+};
+export const registerTargetOperationLookup = (target, loader, streams, setExitCode) => {
+    target.command("lookup_operation")
+        .description("Read the state of one exact target mutation")
+        .argument("<request-file>", "Original strict target-resource mutation request JSON file")
+        .action(async (requestFile) => {
+        let request;
+        try {
+            const parsed = await readTargetRequestFile(requestFile);
+            if (parsed.operation === "select_target")
+                throw new TypeError();
+            request = parsed;
+        }
+        catch {
+            streams.stderr("error: Invalid target lookup request");
+            setExitCode(2);
+            return;
+        }
+        let lookup;
+        try {
+            lookup = await loader(target.opts().config);
+        }
+        catch {
+            streams.stderr("error: Invalid target lookup configuration");
+            setExitCode(2);
+            return;
+        }
+        try {
+            emitLookup(await lookup(request), request, streams);
+        }
+        catch {
+            streams.stderr("error: Target operation lookup failed");
+            setExitCode(1);
+        }
+    });
+};
+export const createProductionTargetLookupLoader = (stdin) => async (configInput) => {
+    if (configInput !== "-")
+        throw new TypeError();
+    const config = await readTargetLookupConfigStdin(stdin);
+    return (request) => lookupTargetOperation({
+        context: config.context,
+        request,
+        root: resolveTargetDefaultJournalRoot()
+    });
+};

package/dist/cli/targetOperationDispatch.d.ts

@@ -0,0 +1,58 @@
+import type { TargetResourceRequest } from "../target/contracts.js";
+export type TargetOperation = TargetResourceRequest["operation"];
+export type TargetMutationOperation = Exclude<TargetOperation, "select_target">;
+export interface TargetSelectionDispatch {
+    readonly kind: "selection";
+    readonly operation: "select_target";
+}
+export interface TargetMutationDispatch {
+    readonly kind: "mutation";
+    readonly operation: TargetMutationOperation;
+}
+export type TargetOperationDispatch = TargetSelectionDispatch | TargetMutationDispatch;
+export declare const TARGET_OPERATION_DISPATCH: Readonly<{
+    attach_organization: TargetMutationDispatch & {
+        readonly operation: "attach_organization";
+    };
+    cleanup_run: TargetMutationDispatch & {
+        readonly operation: "cleanup_run";
+    };
+    create_data_network: TargetMutationDispatch & {
+        readonly operation: "create_data_network";
+    };
+    create_evidence_volume: TargetMutationDispatch & {
+        readonly operation: "create_evidence_volume";
+    };
+    create_world_service: TargetMutationDispatch & {
+        readonly operation: "create_world_service";
+    };
+    detach_organization: TargetMutationDispatch & {
+        readonly operation: "detach_organization";
+    };
+    export_evidence_volume: TargetMutationDispatch & {
+        readonly operation: "export_evidence_volume";
+    };
+    prepare_secret_bindings: TargetMutationDispatch & {
+        readonly operation: "prepare_secret_bindings";
+    };
+    recover_operation: TargetMutationDispatch & {
+        readonly operation: "recover_operation";
+    };
+    resolve_world_artifact: TargetMutationDispatch & {
+        readonly operation: "resolve_world_artifact";
+    };
+    revoke_secret_bindings: TargetMutationDispatch & {
+        readonly operation: "revoke_secret_bindings";
+    };
+    select_target: {
+        kind: "selection";
+        operation: "select_target";
+    };
+    start_world_service: TargetMutationDispatch & {
+        readonly operation: "start_world_service";
+    };
+    stop_world_service: TargetMutationDispatch & {
+        readonly operation: "stop_world_service";
+    };
+}>;
+export declare const targetOperationDispatch: (request: TargetResourceRequest) => TargetOperationDispatch;

package/dist/cli/targetOperationDispatch.js

@@ -0,0 +1,21 @@
+const mutation = (operation) => ({
+    kind: "mutation",
+    operation
+});
+export const TARGET_OPERATION_DISPATCH = Object.freeze({
+    attach_organization: mutation("attach_organization"),
+    cleanup_run: mutation("cleanup_run"),
+    create_data_network: mutation("create_data_network"),
+    create_evidence_volume: mutation("create_evidence_volume"),
+    create_world_service: mutation("create_world_service"),
+    detach_organization: mutation("detach_organization"),
+    export_evidence_volume: mutation("export_evidence_volume"),
+    prepare_secret_bindings: mutation("prepare_secret_bindings"),
+    recover_operation: mutation("recover_operation"),
+    resolve_world_artifact: mutation("resolve_world_artifact"),
+    revoke_secret_bindings: mutation("revoke_secret_bindings"),
+    select_target: { kind: "selection", operation: "select_target" },
+    start_world_service: mutation("start_world_service"),
+    stop_world_service: mutation("stop_world_service")
+});
+export const targetOperationDispatch = (request) => TARGET_OPERATION_DISPATCH[request.operation];

package/dist/cli/targetReceiptOutput.d.ts

@@ -0,0 +1,14 @@
+import { type TargetResourceReceipt } from "../target/contracts.js";
+export interface TargetMutationResult {
+    readonly receipt: unknown;
+    readonly receiptBytes: unknown;
+}
+export interface CanonicalTargetMutationReceipt {
+    readonly bytes: string;
+    readonly receipt: TargetResourceReceipt;
+}
+export type TargetCliErrorPhase = "operation" | "request";
+export declare const formatTargetCliError: (phase: TargetCliErrorPhase) => string;
+export declare const formatCaughtTargetCliError: (error: unknown, crashMessage: string) => string;
+export declare const validateCanonicalTargetMutationReceipt: (raw: TargetMutationResult) => CanonicalTargetMutationReceipt;
+export declare const emitCanonicalTargetMutationReceipt: (raw: TargetMutationResult, write: (receiptBytes: string) => void) => TargetResourceReceipt;

package/dist/cli/targetReceiptOutput.js

@@ -0,0 +1,21 @@
+import { createCanonicalTargetReceiptBytes, createTargetReceiptDigest } from "../target/handles.js";
+import { parseTargetResourceReceipt } from "../target/contracts.js";
+import { isSpawnfileError } from "../shared/index.js";
+export const formatTargetCliError = (phase) => phase === "request" ? "error: Invalid target request" : "error: Target operation failed";
+export const formatCaughtTargetCliError = (error, crashMessage) => isSpawnfileError(error)
+    ? `error: ${error.message}`
+    : `error: ${crashMessage}`;
+export const validateCanonicalTargetMutationReceipt = (raw) => {
+    const receipt = parseTargetResourceReceipt(raw.receipt);
+    const bytes = createCanonicalTargetReceiptBytes(receipt);
+    if (receipt.receipt_digest !== createTargetReceiptDigest(receipt)
+        || typeof raw.receiptBytes !== "string" || raw.receiptBytes !== bytes) {
+        throw new TypeError("Target operation returned a non-canonical receipt");
+    }
+    return Object.freeze({ bytes, receipt });
+};
+export const emitCanonicalTargetMutationReceipt = (raw, write) => {
+    const validated = validateCanonicalTargetMutationReceipt(raw);
+    write(validated.bytes);
+    return validated.receipt;
+};

package/dist/cli/targetRequestFile.d.ts

@@ -0,0 +1,14 @@
+import { type TargetTopologyAttestationRequest, type TargetResourceRequest } from "../target/contracts.js";
+import { type ComposedPreparationRequest } from "../target/composedPreparation.js";
+import { type TargetPublicArtifactSnapshotRequest } from "../target/publicArtifactSnapshot.js";
+import { type TargetWorldClockRequest } from "../target/worldClock.js";
+import { type TargetWorldReadinessRequest } from "../target/worldReadiness.js";
+export declare const DEFAULT_TARGET_REQUEST_FILE_BYTES = 262144;
+export declare const MAX_TARGET_REQUEST_FILE_BYTES = 1048576;
+export declare const MAX_TARGET_REQUEST_FILE_PATH_BYTES = 4096;
+export declare const readTargetRequestFile: (filePath: string, byteLimit?: number) => Promise<TargetResourceRequest>;
+export declare const readComposedPreparationRequestFile: (filePath: string, byteLimit?: number) => Promise<ComposedPreparationRequest>;
+export declare const readTargetTopologyAttestationRequestFile: (filePath: string, byteLimit?: number) => Promise<TargetTopologyAttestationRequest>;
+export declare const readTargetPublicArtifactSnapshotRequestFile: (filePath: string, byteLimit?: number) => Promise<TargetPublicArtifactSnapshotRequest>;
+export declare const readTargetWorldReadinessRequestFile: (filePath: string, byteLimit?: number) => Promise<TargetWorldReadinessRequest>;
+export declare const readTargetWorldClockRequestFile: (filePath: string, byteLimit?: number) => Promise<TargetWorldClockRequest>;

package/dist/cli/targetRequestFile.js

@@ -0,0 +1,63 @@
+import { open } from "node:fs/promises";
+import path from "node:path";
+import { parseTargetResourceRequest, parseTargetTopologyAttestationRequest } from "../target/contracts.js";
+import { parseComposedPreparationRequest } from "../target/composedPreparation.js";
+import { parseTargetPublicArtifactSnapshotRequest } from "../target/publicArtifactSnapshot.js";
+import { parseTargetWorldClockRequest } from "../target/worldClock.js";
+import { parseTargetWorldReadinessRequest } from "../target/worldReadiness.js";
+export const DEFAULT_TARGET_REQUEST_FILE_BYTES = 262_144;
+export const MAX_TARGET_REQUEST_FILE_BYTES = 1_048_576;
+export const MAX_TARGET_REQUEST_FILE_PATH_BYTES = 4_096;
+const parseByteLimit = (raw) => {
+    if (!Number.isSafeInteger(raw) || raw < 1
+        || raw > MAX_TARGET_REQUEST_FILE_BYTES) {
+        throw new TypeError("Target request-file byte limit is invalid");
+    }
+    return raw;
+};
+const requireExactAbsolutePath = (raw) => {
+    if (typeof raw !== "string" || raw.length < 1 || raw.includes("\0")
+        || Buffer.byteLength(raw, "utf8") > MAX_TARGET_REQUEST_FILE_PATH_BYTES
+        || !path.isAbsolute(raw) || path.normalize(raw) !== raw) {
+        throw new TypeError("Target request file path is invalid");
+    }
+    return raw;
+};
+const requireObject = (raw) => {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new TypeError("Target request file must contain one JSON object");
+    }
+    return raw;
+};
+const readTargetRequestFileValue = async (filePath, byteLimit) => {
+    const limit = parseByteLimit(byteLimit);
+    const exactPath = requireExactAbsolutePath(filePath);
+    const handle = await open(exactPath, "r");
+    try {
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > limit) {
+            throw new TypeError("Target request file is not a bounded regular file");
+        }
+        const bytes = Buffer.alloc(limit + 1);
+        let offset = 0;
+        while (offset <= limit) {
+            const result = await handle.read(bytes, offset, limit + 1 - offset, offset);
+            if (result.bytesRead === 0)
+                break;
+            offset += result.bytesRead;
+        }
+        if (offset > limit) {
+            throw new TypeError("Target request file exceeds the byte limit");
+        }
+        return requireObject(JSON.parse(bytes.toString("utf8", 0, offset)));
+    }
+    finally {
+        await handle.close();
+    }
+};
+export const readTargetRequestFile = async (filePath, byteLimit = DEFAULT_TARGET_REQUEST_FILE_BYTES) => parseTargetResourceRequest(await readTargetRequestFileValue(filePath, byteLimit));
+export const readComposedPreparationRequestFile = async (filePath, byteLimit = DEFAULT_TARGET_REQUEST_FILE_BYTES) => parseComposedPreparationRequest(await readTargetRequestFileValue(filePath, byteLimit));
+export const readTargetTopologyAttestationRequestFile = async (filePath, byteLimit = DEFAULT_TARGET_REQUEST_FILE_BYTES) => parseTargetTopologyAttestationRequest(await readTargetRequestFileValue(filePath, byteLimit));
+export const readTargetPublicArtifactSnapshotRequestFile = async (filePath, byteLimit = DEFAULT_TARGET_REQUEST_FILE_BYTES) => parseTargetPublicArtifactSnapshotRequest(await readTargetRequestFileValue(filePath, byteLimit));
+export const readTargetWorldReadinessRequestFile = async (filePath, byteLimit = DEFAULT_TARGET_REQUEST_FILE_BYTES) => parseTargetWorldReadinessRequest(await readTargetRequestFileValue(filePath, byteLimit));
+export const readTargetWorldClockRequestFile = async (filePath, byteLimit = DEFAULT_TARGET_REQUEST_FILE_BYTES) => parseTargetWorldClockRequest(await readTargetRequestFileValue(filePath, byteLimit));

package/dist/cli/targetSecretSourceInput.d.ts

@@ -0,0 +1,28 @@
+import { type OpaqueTargetSecretSourceHandle } from "../auth/targetSecretSourceRecordCommon.js";
+import { type TargetSecretSourceGrantCommandInput } from "../auth/targetSecretSourceGrantRecords.js";
+export declare const TARGET_SECRET_SOURCE_REQUEST_VERSION: "spawnfile.auth.target-secret.source-request.v1";
+export declare const TARGET_SECRET_SOURCE_GRANT_REQUEST_VERSION: "spawnfile.auth.target-secret.grant-request.v1";
+export declare const TARGET_SECRET_SOURCE_RECEIPT_VERSION: "spawnfile.auth.target-secret.receipt.v1";
+export declare const MAX_TARGET_SECRET_SOURCE_REQUEST_FILE_BYTES = 65536;
+export type TargetSecretSourceCommandKind = "author" | "grant" | "revoke-grant" | "revoke-version" | "rotate";
+export type TargetSecretSourceRequest = Readonly<{
+    source_handle: OpaqueTargetSecretSourceHandle;
+    version: typeof TARGET_SECRET_SOURCE_REQUEST_VERSION;
+}>;
+export type TargetSecretSourceReceipt = Readonly<{
+    kind: TargetSecretSourceCommandKind;
+    source_handle: OpaqueTargetSecretSourceHandle;
+    version: typeof TARGET_SECRET_SOURCE_RECEIPT_VERSION;
+}>;
+export declare const parseTargetSecretSourceRequestBytes: (bytes: Uint8Array) => TargetSecretSourceRequest;
+export declare const parseTargetSecretSourceGrantRequestBytes: (bytes: Uint8Array) => TargetSecretSourceGrantCommandInput;
+export interface TargetSecretSourceRequestFileOptions {
+    readonly beforeReadForTest?: () => Promise<void> | void;
+}
+export declare const readTargetSecretSourceRequestFile: (filePath: string, options?: TargetSecretSourceRequestFileOptions) => Promise<TargetSecretSourceRequest>;
+export declare const readTargetSecretSourceGrantRequestFile: (filePath: string, options?: TargetSecretSourceRequestFileOptions) => Promise<TargetSecretSourceGrantCommandInput>;
+export declare const createTargetSecretSourceReceiptBytes: (raw: Readonly<{
+    kind: TargetSecretSourceCommandKind;
+    source_handle: unknown;
+}>) => Uint8Array;
+export declare const readBoundedTargetSecretStdin: (input: AsyncIterable<unknown>, maximumBytes: number) => Promise<Uint8Array>;