spawnfile 0.1.12 → 0.1.14

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,53 @@
+import { type DockerArtifactIdentityBinding, type DockerArtifactIdentityStore, type DockerArtifactMapping } 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;
+    /** 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,210 @@
+import { initializeDockerArtifactIdentityStore } from "../target/dockerArtifactsProvider.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 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,
+            ...(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();
+    }
+};

package/dist/cli/targetDefaultConfig.d.ts

@@ -0,0 +1,68 @@
+import { type DockerArtifactMapping } from "../target/dockerArtifactsProvider.js";
+export { resolveTargetDefaultJournalRoot } from "../target/journalRoot.js";
+export declare const TARGET_DEFAULT_CONFIG_ERROR = "Target configuration failed";
+export interface TargetDefaultConfigInputs {
+    /**
+     * Immutable artifact identities are configuration, not a late-bound provider
+     * input.  Keeping them here makes the complete production input JSON data.
+     */
+    readonly artifactMappings?: readonly DockerArtifactMapping[];
+    /**
+     * Optional durable authority for immutable target-local container bundles.
+     * It is deliberately independent from per-run lifecycle and secret roots.
+     */
+    readonly containerBundleStoreRoot?: string;
+    readonly context: string;
+    readonly dockerCommand: string;
+    readonly evidenceDestination: string;
+    readonly helperArtifactManifestDigest?: string;
+    /** Local-Daemon prepared images, admitted only by manifest/bundle/policy. */
+    readonly preparedArtifactMappings?: readonly PreparedArtifactMapping[];
+    readonly timeoutMs: number;
+}
+export interface PreparedArtifactMapping {
+    readonly archive_digest: string;
+    readonly artifact_manifest_digest: string;
+    readonly base_image_config_digest: string;
+    readonly build_policy_digest: string;
+    readonly bundle_digest: string;
+    readonly entrypoint: string;
+    readonly launcher_digest: string;
+    readonly network_alias: string;
+    readonly platform: {
+        readonly architecture: "amd64" | "arm64";
+        readonly os: "linux";
+    };
+    readonly platform_digest: string;
+}
+export interface TargetDefaultConfig {
+    readonly artifactMappings: readonly DockerArtifactMapping[];
+    readonly context: string;
+    readonly dockerCommand: string;
+    readonly evidenceDestination: string;
+    /** Present only when the private evidence-export helper was configured. */
+    readonly helperArtifact?: DockerArtifactMapping;
+    readonly preparedArtifactMappings: readonly PreparedArtifactMapping[];
+    readonly paths: {
+        readonly artifactIdentities: string;
+        readonly attachmentAuthority: string;
+        readonly evidenceExport: string;
+        readonly containerBundles: string;
+        readonly journals: string;
+        readonly root: string;
+        readonly secretAuthority: string;
+        readonly worldAuthority: string;
+    };
+    readonly timeoutMs: number;
+}
+export interface TargetDefaultWorldReadinessConfig {
+    readonly context: string;
+    readonly dockerCommand: string;
+    readonly paths: {
+        readonly worldAuthority: string;
+    };
+    readonly timeoutMs: number;
+}
+export declare const loadTargetDefaultConfig: (raw: TargetDefaultConfigInputs) => Promise<TargetDefaultConfig>;
+/** Resolves only the paths required by a world-readiness query; performs no I/O. */
+export declare const resolveTargetDefaultWorldReadinessConfig: (raw: TargetDefaultConfigInputs) => TargetDefaultWorldReadinessConfig;

package/dist/cli/targetDefaultConfig.js

@@ -0,0 +1,317 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, realpath } from "node:fs/promises";
+import path from "node:path";
+import { types as nodeTypes } from "node:util";
+import { resolveSpawnfileHome } from "../auth/index.js";
+import { parseDockerArtifactMappings } from "../target/dockerArtifactsProvider.js";
+export { resolveTargetDefaultJournalRoot } from "../target/journalRoot.js";
+export const TARGET_DEFAULT_CONFIG_ERROR = "Target configuration failed";
+const MAX_PATH_BYTES = 4_096;
+const CONTEXT = /^[a-z][a-z0-9_-]{0,63}$/u;
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+const COMMAND_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const CHILD_ROOTS = Object.freeze([
+    "journals",
+    "artifact-identities",
+    "secret-authority",
+    "attachment-authority",
+    "world-authority",
+    "evidence-export"
+]);
+const fail = () => { throw new Error(TARGET_DEFAULT_CONFIG_ERROR); };
+const byteLength = (value) => Buffer.byteLength(value, "utf8");
+const descriptorValues = (raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw) || nodeTypes.isProxy(raw)
+        || Object.getPrototypeOf(raw) !== Object.prototype)
+        return fail();
+    const expected = [
+        "artifactMappings", "containerBundleStoreRoot", "context", "dockerCommand", "evidenceDestination",
+        "helperArtifactManifestDigest", "preparedArtifactMappings", "timeoutMs"
+    ];
+    const required = ["context", "dockerCommand", "evidenceDestination", "timeoutMs"];
+    const keys = Reflect.ownKeys(raw);
+    if (keys.some((key) => typeof key !== "string" || !expected.includes(key))
+        || required.some((key) => !keys.includes(key)))
+        return fail();
+    const descriptors = Object.getOwnPropertyDescriptors(raw);
+    if (Object.values(descriptors).some((item) => !item.enumerable || !("value" in item)))
+        return fail();
+    return Object.fromEntries(expected.filter((key) => Object.hasOwn(descriptors, key)).map((key) => [key, descriptors[key].value]));
+};
+const preparedMappings = (raw) => {
+    if (raw === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(raw) || raw.length > 32)
+        return fail();
+    const manifests = new Set();
+    const mappings = raw.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item) || nodeTypes.isProxy(item)
+            || Object.getPrototypeOf(item) !== Object.prototype)
+            return fail();
+        const descriptors = Object.getOwnPropertyDescriptors(item);
+        if (Object.values(descriptors).some((descriptor) => !descriptor.enumerable || !("value" in descriptor)))
+            return fail();
+        const value = Object.fromEntries(Object.entries(descriptors).map(([key, descriptor]) => [key, descriptor.value]));
+        if (Object.keys(value).sort().join("\0") !== "archive_digest\0artifact_manifest_digest\0base_image_config_digest\0build_policy_digest\0bundle_digest\0entrypoint\0launcher_digest\0network_alias\0platform\0platform_digest"
+            || typeof value.artifact_manifest_digest !== "string" || !DIGEST.test(value.artifact_manifest_digest)
+            || typeof value.archive_digest !== "string" || !DIGEST.test(value.archive_digest)
+            || typeof value.base_image_config_digest !== "string" || !DIGEST.test(value.base_image_config_digest)
+            || typeof value.bundle_digest !== "string" || !DIGEST.test(value.bundle_digest)
+            || typeof value.build_policy_digest !== "string" || !DIGEST.test(value.build_policy_digest)
+            || typeof value.launcher_digest !== "string" || !DIGEST.test(value.launcher_digest)
+            || typeof value.platform_digest !== "string" || !DIGEST.test(value.platform_digest)
+            || typeof value.entrypoint !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._/-]{0,239}$/u.test(value.entrypoint)
+            || value.entrypoint.includes("//") || value.entrypoint.split("/").some((part) => part === "." || part === "..")
+            || typeof value.network_alias !== "string" || !/^[a-z][a-z0-9-]{0,62}$/u.test(value.network_alias)
+            || !value.platform || typeof value.platform !== "object" || Array.isArray(value.platform) || nodeTypes.isProxy(value.platform)
+            || Object.getPrototypeOf(value.platform) !== Object.prototype
+            || Object.keys(value.platform).sort().join("\0") !== "architecture\0os"
+            || Object.values(Object.getOwnPropertyDescriptors(value.platform)).some((descriptor) => !descriptor.enumerable || !("value" in descriptor))
+            || value.platform.os !== "linux"
+            || !["amd64", "arm64"].includes(value.platform.architecture)
+            || manifests.has(value.artifact_manifest_digest))
+            return fail();
+        manifests.add(value.artifact_manifest_digest);
+        return Object.freeze({ archive_digest: value.archive_digest, artifact_manifest_digest: value.artifact_manifest_digest,
+            base_image_config_digest: value.base_image_config_digest, build_policy_digest: value.build_policy_digest,
+            bundle_digest: value.bundle_digest, entrypoint: value.entrypoint, launcher_digest: value.launcher_digest,
+            network_alias: value.network_alias, platform: Object.freeze({ ...value.platform }),
+            platform_digest: value.platform_digest });
+    });
+    return Object.freeze(mappings);
+};
+const exactPath = (raw) => {
+    if (typeof raw !== "string" || raw.length < 1 || raw.includes("\0")
+        || byteLength(raw) > MAX_PATH_BYTES || !path.isAbsolute(raw)
+        || path.normalize(raw) !== raw)
+        return fail();
+    return raw;
+};
+const command = (raw) => {
+    if (typeof raw !== "string" || raw.includes("\0") || byteLength(raw) > 1_024)
+        return fail();
+    if (COMMAND_NAME.test(raw))
+        return raw;
+    if (!path.isAbsolute(raw) || path.normalize(raw) !== raw)
+        return fail();
+    return raw;
+};
+const ensureOwnedRoot = async (root) => {
+    let info;
+    try {
+        info = await lstat(root);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return fail();
+        try {
+            await mkdir(root, { mode: 0o700 });
+        }
+        catch {
+            return fail();
+        }
+        try {
+            info = await lstat(root);
+        }
+        catch {
+            return fail();
+        }
+    }
+    const owner = process.getuid?.();
+    if (!info.isDirectory() || info.isSymbolicLink()
+        || owner !== undefined && info.uid !== owner)
+        return fail();
+    let handle;
+    try {
+        handle = await open(root, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+        await handle.chmod(0o700);
+        info = await handle.stat();
+    }
+    catch {
+        return fail();
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    if (!info.isDirectory() || (info.mode & 0o777) !== 0o700
+        || owner !== undefined && info.uid !== owner)
+        return fail();
+    return root;
+};
+const isWithin = (candidate, root) => candidate === root || candidate.startsWith(`${root}${path.sep}`);
+const prepareExplicitContainerBundleRoot = async (raw, lifecycleRoot) => {
+    const requested = exactPath(raw);
+    if (path.parse(requested).root === requested
+        || isWithin(requested, lifecycleRoot)
+        || isWithin(lifecycleRoot, requested))
+        return fail();
+    try {
+        const existing = await lstat(requested);
+        if (!existing.isDirectory() || existing.isSymbolicLink()
+            || await realpath(requested) !== requested)
+            return fail();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return fail();
+        const parent = path.dirname(requested);
+        let parentInfo;
+        try {
+            parentInfo = await lstat(parent);
+        }
+        catch {
+            return fail();
+        }
+        const owner = process.getuid?.();
+        if (!parentInfo.isDirectory() || parentInfo.isSymbolicLink()
+            || owner !== undefined && parentInfo.uid !== owner)
+            return fail();
+        try {
+            if (await realpath(parent) !== parent)
+                return fail();
+        }
+        catch {
+            return fail();
+        }
+    }
+    const root = await ensureOwnedRoot(requested);
+    try {
+        if (await realpath(root) !== root)
+            return fail();
+    }
+    catch {
+        return fail();
+    }
+    return root;
+};
+const prepareRoots = async (containerBundleStoreRoot) => {
+    const home = resolveSpawnfileHome();
+    let homeInfo;
+    try {
+        homeInfo = await lstat(home);
+    }
+    catch {
+        return fail();
+    }
+    if (!homeInfo.isDirectory() || homeInfo.isSymbolicLink())
+        return fail();
+    const owner = process.getuid?.();
+    if (owner !== undefined && homeInfo.uid !== owner)
+        return fail();
+    try {
+        if (await realpath(home) !== home)
+            return fail();
+    }
+    catch {
+        return fail();
+    }
+    const root = await ensureOwnedRoot(path.join(home, "target"));
+    const childRoots = containerBundleStoreRoot === undefined
+        ? [...CHILD_ROOTS, "container-bundles"]
+        : CHILD_ROOTS;
+    const created = await Promise.all(childRoots.map((name) => ensureOwnedRoot(path.join(root, name))));
+    const containerBundles = containerBundleStoreRoot === undefined
+        ? created[6]
+        : await prepareExplicitContainerBundleRoot(containerBundleStoreRoot, root);
+    return Object.freeze({
+        root,
+        journals: created[0],
+        artifactIdentities: created[1],
+        secretAuthority: created[2],
+        attachmentAuthority: created[3],
+        worldAuthority: created[4],
+        evidenceExport: created[5],
+        containerBundles
+    });
+};
+const validateDestination = async (raw) => {
+    const destination = exactPath(raw);
+    const parent = path.dirname(destination);
+    let parentInfo;
+    try {
+        parentInfo = await lstat(parent);
+    }
+    catch {
+        return fail();
+    }
+    const owner = process.getuid?.();
+    if (!parentInfo.isDirectory() || parentInfo.isSymbolicLink()
+        || (parentInfo.mode & 0o777) !== 0o700
+        || owner !== undefined && parentInfo.uid !== owner)
+        return fail();
+    try {
+        if (await realpath(parent) !== parent)
+            return fail();
+    }
+    catch {
+        return fail();
+    }
+    try {
+        const existing = await lstat(destination);
+        if (!existing.isFile() || existing.isSymbolicLink()
+            || owner !== undefined && existing.uid !== owner
+            || (existing.mode & 0o777) !== 0o600)
+            return fail();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return fail();
+    }
+    return destination;
+};
+export const loadTargetDefaultConfig = async (raw) => {
+    const value = descriptorValues(raw);
+    if (typeof value.context !== "string" || !CONTEXT.test(value.context)
+        || !Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1
+        || value.timeoutMs > 120_000
+        || (Object.hasOwn(value, "artifactMappings") !== Object.hasOwn(value, "helperArtifactManifestDigest"))
+        || (Object.hasOwn(value, "helperArtifactManifestDigest") &&
+            (typeof value.helperArtifactManifestDigest !== "string"
+                || !DIGEST.test(value.helperArtifactManifestDigest))))
+        return fail();
+    const dockerCommand = command(value.dockerCommand);
+    let artifactMappings;
+    try {
+        artifactMappings = value.artifactMappings === undefined
+            ? Object.freeze([]) : parseDockerArtifactMappings(value.artifactMappings);
+    }
+    catch {
+        return fail();
+    }
+    const preparedArtifactMappings = preparedMappings(value.preparedArtifactMappings);
+    if (preparedArtifactMappings.some((prepared) => artifactMappings.some((artifact) => artifact.artifact_manifest_digest === prepared.artifact_manifest_digest)))
+        return fail();
+    const evidenceDestination = await validateDestination(value.evidenceDestination);
+    const matches = value.helperArtifactManifestDigest === undefined ? [] : artifactMappings.filter((mapping) => mapping.artifact_manifest_digest === value.helperArtifactManifestDigest);
+    if (value.helperArtifactManifestDigest !== undefined && matches.length !== 1)
+        return fail();
+    const paths = await prepareRoots(value.containerBundleStoreRoot);
+    const config = {
+        artifactMappings,
+        context: value.context,
+        dockerCommand,
+        evidenceDestination,
+        ...(matches.length === 1 ? { helperArtifact: matches[0] } : {}),
+        preparedArtifactMappings,
+        paths,
+        timeoutMs: value.timeoutMs
+    };
+    return Object.freeze(config);
+};
+/** Resolves only the paths required by a world-readiness query; performs no I/O. */
+export const resolveTargetDefaultWorldReadinessConfig = (raw) => {
+    const value = descriptorValues(raw);
+    if (typeof value.context !== "string" || !CONTEXT.test(value.context)
+        || !Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1
+        || value.timeoutMs > 120_000)
+        return fail();
+    const home = resolveSpawnfileHome();
+    return Object.freeze({
+        context: value.context,
+        dockerCommand: command(value.dockerCommand),
+        paths: Object.freeze({
+            worldAuthority: path.join(home, "target", "world-authority")
+        }),
+        timeoutMs: value.timeoutMs
+    });
+};