spawnfile 0.1.13 → 0.1.17

package/dist/cli/targetConfigResolverCommand.js

@@ -0,0 +1,43 @@
+import { errorExitCode, SpawnfileError } from "../shared/index.js";
+import { createTargetConfigResolutionBytes, resolveTargetConfig, } from "./targetConfigResolver.js";
+import { formatCaughtTargetCliError } from "./targetReceiptOutput.js";
+export const TARGET_CONFIG_RESOLVER_COMMAND = "resolve_config";
+const timeout = (value) => {
+    if (!/^[1-9][0-9]{0,5}$/u.test(value)) {
+        throw new SpawnfileError("validation_error", "Target timeout must be an integer from 1 to 120000 milliseconds");
+    }
+    return Number(value);
+};
+export const registerTargetConfigResolverCommand = (target, streams, setExitCode, resolver = resolveTargetConfig) => {
+    target.command(TARGET_CONFIG_RESOLVER_COMMAND)
+        .description("Resolve one explicit Docker context and base image into target configuration")
+        .option("--context <name>", "Explicit named Docker context; omitted accepts only the current local context")
+        .option("--base-image <reference>", "Portable base image reference; defaults to Spawnfile's standard world base")
+        .requiredOption("--evidence-destination <path>", "Absolute private evidence archive destination")
+        .option("--docker-command <command>", "Docker-compatible command", "docker")
+        .option("--prepare-evidence-helper", "Prepare the package-owned evidence helper on an explicitly selected local Docker context")
+        .option("--timeout-ms <milliseconds>", "Bounded Docker command timeout", "10000")
+        .option("--prepared-plan <path>", "Absolute private composed target plan containing one prepared artifact mapping")
+        .option("--pull", "Explicitly pull the base image before inspection")
+        .option("--allow-remote-pull", "Allow --pull to mutate the explicitly named remote Docker context")
+        .action(async (options) => {
+        try {
+            const resolution = await resolver({
+                allowRemotePull: options.allowRemotePull,
+                baseImage: options.baseImage,
+                context: options.context,
+                dockerCommand: options.dockerCommand,
+                evidenceDestination: options.evidenceDestination,
+                prepareEvidenceHelper: options.prepareEvidenceHelper,
+                preparedPlanPath: options.preparedPlan,
+                pull: options.pull,
+                timeoutMs: timeout(options.timeoutMs),
+            });
+            streams.stdout(createTargetConfigResolutionBytes(resolution));
+        }
+        catch (error) {
+            streams.stderr(formatCaughtTargetCliError(error, "Target configuration resolution failed"));
+            setExitCode(errorExitCode(error));
+        }
+    });
+};

package/dist/cli/targetConfigResolverContracts.d.ts

@@ -0,0 +1,56 @@
+import type { PreparedEvidenceHelperReceipt, PrepareEvidenceHelperInput } from "../evidenceExportHelper/index.js";
+import type { DockerTargetExecFile } from "../target/dockerTarget.js";
+import type { PreparedArtifactMapping } from "./targetDefaultConfig.js";
+import { TARGET_DEFAULT_CONFIG_STDIN_VERSION } from "./targetDefaultConfigStdin.js";
+export declare const TARGET_CONFIG_RESOLUTION_VERSION: "spawnfile.target-config-resolution.v1";
+export declare const TARGET_CONFIG_DIGEST_VERSION: "spawnfile.target-config-digest.v1";
+/** Exact version for the strict `resolve_config --prepared-plan` document. */
+export declare const TARGET_CONFIG_PREPARED_PLAN_ABI_VERSION: "spawnfile.target-config-prepared-plan.v1";
+export declare const STANDARD_WORLD_BASE_IMAGE = "node:22-bookworm-slim";
+export interface ResolveTargetConfigInput {
+    readonly allowRemotePull?: boolean;
+    readonly baseImage?: string;
+    readonly context?: string;
+    readonly dockerCommand?: string;
+    readonly evidenceDestination: string;
+    readonly prepareEvidenceHelper?: boolean;
+    readonly execFile?: DockerTargetExecFile;
+    readonly preparedPlanPath?: string;
+    readonly pull?: boolean;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+export interface TargetConfigResolution {
+    readonly base_image: {
+        readonly config_digest: `sha256:${string}`;
+        readonly reference: string;
+    };
+    readonly endpoint: {
+        readonly class: "local" | "remote";
+        readonly transport: "fd" | "http" | "https" | "npipe" | "ssh" | "tcp" | "unix";
+    };
+    readonly context_selection: "auto-local" | "explicit";
+    readonly platform: {
+        readonly architecture: "amd64" | "arm64";
+        readonly os: "linux";
+    };
+    readonly prepared_evidence_helper?: PreparedEvidenceHelperReceipt;
+    readonly target_config: {
+        readonly context: string;
+        readonly dockerCommand: string;
+        readonly evidenceDestination: string;
+        readonly evidenceHelperBaseImage?: string;
+        readonly preparedEvidenceHelper?: PreparedEvidenceHelperReceipt;
+        readonly preparedArtifactMappings?: readonly PreparedArtifactMapping[];
+        readonly timeoutMs: number;
+        readonly version: typeof TARGET_DEFAULT_CONFIG_STDIN_VERSION;
+    };
+    readonly target_config_digest: `sha256:${string}`;
+    readonly version: typeof TARGET_CONFIG_RESOLUTION_VERSION;
+}
+export interface ResolveTargetConfigDependencies {
+    readonly prepareEvidenceExportHelper?: (input: PrepareEvidenceHelperInput) => Promise<PreparedEvidenceHelperReceipt>;
+}
+export declare const createCanonicalTargetConfigBytes: (targetConfig: TargetConfigResolution["target_config"]) => string;
+export declare const createTargetConfigDigest: (targetConfig: TargetConfigResolution["target_config"]) => `sha256:${string}`;
+export declare const createTargetConfigResolutionBytes: (resolution: TargetConfigResolution) => string;

package/dist/cli/targetConfigResolverContracts.js

@@ -0,0 +1,30 @@
+import { createHash } from "node:crypto";
+import { TARGET_CONFIG_PREPARED_PLAN_VERSION } from "./targetConfigPreparedPlan.js";
+export const TARGET_CONFIG_RESOLUTION_VERSION = "spawnfile.target-config-resolution.v1";
+export const TARGET_CONFIG_DIGEST_VERSION = "spawnfile.target-config-digest.v1";
+/** Exact version for the strict `resolve_config --prepared-plan` document. */
+export const TARGET_CONFIG_PREPARED_PLAN_ABI_VERSION = TARGET_CONFIG_PREPARED_PLAN_VERSION;
+export const STANDARD_WORLD_BASE_IMAGE = "node:22-bookworm-slim";
+const canonicalJson = (value) => {
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new TypeError("Target configuration is not JSON");
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value !== "object")
+        throw new TypeError("Target configuration is not JSON");
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+};
+export const createCanonicalTargetConfigBytes = (targetConfig) => canonicalJson(targetConfig);
+export const createTargetConfigDigest = (targetConfig) => `sha256:${createHash("sha256")
+    .update(`${TARGET_CONFIG_DIGEST_VERSION}\0`, "utf8")
+    .update(createCanonicalTargetConfigBytes(targetConfig), "utf8")
+    .digest("hex")}`;
+export const createTargetConfigResolutionBytes = (resolution) => JSON.stringify(resolution);

package/dist/cli/targetConfigResolverDocker.d.ts

@@ -0,0 +1,4 @@
+import type { DockerTargetExecFile } from "../target/dockerTarget.js";
+export declare const exactJson: (source: string, keys: readonly string[], failureMessage: string) => Record<string, unknown>;
+export declare const executeDocker: (execFile: DockerTargetExecFile, command: string, context: string, args: string[], timeout: number, signal: AbortSignal | undefined, failureMessage: string) => Promise<string>;
+export declare const resolveCurrentDockerContext: (execFile: DockerTargetExecFile, dockerCommand: string, timeoutMs: number, signal: AbortSignal | undefined) => Promise<string>;

package/dist/cli/targetConfigResolverDocker.js

@@ -0,0 +1,47 @@
+import { SpawnfileError } from "../shared/index.js";
+import { parseContext, runtimeFailure } from "./targetConfigResolverValidation.js";
+const MAX_DOCKER_OUTPUT_BYTES = 64 * 1_024;
+export const exactJson = (source, keys, failureMessage) => {
+    if (Buffer.byteLength(source, "utf8") > MAX_DOCKER_OUTPUT_BYTES) {
+        return runtimeFailure(failureMessage);
+    }
+    try {
+        const parsed = JSON.parse(source);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)
+            || Object.keys(parsed).sort().join("\0") !== [...keys].sort().join("\0")) {
+            return runtimeFailure(failureMessage);
+        }
+        return parsed;
+    }
+    catch {
+        return runtimeFailure(failureMessage);
+    }
+};
+export const executeDocker = async (execFile, command, context, args, timeout, signal, failureMessage) => {
+    try {
+        const result = await execFile(command, ["--context", context, ...args], { signal, timeout });
+        if (Buffer.byteLength(result.stdout, "utf8") > MAX_DOCKER_OUTPUT_BYTES) {
+            return runtimeFailure(failureMessage);
+        }
+        return result.stdout;
+    }
+    catch {
+        return runtimeFailure(failureMessage);
+    }
+};
+export const resolveCurrentDockerContext = async (execFile, dockerCommand, timeoutMs, signal) => {
+    try {
+        const result = await execFile(dockerCommand, ["context", "show"], {
+            signal, timeout: timeoutMs,
+        });
+        if (Buffer.byteLength(result.stdout, "utf8") > 4_096) {
+            return runtimeFailure("Current Docker context is invalid");
+        }
+        return parseContext(result.stdout.trim());
+    }
+    catch (error) {
+        if (error instanceof SpawnfileError)
+            throw error;
+        return runtimeFailure("Unable to resolve the current Docker context");
+    }
+};

package/dist/cli/targetConfigResolverValidation.d.ts

@@ -0,0 +1,10 @@
+import type { TargetConfigResolution } from "./targetConfigResolverContracts.js";
+export declare const validationFailure: (message: string) => never;
+export declare const runtimeFailure: (message: string) => never;
+export declare const parseContext: (value: unknown) => string;
+export declare const parseDockerCommand: (value: unknown) => string;
+export declare const parseTimeout: (value: unknown) => number;
+export declare const parseBaseImage: (value: unknown) => string;
+export declare const validateEvidenceDestination: (value: unknown) => Promise<string>;
+export declare const classifyEndpoint: (endpoint: string) => TargetConfigResolution["endpoint"];
+export declare const normalizeArchitecture: (value: unknown) => "amd64" | "arm64";

package/dist/cli/targetConfigResolverValidation.js

@@ -0,0 +1,94 @@
+import { lstat, realpath } from "node:fs/promises";
+import path from "node:path";
+import { SpawnfileError } from "../shared/index.js";
+import { parseDockerBaseImageReference } from "../target/dockerBaseImage.js";
+const CONTEXT = /^[a-z][a-z0-9_-]{0,63}$/u;
+const COMMAND_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const MAX_PATH_BYTES = 4_096;
+export const validationFailure = (message) => {
+    throw new SpawnfileError("validation_error", message);
+};
+export const runtimeFailure = (message) => {
+    throw new SpawnfileError("runtime_error", message);
+};
+export const parseContext = (value) => typeof value === "string" && CONTEXT.test(value)
+    ? value
+    : validationFailure("Docker context must be an explicit bounded context name");
+export const parseDockerCommand = (value) => {
+    if (typeof value !== "string" || value.includes("\0")
+        || Buffer.byteLength(value, "utf8") > 1_024) {
+        return validationFailure("Docker command is invalid");
+    }
+    if (COMMAND_NAME.test(value))
+        return value;
+    if (path.isAbsolute(value) && path.normalize(value) === value)
+        return value;
+    return validationFailure("Docker command is invalid");
+};
+export const parseTimeout = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 120_000
+    ? value
+    : validationFailure("Target timeout must be an integer from 1 to 120000 milliseconds");
+export const parseBaseImage = (value) => parseDockerBaseImageReference(value)
+    ?? validationFailure("Base image must be an explicit portable image reference");
+export const validateEvidenceDestination = async (value) => {
+    if (typeof value !== "string" || value.includes("\0")
+        || Buffer.byteLength(value, "utf8") > MAX_PATH_BYTES
+        || !path.isAbsolute(value) || path.normalize(value) !== value) {
+        return validationFailure("Evidence destination must be an absolute normalized path");
+    }
+    const parent = path.dirname(value);
+    const owner = process.getuid?.();
+    try {
+        const parentInfo = await lstat(parent);
+        if (!parentInfo.isDirectory() || parentInfo.isSymbolicLink()
+            || (parentInfo.mode & 0o777) !== 0o700
+            || owner !== undefined && parentInfo.uid !== owner
+            || await realpath(parent) !== parent) {
+            return validationFailure("Evidence destination parent must be a private physical directory");
+        }
+        try {
+            const destinationInfo = await lstat(value);
+            if (!destinationInfo.isFile() || destinationInfo.isSymbolicLink()
+                || (destinationInfo.mode & 0o777) !== 0o600
+                || owner !== undefined && destinationInfo.uid !== owner) {
+                return validationFailure("Existing evidence destination must be a private regular file");
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    catch (error) {
+        if (error instanceof SpawnfileError)
+            throw error;
+        return validationFailure("Evidence destination parent is unavailable");
+    }
+    return value;
+};
+export const classifyEndpoint = (endpoint) => {
+    if (Buffer.byteLength(endpoint, "utf8") > 4_096 || /\s/u.test(endpoint)) {
+        return runtimeFailure("Docker context returned an invalid endpoint");
+    }
+    const match = /^(fd|http|https|npipe|ssh|tcp|unix):\/\/.+$/u.exec(endpoint);
+    if (!match)
+        return runtimeFailure("Docker context returned an unsupported endpoint transport");
+    const transport = match[1];
+    return Object.freeze({
+        class: transport === "fd" || transport === "npipe" || transport === "unix"
+            ? "local" : "remote",
+        transport,
+    });
+};
+export const normalizeArchitecture = (value) => {
+    if (typeof value !== "string")
+        return runtimeFailure("Docker architecture is invalid");
+    switch (value.trim()) {
+        case "amd64":
+        case "x64":
+        case "x86_64": return "amd64";
+        case "aarch64":
+        case "arm64": return "arm64";
+        default: return runtimeFailure("Docker architecture is unsupported");
+    }
+};

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;

package/dist/cli/targetDefaultArtifactAuthority.js

@@ -0,0 +1,28 @@
+const fail = () => { throw new Error("Target authority initialization failed"); };
+export const completedTargetArtifacts = async (journal, identities) => {
+    const snapshot = await journal.read();
+    const bindings = [];
+    for (const entry of snapshot.entries) {
+        if (entry.operation !== "resolve_world_artifact" || entry.state !== "completed")
+            continue;
+        const completed = await journal.resolveCompletedReceipt({ operationHandle: entry.operation_handle, requestDigest: entry.request_digest });
+        if (!completed || completed.receipt.operation !== "resolve_world_artifact" || completed.receipt.operation_handle !== entry.operation_handle
+            || completed.receipt.request_digest !== entry.request_digest || completed.receipt.result_handle === null)
+            return fail();
+        const binding = await identities.resolveOperation(entry.operation_handle, entry.request_digest);
+        if (!binding || binding.operationHandle !== entry.operation_handle || binding.requestDigest !== entry.request_digest
+            || binding.resultHandle !== completed.receipt.result_handle || binding.selectedTargetHandle !== snapshot.selected_target.handle)
+            return fail();
+        bindings.push(binding);
+    }
+    return Object.freeze(bindings);
+};
+export const exactTargetArtifactMapping = (config, binding) => {
+    if (binding.identityKind !== "oci_image_manifest")
+        return fail();
+    const matches = config.artifactMappings.filter((mapping) => mapping.artifact_manifest_digest === binding.artifactManifestDigest
+        && mapping.image_digest === binding.imageDigest && mapping.image_reference === binding.imageReference);
+    if (matches.length !== 1)
+        return fail();
+    return matches[0];
+};

package/dist/cli/targetDefaultAuthorities.d.ts

@@ -0,0 +1,55 @@
+import { type DockerArtifactIdentityBinding, type DockerArtifactIdentityStore, type DockerArtifactMapping } from "../target/dockerArtifactsProvider.js";
+import type { DockerArtifactExecutor } from "../target/dockerArtifactsProvider.js";
+import { type DockerTargetExecutors } from "../target/dockerCommandExecutor.js";
+import { type TargetSecretVersionAuthorityStore } from "../target/dockerSecretsAuthority.js";
+import { type WorldServiceResolver } from "../target/dockerWorldServiceAuthority.js";
+import { type WorldServiceAuthorityStore } from "../target/dockerWorldServiceStore.js";
+import { type EvidenceExportAuthorityStore } from "../target/evidenceExportStore.js";
+import { type OrganizationAttachmentAuthorityStore } from "../target/organizationAttachmentStore.js";
+import { type TargetTopologyAttestor } from "../target/topologyAttestation.js";
+import type { TargetSecretSourceResolver } from "../target/dockerSecrets.js";
+import type { OrganizationAttachmentResolver } from "../target/organizationAttachmentAuthority.js";
+import type { TargetDefaultConfig } from "./targetDefaultConfig.js";
+import { type TargetJournalResolver } from "./targetDefaultJournalAuthority.js";
+export { TARGET_DEFAULT_AUTHORITIES_ERROR, type TargetJournalResolver, type TargetMutationAuthority } from "./targetDefaultJournalAuthority.js";
+export interface HelperArtifactAuthority {
+    readonly artifactIdentity: DockerArtifactIdentityBinding;
+    readonly bundle: {
+        readonly operation_handle: DockerArtifactIdentityBinding["operationHandle"];
+        readonly request_digest: string;
+        readonly result_handle: DockerArtifactIdentityBinding["resultHandle"];
+    };
+    readonly mapping: DockerArtifactMapping;
+}
+export interface HelperArtifactResolver {
+    resolve(input: {
+        readonly context: unknown;
+        readonly request: unknown;
+    }): Promise<HelperArtifactAuthority>;
+}
+export interface TargetDefaultAuthorities {
+    readonly artifactIdentityStore: DockerArtifactIdentityStore;
+    readonly attachmentAuthorityStore: OrganizationAttachmentAuthorityStore;
+    readonly evidenceExportAuthorityStore: EvidenceExportAuthorityStore;
+    readonly executors: DockerTargetExecutors;
+    readonly handoffResolver: OrganizationAttachmentResolver;
+    readonly helperExecutor: DockerArtifactExecutor;
+    /** Omitted when this invocation cannot export evidence. */
+    readonly helperArtifactResolver?: HelperArtifactResolver;
+    readonly journals: TargetJournalResolver;
+    readonly secretAuthorityStore: TargetSecretVersionAuthorityStore;
+    readonly secretResolver: TargetSecretSourceResolver;
+    readonly topologyAttestor: TargetTopologyAttestor;
+    readonly worldAuthorityStore: WorldServiceAuthorityStore;
+    readonly worldResolver: WorldServiceResolver;
+}
+/**
+ * The production authority graph owns B114 worker clients and directory file
+ * handles.  It is therefore deliberately a session, rather than an ambient
+ * process singleton: the caller that starts the graph must close it.
+ */
+export interface TargetDefaultAuthoritySession {
+    readonly authorities: TargetDefaultAuthorities;
+    dispose(): Promise<void>;
+}
+export declare const initializeTargetDefaultAuthoritySession: (config: TargetDefaultConfig) => Promise<TargetDefaultAuthoritySession>;

package/dist/cli/targetDefaultAuthorities.js

@@ -0,0 +1,213 @@
+import { initializeDockerArtifactIdentityStore } from "../target/dockerArtifactsProvider.js";
+import { createPreparedEvidenceHelperExecutor } from "../evidenceExportHelper/index.js";
+import { createDockerTargetExecutors } from "../target/dockerCommandExecutor.js";
+import { initializeTargetSecretVersionAuthorityStore } from "../target/dockerSecretsAuthority.js";
+import { parseWorldServiceAuthorization, parseWorldServiceResolution } from "../target/dockerWorldServiceAuthority.js";
+import { initializeWorldServiceAuthorityStore } from "../target/dockerWorldServiceStore.js";
+import { initializeEvidenceExportAuthorityStore } from "../target/evidenceExportStore.js";
+import { initializeOrganizationAttachmentAuthorityStore } from "../target/organizationAttachmentStore.js";
+import { createTargetTopologyAttestor } from "../target/topologyAttestation.js";
+import { initializeTargetSecretSourceResolver } from "../auth/targetSecretSourceResolver.js";
+import { initializeOrganizationHandoffAuthorityStore } from "../deployment/organizationHandoffAuthorityStore.js";
+import { completedTargetArtifacts, exactTargetArtifactMapping } from "./targetDefaultArtifactAuthority.js";
+import { targetDefaultEnvelope as envelope } from "./targetDefaultEnvelope.js";
+import { createDockerTargetLocalBundleBuilder } from "../target/dockerContainerBundleBuilder.js";
+import { attestPreparedArtifactIdentity } from "../target/dockerPreparedArtifact.js";
+import { initializeFilesystemTargetLocalBundleStore } from "../target/containerBundleFilesystemStore.js";
+import { createTargetJournalAccess, TARGET_DEFAULT_AUTHORITIES_ERROR } from "./targetDefaultJournalAuthority.js";
+export { TARGET_DEFAULT_AUTHORITIES_ERROR } from "./targetDefaultJournalAuthority.js";
+const fail = () => { throw new Error(TARGET_DEFAULT_AUTHORITIES_ERROR); };
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+export const initializeTargetDefaultAuthoritySession = async (config) => {
+    let handoffAuthority;
+    try {
+        const journalAccess = createTargetJournalAccess(config);
+        const journals = journalAccess.resolver;
+        const [artifactIdentityStore, secretAuthorityStore, attachmentAuthorityStore, worldAuthorityStore, evidenceExportAuthorityStore, secretResolver] = await Promise.all([
+            initializeDockerArtifactIdentityStore(config.paths.artifactIdentities),
+            initializeTargetSecretVersionAuthorityStore(config.paths.secretAuthority),
+            initializeOrganizationAttachmentAuthorityStore(config.paths.attachmentAuthority),
+            initializeWorldServiceAuthorityStore(config.paths.worldAuthority),
+            initializeEvidenceExportAuthorityStore(config.paths.evidenceExport),
+            // Production always resolves grants from the B113 host-local authority
+            // store.  It deliberately has no configuration or ambient override seam.
+            initializeTargetSecretSourceResolver()
+        ]);
+        // The B114 store owns its anchored filesystem workers.  Keep the store
+        // alive through its resolver rather than accepting a caller-provided one.
+        handoffAuthority = await initializeOrganizationHandoffAuthorityStore();
+        const handoffResolver = handoffAuthority.resolver;
+        const executors = createDockerTargetExecutors({ dockerCommand: config.dockerCommand });
+        const helperExecutor = createPreparedEvidenceHelperExecutor(config.dockerCommand);
+        const preparedBuilder = createDockerTargetLocalBundleBuilder({ context: config.context,
+            executor: executors.artifact, timeoutMs: config.timeoutMs });
+        const preparedStore = await initializeFilesystemTargetLocalBundleStore(config.paths.containerBundles);
+        const worldResolver = Object.freeze({
+            resolve: async (raw) => {
+                const input = envelope(raw, ["authorization"], ["signal"]);
+                let authorization;
+                try {
+                    authorization = parseWorldServiceAuthorization(input.authorization);
+                }
+                catch {
+                    return fail();
+                }
+                const journal = await journalAccess.resolveIdentity({
+                    context: config.context,
+                    descriptorDigest: authorization.descriptor_digest,
+                    runId: authorization.run_id,
+                    selectedTarget: authorization.selected_target
+                });
+                const bindings = (await completedTargetArtifacts(journal, artifactIdentityStore))
+                    .filter((binding) => binding.resultHandle === authorization.world_artifact_handle);
+                if (bindings.length !== 1)
+                    return fail();
+                const binding = bindings[0];
+                try {
+                    let artifact;
+                    if (binding.identityKind === "oci_image_manifest") {
+                        artifact = {
+                            artifact_manifest_digest: binding.artifactManifestDigest,
+                            identity_kind: binding.identityKind,
+                            image_digest: binding.imageDigest,
+                            image_reference: binding.imageReference,
+                            operation_handle: binding.operationHandle,
+                            request_digest: binding.requestDigest,
+                            result_handle: binding.resultHandle
+                        };
+                    }
+                    else if (binding.identityKind === "docker_image_config_digest") {
+                        const prepared = await preparedStore.resolve({
+                            operation_handle: binding.preparedOperationHandle,
+                            request_digest: binding.preparedRequestDigest
+                        });
+                        if (!prepared || !same(prepared, {
+                            archive_digest: binding.archiveDigest,
+                            artifact_digest: binding.artifactManifestDigest,
+                            base_image_config_digest: binding.baseImageConfigDigest,
+                            build_policy_digest: binding.buildPolicyDigest,
+                            bundle_digest: binding.bundleDigest,
+                            config_id: binding.configId,
+                            daemon_epoch: binding.daemonEpoch,
+                            entrypoint: binding.entrypoint,
+                            gc_tag: binding.gcTag,
+                            identity_kind: binding.identityKind,
+                            launcher_digest: binding.launcherDigest,
+                            network_alias: binding.networkAlias,
+                            operation_handle: binding.preparedOperationHandle,
+                            platform: binding.platform,
+                            platform_digest: binding.platformDigest,
+                            request_digest: binding.preparedRequestDigest,
+                            selected_target: authorization.selected_target
+                        }))
+                            return fail();
+                        await attestPreparedArtifactIdentity(preparedBuilder, binding, prepared, authorization.selected_target);
+                        artifact = {
+                            archive_digest: binding.archiveDigest,
+                            artifact_manifest_digest: binding.artifactManifestDigest,
+                            base_image_config_digest: binding.baseImageConfigDigest,
+                            build_policy_digest: binding.buildPolicyDigest,
+                            bundle_digest: binding.bundleDigest,
+                            config_id: binding.configId,
+                            daemon_epoch: binding.daemonEpoch,
+                            entrypoint: binding.entrypoint,
+                            gc_tag: binding.gcTag,
+                            identity_kind: binding.identityKind,
+                            image_digest: binding.configId,
+                            image_reference: binding.configId,
+                            launcher_digest: binding.launcherDigest,
+                            network_alias: binding.networkAlias,
+                            operation_handle: binding.operationHandle,
+                            platform: binding.platform,
+                            platform_digest: binding.platformDigest,
+                            prepared_operation_handle: binding.preparedOperationHandle,
+                            prepared_request_digest: binding.preparedRequestDigest,
+                            request_digest: binding.requestDigest,
+                            result_handle: binding.resultHandle
+                        };
+                    }
+                    else
+                        return fail();
+                    return parseWorldServiceResolution({
+                        artifact,
+                        authorization
+                    });
+                }
+                catch {
+                    return fail();
+                }
+            }
+        });
+        const helperArtifactResolver = config.helperArtifact
+            ? Object.freeze({
+                resolve: async (raw) => {
+                    const input = envelope(raw, ["context", "request"]);
+                    const authority = await journals.resolve({
+                        context: input.context,
+                        request: input.request
+                    });
+                    const bindings = (await completedTargetArtifacts(authority.journal, artifactIdentityStore))
+                        .filter((binding) => binding.identityKind === "oci_image_manifest"
+                        && binding.artifactManifestDigest === config.helperArtifact.artifact_manifest_digest);
+                    if (bindings.length !== 1)
+                        return fail();
+                    const artifactIdentity = bindings[0];
+                    if (artifactIdentity.identityKind !== "oci_image_manifest")
+                        return fail();
+                    const mapping = exactTargetArtifactMapping(config, artifactIdentity);
+                    return Object.freeze({
+                        artifactIdentity,
+                        bundle: Object.freeze({
+                            operation_handle: artifactIdentity.operationHandle,
+                            request_digest: artifactIdentity.requestDigest,
+                            result_handle: artifactIdentity.resultHandle
+                        }),
+                        mapping
+                    });
+                }
+            }) : undefined;
+        const topologyAttestor = createTargetTopologyAttestor({
+            attachmentExecutor: executors.attachment,
+            attachmentStore: attachmentAuthorityStore,
+            context: config.context,
+            resolveJournal: async (input) => journalAccess.resolveExistingIdentity({
+                context: config.context,
+                descriptorDigest: input.descriptorDigest,
+                runId: input.runId,
+                selectedTarget: input.selectedTarget
+            }),
+            resourceExecutor: executors.resource,
+            timeoutMs: config.timeoutMs,
+            worldExecutor: executors.world,
+            worldStore: worldAuthorityStore
+        });
+        const authorities = Object.freeze({
+            artifactIdentityStore,
+            attachmentAuthorityStore,
+            evidenceExportAuthorityStore,
+            executors,
+            handoffResolver,
+            helperExecutor,
+            ...(helperArtifactResolver ? { helperArtifactResolver } : {}),
+            journals,
+            secretAuthorityStore,
+            secretResolver,
+            topologyAttestor,
+            worldAuthorityStore,
+            worldResolver
+        });
+        let disposal;
+        const dispose = async () => {
+            disposal ??= handoffAuthority.dispose();
+            await disposal;
+        };
+        return Object.freeze({ authorities, dispose });
+    }
+    catch {
+        // Do not orphan B114's worker clients if a later authority fails to
+        // initialize.  A successfully-created session transfers that ownership
+        // to its explicit disposer instead.
+        await handoffAuthority?.dispose().catch(() => undefined);
+        return fail();
+    }
+};