@empire-builder-kit/nx 1.0.0-beta.9 → 1.0.0-rc.2

package/src/blueprints/external-sandbox.js

@@ -0,0 +1,1182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTERNAL_BLUEPRINT_SANDBOX_FLAGS = exports.EXTERNAL_BLUEPRINT_CONTAINER_AUTO_REMOVE = exports.EXTERNAL_BLUEPRINT_SANDBOX_IMAGE = void 0;
+exports.externalBlueprintSandboxUserFlag = externalBlueprintSandboxUserFlag;
+exports.externalBlueprintSandboxTimeoutCommand = externalBlueprintSandboxTimeoutCommand;
+exports.stageExternalBlueprintClosure = stageExternalBlueprintClosure;
+exports.externalBlueprintDockerEnvironment = externalBlueprintDockerEnvironment;
+exports.assertExternalBlueprintDockerSecurityOptions = assertExternalBlueprintDockerSecurityOptions;
+exports.proveExternalBlueprintContainerAbsent = proveExternalBlueprintContainerAbsent;
+exports.executeCreatedExternalBlueprintContainer = executeCreatedExternalBlueprintContainer;
+exports.runExternalBlueprintSandbox = runExternalBlueprintSandbox;
+const node_buffer_1 = require("node:buffer");
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const yaml_1 = require("yaml");
+const container_images_js_1 = require("../container-images.js");
+const DIAGNOSTIC_LIMIT_BYTES = 64 * 1024;
+const RESULT_LIMIT_BYTES = 16 * 1024 * 1024;
+const TERMINATION_TIMEOUT_MS = 5_000;
+const IMAGE_PULL_TIMEOUT_MS = 5 * 60 * 1_000;
+const CLEANUP_RETRY_DELAY_MS = 100;
+const MAX_CLOSURE_PACKAGES = 2_048;
+const MAX_CLOSURE_FILES = 200_000;
+const MAX_CLOSURE_DIRECTORIES = 200_000;
+const MAX_CLOSURE_DEPTH = 128;
+const MAX_CLOSURE_BYTES = 1024 * 1024 * 1024;
+const MAX_PACKAGE_MANIFEST_BYTES = 1024 * 1024;
+const MAX_LOCKFILE_BYTES = 32 * 1024 * 1024;
+const REGISTRY_INTEGRITY = /^sha512-[A-Za-z0-9+/]{86}==$/u;
+const CONTAINER_PROXY_ENVIRONMENT = [
+    'ALL_PROXY',
+    'FTP_PROXY',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'NO_PROXY',
+    'all_proxy',
+    'ftp_proxy',
+    'http_proxy',
+    'https_proxy',
+    'no_proxy',
+];
+const INSTALL_BUILD_DEPENDENCIES = new Set([
+    '@mapbox/node-pre-gyp',
+    'cmake-js',
+    'node-gyp',
+    'node-gyp-build',
+    'node-gyp-build-optional-packages',
+    'node-pre-gyp',
+    'prebuild-install',
+]);
+let sandboxImageReady = false;
+exports.EXTERNAL_BLUEPRINT_SANDBOX_IMAGE = container_images_js_1.EBK_NODE_22_ALPINE_IMAGE;
+exports.EXTERNAL_BLUEPRINT_CONTAINER_AUTO_REMOVE = '--rm';
+exports.EXTERNAL_BLUEPRINT_SANDBOX_FLAGS = [
+    '--network=none',
+    '--read-only',
+    '--cap-drop=ALL',
+    '--security-opt=no-new-privileges',
+    '--pids-limit=64',
+    '--memory=256m',
+    '--memory-swap=256m',
+    '--cpus=1',
+    '--ulimit=nofile=256:256',
+    '--tmpfs=/tmp:rw,noexec,nosuid,nodev,size=16m,mode=1777',
+];
+const sandboxRunner = `
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+const protocolWrite = process.stdout.write.bind(process.stdout);
+const diagnosticWrite = process.stderr.write.bind(process.stderr);
+const flush = (write) =>
+  new Promise((resolve, reject) => {
+    write('', (error) => (error ? reject(error) : resolve()));
+  });
+process.stdout.write = diagnosticWrite;
+try {
+  const module = await import(process.argv[1]);
+  const generator = module.default ?? module.generate;
+  if (typeof generator !== 'function') {
+    throw new Error('Blueprint must export a default function or named generate function.');
+  }
+  const result = JSON.stringify(await generator(JSON.parse(input)));
+  if (Buffer.byteLength(result, 'utf8') > ${RESULT_LIMIT_BYTES}) {
+    throw new Error('Blueprint result exceeds the fixed protocol byte bound.');
+  }
+  await flush(diagnosticWrite);
+  protocolWrite(result);
+  await flush(protocolWrite);
+  process.exit(0);
+} catch (error) {
+  const diagnostic =
+    error instanceof Error ? error.stack ?? error.message : String(error);
+  diagnosticWrite(diagnostic.slice(0, 4096));
+  await flush(diagnosticWrite);
+  process.exit(1);
+}
+`;
+function isContainedPath(root, candidate) {
+    const fromRoot = (0, node_path_1.relative)(root, candidate);
+    return !(fromRoot === '..' ||
+        fromRoot.startsWith(`..${node_path_1.sep}`) ||
+        (0, node_path_1.isAbsolute)(fromRoot));
+}
+function mountPathIsUnsafe(value) {
+    return (value.includes('\0') ||
+        value.includes('\r') ||
+        value.includes('\n') ||
+        value.includes(','));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function externalBlueprintSandboxUserFlag(platform = process.platform, uid = process.getuid?.(), gid = process.getgid?.()) {
+    if (platform === 'win32') {
+        throw new Error('External Blueprint execution is unsupported on Windows until a container-compatible dependency graph and link proof exists.');
+    }
+    if (!['darwin', 'linux'].includes(platform)) {
+        throw new Error('External Blueprint execution requires a supported POSIX Docker host.');
+    }
+    if (uid === undefined ||
+        gid === undefined ||
+        !Number.isSafeInteger(uid) ||
+        !Number.isSafeInteger(gid) ||
+        uid <= 0 ||
+        gid <= 0 ||
+        uid > 2_147_483_647 ||
+        gid > 2_147_483_647) {
+        throw new Error('External Blueprint execution requires one bounded non-root host UID and GID.');
+    }
+    return `--user=${uid}:${gid}`;
+}
+function externalBlueprintSandboxTimeoutCommand(timeoutMs) {
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 30_000) {
+        throw new Error('External Blueprint timeout command requires an integer from 1 through 30000 milliseconds.');
+    }
+    return [
+        'timeout',
+        '-s',
+        'KILL',
+        `${Math.ceil(timeoutMs / 1_000) + 1}s`,
+        '/usr/local/bin/node',
+    ];
+}
+function packagePathSegments(name, label) {
+    const segments = name.split('/');
+    const scoped = name.startsWith('@');
+    if (node_buffer_1.Buffer.byteLength(name, 'utf8') > 214 ||
+        !/^(?:@[A-Za-z0-9][A-Za-z0-9._~-]*\/)?[A-Za-z0-9][A-Za-z0-9._~-]*$/u.test(name) ||
+        (scoped ? segments.length !== 2 : segments.length !== 1) ||
+        segments.some((segment) => segment === '' ||
+            segment === '.' ||
+            segment === '..' ||
+            segment.includes('\\') ||
+            /[\0\r\n,]/u.test(segment))) {
+        throw new Error(`${label} must be one exact package name.`);
+    }
+    return segments;
+}
+function assertLinuxMuslPortableManifest(manifest) {
+    if (manifest.optionalDependencies !== undefined) {
+        if (!isRecord(manifest.optionalDependencies)) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} has a malformed optional dependency map.`);
+        }
+        if (Object.keys(manifest.optionalDependencies).length > 0) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} has optional dependency ambiguity and cannot enter the pinned Linux/musl closure.`);
+        }
+    }
+    for (const field of ['bundleDependencies', 'bundledDependencies']) {
+        const bundled = manifest[field];
+        if (bundled === true ||
+            (Array.isArray(bundled) && bundled.length > 0) ||
+            (bundled !== undefined && bundled !== false && !Array.isArray(bundled))) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} declares unsupported bundled dependency surface ${field}.`);
+        }
+    }
+    if (manifest.peerDependencies !== undefined &&
+        !isRecord(manifest.peerDependencies)) {
+        throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} has a malformed peer dependency map.`);
+    }
+    if (manifest.peerDependenciesMeta !== undefined) {
+        if (!isRecord(manifest.peerDependenciesMeta)) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} has malformed peer dependency metadata.`);
+        }
+        const malformedPeer = Object.entries(manifest.peerDependenciesMeta).find(([name, metadata]) => !isRecord(metadata) ||
+            !Object.prototype.hasOwnProperty.call(manifest.peerDependencies ?? {}, name) ||
+            Object.keys(metadata).some((key) => key !== 'optional') ||
+            (Object.prototype.hasOwnProperty.call(metadata, 'optional') &&
+                typeof metadata.optional !== 'boolean'));
+        if (malformedPeer) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} has malformed peer dependency metadata.`);
+        }
+        const optionalPeer = Object.entries(manifest.peerDependenciesMeta).find(([, metadata]) => metadata?.optional === true);
+        if (optionalPeer) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} declares optional peer ambiguity for ${optionalPeer[0]}.`);
+        }
+    }
+    const conditionedField = ['os', 'cpu', 'libc', 'gypfile', 'binary'].find((field) => Object.prototype.hasOwnProperty.call(manifest, field));
+    if (conditionedField) {
+        throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} declares unsupported platform or native field ${conditionedField}.`);
+    }
+    if (manifest.scripts !== undefined) {
+        if (!isRecord(manifest.scripts)) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} has a malformed scripts map.`);
+        }
+        const installScript = [
+            'preinstall',
+            'install',
+            'postinstall',
+            'prepare',
+            'prepublish',
+        ].find((name) => Object.prototype.hasOwnProperty.call(manifest.scripts, name));
+        if (installScript) {
+            throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} declares unsupported install/build script ${installScript}.`);
+        }
+    }
+    const buildDependency = [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.peerDependencies ?? {}),
+    ].find((name) => INSTALL_BUILD_DEPENDENCIES.has(name));
+    if (buildDependency) {
+        throw new Error(`External Blueprint package ${manifest.name}@${manifest.version} declares unsupported native build dependency ${buildDependency}.`);
+    }
+}
+function readPackageManifest(packageRoot, expectedName, expectedVersion) {
+    const manifestPath = (0, node_path_1.join)(packageRoot, 'package.json');
+    let descriptor;
+    let bytes;
+    try {
+        const pathStatus = (0, node_fs_1.lstatSync)(manifestPath);
+        if (pathStatus.isSymbolicLink() ||
+            !pathStatus.isFile() ||
+            pathStatus.size > MAX_PACKAGE_MANIFEST_BYTES) {
+            throw new Error('invalid bounded regular manifest');
+        }
+        descriptor = (0, node_fs_1.openSync)(manifestPath, node_fs_1.constants.O_RDONLY | node_fs_1.constants.O_NOFOLLOW);
+        const descriptorStatus = (0, node_fs_1.fstatSync)(descriptor);
+        if (!descriptorStatus.isFile() ||
+            descriptorStatus.size > MAX_PACKAGE_MANIFEST_BYTES) {
+            throw new Error('invalid bounded regular manifest');
+        }
+        const bounded = node_buffer_1.Buffer.allocUnsafe(MAX_PACKAGE_MANIFEST_BYTES + 1);
+        let offset = 0;
+        for (;;) {
+            const read = (0, node_fs_1.readSync)(descriptor, bounded, offset, bounded.length - offset, null);
+            if (read === 0)
+                break;
+            offset += read;
+            if (offset > MAX_PACKAGE_MANIFEST_BYTES) {
+                throw new Error('invalid bounded regular manifest');
+            }
+        }
+        bytes = bounded.subarray(0, offset);
+    }
+    catch {
+        throw new Error('External Blueprint dependency manifest must be one regular non-symlink file no larger than 1 MiB.');
+    }
+    finally {
+        if (descriptor !== undefined)
+            (0, node_fs_1.closeSync)(descriptor);
+    }
+    let value;
+    try {
+        value = JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        throw new Error('External Blueprint dependency manifest is not valid JSON.');
+    }
+    if (!value ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        !('name' in value) ||
+        typeof value.name !== 'string' ||
+        !('version' in value) ||
+        typeof value.version !== 'string' ||
+        value.version.trim() === '' ||
+        (expectedName !== undefined && value.name !== expectedName) ||
+        (expectedVersion !== undefined && value.version !== expectedVersion)) {
+        throw new Error('External Blueprint dependency manifest does not retain its exact package identity.');
+    }
+    packagePathSegments(value.name, 'External Blueprint dependency name');
+    const manifest = value;
+    assertLinuxMuslPortableManifest(manifest);
+    return manifest;
+}
+function manifestDependencyInventory(manifest) {
+    const inventory = new Map();
+    const add = (source, optional) => {
+        if (source === undefined)
+            return;
+        if (!source || typeof source !== 'object' || Array.isArray(source)) {
+            throw new Error('External Blueprint dependency manifest contains an invalid dependency map.');
+        }
+        for (const [name, version] of Object.entries(source)) {
+            packagePathSegments(name, 'External Blueprint dependency name');
+            if (typeof version !== 'string' || version.trim() === '') {
+                throw new Error('External Blueprint dependency manifest contains an invalid dependency version.');
+            }
+            inventory.set(name, (inventory.get(name) ?? true) && optional);
+        }
+    };
+    add(manifest.dependencies, false);
+    add(manifest.optionalDependencies, true);
+    for (const [name, version] of Object.entries(manifest.peerDependencies ?? {})) {
+        add({ [name]: version }, manifest.peerDependenciesMeta?.[name]?.optional === true);
+    }
+    return [...inventory.entries()]
+        .map(([name, optional]) => ({ name, optional }))
+        .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+}
+function workspaceRegistryAuthority(workspaceRoot, expectedLockfileDigest) {
+    const lockfilePath = (0, node_path_1.join)(workspaceRoot, 'pnpm-lock.yaml');
+    let lockfileBytes;
+    let nodeModulesRoot;
+    let virtualStoreRoot;
+    try {
+        if ((0, node_fs_1.lstatSync)(lockfilePath).isSymbolicLink() ||
+            !(0, node_fs_1.lstatSync)(lockfilePath).isFile() ||
+            (0, node_fs_1.statSync)(lockfilePath).size > MAX_LOCKFILE_BYTES) {
+            throw new Error('invalid lockfile authority');
+        }
+        lockfileBytes = (0, node_fs_1.readFileSync)(lockfilePath);
+        if (lockfileBytes.length > MAX_LOCKFILE_BYTES) {
+            throw new Error('invalid lockfile authority');
+        }
+        nodeModulesRoot = (0, node_fs_1.realpathSync)((0, node_path_1.join)(workspaceRoot, 'node_modules'));
+        virtualStoreRoot = (0, node_fs_1.realpathSync)((0, node_path_1.join)(nodeModulesRoot, '.pnpm'));
+    }
+    catch {
+        throw new Error('Installed external Blueprint execution requires one bounded regular pnpm lockfile and canonical workspace virtual store.');
+    }
+    if (!isContainedPath(nodeModulesRoot, virtualStoreRoot)) {
+        throw new Error('External Blueprint pnpm virtual store escapes the canonical workspace node_modules authority.');
+    }
+    if (expectedLockfileDigest !== undefined) {
+        const lockfileDigest = (0, node_crypto_1.createHash)('sha256')
+            .update(lockfileBytes)
+            .digest('hex');
+        if (!/^[a-f0-9]{64}$/u.test(expectedLockfileDigest) ||
+            lockfileDigest !== expectedLockfileDigest) {
+            throw new Error('Installed external Blueprint pnpm lockfile changed after package resolution.');
+        }
+    }
+    let parsed;
+    try {
+        parsed = (0, yaml_1.parse)(lockfileBytes.toString('utf8'));
+    }
+    catch {
+        parsed = undefined;
+    }
+    if (!isRecord(parsed) ||
+        !isRecord(parsed.packages) ||
+        !isRecord(parsed.importers) ||
+        !isRecord(parsed.importers['.'])) {
+        throw new Error('Installed external Blueprint execution requires a complete parseable pnpm lockfile authority.');
+    }
+    const mutableIntegrities = new Map();
+    for (const [lockKey, metadata] of Object.entries(parsed.packages)) {
+        if (!isRecord(metadata) ||
+            !isRecord(metadata.resolution) ||
+            typeof metadata.resolution.integrity !== 'string' ||
+            !REGISTRY_INTEGRITY.test(metadata.resolution.integrity)) {
+            continue;
+        }
+        const identity = lockKey.replace(/\(.+$/u, '');
+        const values = mutableIntegrities.get(identity) ?? new Set();
+        values.add(metadata.resolution.integrity);
+        mutableIntegrities.set(identity, values);
+    }
+    return {
+        integrities: mutableIntegrities,
+        lockfile: parsed,
+        lockfileBytes,
+        nodeModulesRoot,
+        virtualStoreRoot,
+    };
+}
+function installedRegistryAuthority(workspaceRoot, packageRoot, rootManifest, expectedRegistryIntegrity, expectedLockfileDigest) {
+    const authority = workspaceRegistryAuthority(workspaceRoot, expectedLockfileDigest);
+    let installedRoot;
+    try {
+        installedRoot = (0, node_fs_1.realpathSync)((0, node_path_1.join)(authority.nodeModulesRoot, ...packagePathSegments(rootManifest.name, 'Installed external Blueprint package name')));
+    }
+    catch {
+        throw new Error(`Installed external Blueprint ${rootManifest.name}@${rootManifest.version} is absent from canonical workspace node_modules.`);
+    }
+    if (installedRoot !== packageRoot) {
+        throw new Error(`Installed external Blueprint ${rootManifest.name}@${rootManifest.version} does not match its canonical workspace node_modules resolution.`);
+    }
+    const rootImporter = authority.lockfile.importers;
+    const importer = isRecord(rootImporter) ? rootImporter['.'] : undefined;
+    if (!isRecord(importer)) {
+        throw new Error('Installed external Blueprint execution requires one root lockfile importer.');
+    }
+    let directDeclarations = 0;
+    for (const group of [
+        'dependencies',
+        'devDependencies',
+        'optionalDependencies',
+    ]) {
+        const declarations = importer[group];
+        if (!isRecord(declarations) ||
+            !Object.prototype.hasOwnProperty.call(declarations, rootManifest.name)) {
+            continue;
+        }
+        directDeclarations += 1;
+        const declaration = declarations[rootManifest.name];
+        if (!isRecord(declaration) ||
+            declaration.specifier !== rootManifest.version ||
+            typeof declaration.version !== 'string' ||
+            declaration.version.replace(/\(.+$/u, '') !== rootManifest.version) {
+            throw new Error(`Installed external Blueprint ${rootManifest.name}@${rootManifest.version} lacks one exact root lockfile declaration.`);
+        }
+    }
+    if (directDeclarations !== 1) {
+        throw new Error(`Installed external Blueprint ${rootManifest.name}@${rootManifest.version} must have exactly one root lockfile declaration.`);
+    }
+    const rootIntegrities = authority.integrities.get(`${rootManifest.name}@${rootManifest.version}`);
+    if (!REGISTRY_INTEGRITY.test(expectedRegistryIntegrity) ||
+        !rootIntegrities ||
+        rootIntegrities.size !== 1 ||
+        !rootIntegrities.has(expectedRegistryIntegrity)) {
+        throw new Error(`Installed external Blueprint ${rootManifest.name}@${rootManifest.version} no longer matches its resolution-time registry integrity.`);
+    }
+    return authority;
+}
+function assertInstalledPackageRoot(authority, packageRoot) {
+    const relativeRoot = (0, node_path_1.relative)(authority.virtualStoreRoot, packageRoot);
+    if (relativeRoot === '' ||
+        relativeRoot === '..' ||
+        relativeRoot.startsWith(`..${node_path_1.sep}`) ||
+        (0, node_path_1.isAbsolute)(relativeRoot)) {
+        throw new Error('Installed external Blueprint dependency resolves outside the canonical pnpm virtual store.');
+    }
+}
+function assertInstalledPackageAuthority(authority, packageRoot, manifest) {
+    assertInstalledPackageRoot(authority, packageRoot);
+    const identity = `${manifest.name}@${manifest.version}`;
+    const integrities = authority.integrities.get(identity);
+    if (!integrities || integrities.size !== 1) {
+        throw new Error(`Installed external Blueprint dependency ${identity} lacks one exact registry integrity in pnpm-lock.yaml.`);
+    }
+}
+function resolveInstalledDependencyRoot(workspaceRoot, packageRoot, dependency, installedAuthority) {
+    const resolver = (0, node_module_1.createRequire)((0, node_path_1.join)(packageRoot, 'package.json'));
+    // Asking for the bare package name returns null when its name is shadowed by
+    // a Node builtin (for example, the declared npm package `buffer`). Resolve a
+    // package subpath so every manifest dependency uses ordinary node_modules
+    // lookup semantics rather than silently substituting a builtin.
+    const candidates = resolver.resolve.paths(`${dependency.name}/package.json`) ?? [];
+    for (const candidateRoot of candidates) {
+        const candidate = (0, node_path_1.join)(candidateRoot, ...packagePathSegments(dependency.name, 'External Blueprint dependency name'));
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(candidate, 'package.json')))
+            continue;
+        const canonical = (0, node_fs_1.realpathSync)(candidate);
+        if (!isContainedPath(workspaceRoot, canonical)) {
+            throw new Error('External Blueprint dependency closure escapes the canonical workspace.');
+        }
+        assertInstalledPackageRoot(installedAuthority, canonical);
+        readPackageManifest(canonical, dependency.name);
+        return canonical;
+    }
+    if (dependency.optional)
+        return undefined;
+    throw new Error(`External Blueprint dependency ${dependency.name} is not installed in its exact package resolution scope.`);
+}
+function copyPackageBytes(sourceRoot, destinationRoot, budget) {
+    (0, node_fs_1.mkdirSync)(destinationRoot, { recursive: true, mode: 0o700 });
+    (0, node_fs_1.chmodSync)(destinationRoot, 0o700);
+    const visit = (source, destination, depth) => {
+        if (depth > MAX_CLOSURE_DEPTH) {
+            throw new Error('External Blueprint dependency closure exceeds its fixed directory-depth bound.');
+        }
+        const entries = (0, node_fs_1.readdirSync)(source, { withFileTypes: true }).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            const sourcePath = (0, node_path_1.join)(source, entry.name);
+            const destinationPath = (0, node_path_1.join)(destination, entry.name);
+            const status = (0, node_fs_1.lstatSync)(sourcePath);
+            if (status.isSymbolicLink()) {
+                throw new Error('External Blueprint dependency closure may not contain symbolic links.');
+            }
+            if (status.isDirectory()) {
+                budget.directories += 1;
+                if (budget.directories > MAX_CLOSURE_DIRECTORIES) {
+                    throw new Error('External Blueprint dependency closure exceeds its fixed directory bound.');
+                }
+                (0, node_fs_1.mkdirSync)(destinationPath, { mode: 0o700 });
+                (0, node_fs_1.chmodSync)(destinationPath, 0o700);
+                visit(sourcePath, destinationPath, depth + 1);
+                continue;
+            }
+            if (!status.isFile()) {
+                throw new Error('External Blueprint dependency closure may contain only regular files and directories.');
+            }
+            if (entry.name.toLowerCase() === 'binding.gyp' ||
+                entry.name.toLowerCase().endsWith('.node')) {
+                throw new Error('External Blueprint dependency closure contains an unsupported native build or binary surface.');
+            }
+            budget.files += 1;
+            budget.bytes += status.size;
+            if (budget.files > MAX_CLOSURE_FILES ||
+                budget.bytes > MAX_CLOSURE_BYTES) {
+                throw new Error('External Blueprint dependency closure exceeds its fixed file or byte bound.');
+            }
+            (0, node_fs_1.copyFileSync)(sourcePath, destinationPath, node_fs_1.constants.COPYFILE_FICLONE);
+            (0, node_fs_1.chmodSync)(destinationPath, status.mode & 0o111 ? 0o500 : 0o400);
+        }
+    };
+    visit(sourceRoot, destinationRoot, 0);
+}
+function discoverPackage(workspaceRoot, sourceRoot, packagesRoot, packages, budget, installedAuthority, requiresRegistryAuthority) {
+    const existing = packages.get(sourceRoot);
+    if (existing)
+        return existing;
+    budget.packages += 1;
+    if (budget.packages > MAX_CLOSURE_PACKAGES) {
+        throw new Error('External Blueprint dependency closure exceeds its fixed package bound.');
+    }
+    if (requiresRegistryAuthority && !installedAuthority) {
+        throw new Error('Local external Blueprint dependencies require canonical pnpm registry and lockfile authority.');
+    }
+    if (requiresRegistryAuthority && installedAuthority) {
+        assertInstalledPackageRoot(installedAuthority, sourceRoot);
+    }
+    const manifest = readPackageManifest(sourceRoot);
+    if (requiresRegistryAuthority && installedAuthority) {
+        assertInstalledPackageAuthority(installedAuthority, sourceRoot, manifest);
+    }
+    const stagedRoot = (0, node_path_1.join)(packagesRoot, String(packages.size).padStart(4, '0'));
+    const node = {
+        dependencies: new Map(),
+        manifest,
+        stagedRoot,
+    };
+    packages.set(sourceRoot, node);
+    copyPackageBytes(sourceRoot, stagedRoot, budget);
+    for (const dependency of manifestDependencyInventory(manifest)) {
+        if (!installedAuthority) {
+            throw new Error('Local external Blueprint dependencies require canonical pnpm registry and lockfile authority.');
+        }
+        const dependencyRoot = resolveInstalledDependencyRoot(workspaceRoot, sourceRoot, dependency, installedAuthority);
+        if (dependencyRoot === undefined)
+            continue;
+        node.dependencies.set(dependency.name, discoverPackage(workspaceRoot, dependencyRoot, packagesRoot, packages, budget, installedAuthority, true));
+    }
+    return node;
+}
+function stagedPackageLink(target, link) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(link), { recursive: true, mode: 0o700 });
+    (0, node_fs_1.chmodSync)((0, node_path_1.dirname)(link), 0o700);
+    if (process.platform === 'win32') {
+        (0, node_fs_1.symlinkSync)(target, link, 'junction');
+    }
+    else {
+        (0, node_fs_1.symlinkSync)((0, node_path_1.relative)((0, node_path_1.dirname)(link), target), link, 'dir');
+    }
+}
+function linkStagedPackageGraph(stageRoot, root, packages) {
+    for (const node of packages.values()) {
+        for (const [name, dependency] of node.dependencies) {
+            stagedPackageLink(dependency.stagedRoot, (0, node_path_1.join)(node.stagedRoot, 'node_modules', ...packagePathSegments(name, 'External Blueprint dependency name')));
+        }
+    }
+    stagedPackageLink(root.stagedRoot, (0, node_path_1.join)(stageRoot, 'node_modules', ...packagePathSegments(root.manifest.name, 'External Blueprint package name')));
+}
+function stageExternalBlueprintClosure(workspaceRoot, packageRoot, generatorPath, authority) {
+    const generatorChild = (0, node_path_1.relative)(packageRoot, generatorPath);
+    if (generatorChild === '' ||
+        generatorChild === '..' ||
+        generatorChild.startsWith(`..${node_path_1.sep}`) ||
+        (0, node_path_1.isAbsolute)(generatorChild)) {
+        throw new Error('External Blueprint generator must remain inside its canonical package root.');
+    }
+    const manifest = readPackageManifest(packageRoot, authority.blueprint.name, authority.blueprint.version);
+    if (authority.source === 'local') {
+        let nodeModulesRoot;
+        try {
+            nodeModulesRoot = (0, node_fs_1.realpathSync)((0, node_path_1.join)(workspaceRoot, 'node_modules'));
+        }
+        catch {
+            nodeModulesRoot = undefined;
+        }
+        if (nodeModulesRoot && isContainedPath(nodeModulesRoot, packageRoot)) {
+            throw new Error('Local external Blueprint packages must remain outside workspace node_modules so source authority is unambiguous.');
+        }
+    }
+    const installedAuthority = authority.source === 'installed'
+        ? installedRegistryAuthority(workspaceRoot, packageRoot, manifest, authority.registryIntegrity, authority.lockfileDigest)
+        : manifestDependencyInventory(manifest).length > 0
+            ? workspaceRegistryAuthority(workspaceRoot)
+            : undefined;
+    const stageRoot = (0, node_fs_1.realpathSync)((0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'ebk-blueprint-closure-')));
+    try {
+        (0, node_fs_1.chmodSync)(stageRoot, 0o700);
+        const packageSegments = packagePathSegments(manifest.name, 'External Blueprint package name');
+        const packagesRoot = (0, node_path_1.join)(stageRoot, '.packages');
+        (0, node_fs_1.mkdirSync)(packagesRoot, { recursive: true, mode: 0o700 });
+        (0, node_fs_1.chmodSync)(packagesRoot, 0o700);
+        const packages = new Map();
+        const root = discoverPackage(workspaceRoot, packageRoot, packagesRoot, packages, { bytes: 0, directories: 0, files: 0, packages: 0 }, installedAuthority, authority.source === 'installed');
+        linkStagedPackageGraph(stageRoot, root, packages);
+        const containerGeneratorUrl = `file://${node_path_1.posix.join('/sandbox/node_modules', ...packageSegments, ...generatorChild
+            .split(node_path_1.sep)
+            .map((segment) => encodeURIComponent(segment)))}`;
+        return {
+            containerGeneratorUrl,
+            mountRoot: stageRoot,
+            remove: () => (0, node_fs_1.rmSync)(stageRoot, { force: true, recursive: true }),
+        };
+    }
+    catch (error) {
+        (0, node_fs_1.rmSync)(stageRoot, { force: true, recursive: true });
+        throw error;
+    }
+}
+function trustedDockerCandidates() {
+    const candidates = [
+        '/Applications/Docker.app/Contents/Resources/bin/docker',
+        '/usr/local/bin/docker',
+        '/opt/homebrew/bin/docker',
+        '/usr/bin/docker',
+        '/snap/bin/docker',
+    ];
+    const home = process.env.HOME;
+    if (home)
+        candidates.push((0, node_path_1.join)(home, '.docker', 'bin', 'docker'));
+    const programFiles = process.env.ProgramFiles;
+    if (programFiles) {
+        candidates.push((0, node_path_1.join)(programFiles, 'Docker', 'Docker', 'resources', 'bin', 'docker.exe'));
+    }
+    return candidates;
+}
+function resolveDockerExecutable(workspaceRoot) {
+    for (const candidate of trustedDockerCandidates()) {
+        if (!(0, node_fs_1.existsSync)(candidate))
+            continue;
+        let canonical;
+        try {
+            canonical = (0, node_fs_1.realpathSync)(candidate);
+            if (!(0, node_fs_1.lstatSync)(canonical).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (!isContainedPath(workspaceRoot, canonical))
+            return canonical;
+    }
+    throw new Error('External Blueprint execution requires a trusted Docker installation in a standard platform location.');
+}
+function externalBlueprintDockerDiscoveryEnvironment(docker, source = process.env) {
+    const names = [
+        'DOCKER_CERT_PATH',
+        'DOCKER_CONFIG',
+        'DOCKER_CONTEXT',
+        'DOCKER_HOST',
+        'DOCKER_TLS_VERIFY',
+        'HOME',
+        'SystemRoot',
+        'TEMP',
+        'TMP',
+        'USERPROFILE',
+        'WINDIR',
+    ];
+    const environment = Object.fromEntries(names.flatMap((name) => {
+        const value = source[name];
+        return value === undefined ? [] : [[name, value]];
+    }));
+    const helperPath = [
+        (0, node_path_1.dirname)(docker),
+        '/usr/bin',
+        '/bin',
+        '/usr/sbin',
+        '/sbin',
+    ].filter((value, index, values) => values.indexOf(value) === index);
+    environment.PATH = helperPath.join(node_path_1.delimiter);
+    return environment;
+}
+function externalBlueprintDockerEnvironment(docker, endpoint, privateRoot, source = process.env) {
+    let canonicalPrivateRoot;
+    try {
+        canonicalPrivateRoot = (0, node_fs_1.realpathSync)(privateRoot);
+    }
+    catch {
+        throw new Error('External Blueprint Docker client requires one canonical private configuration root.');
+    }
+    const metadata = (0, node_fs_1.lstatSync)(canonicalPrivateRoot);
+    if (!isLocalDockerEndpoint(endpoint) ||
+        metadata.isSymbolicLink() ||
+        !metadata.isDirectory() ||
+        (process.platform !== 'win32' && (metadata.mode & 0o077) !== 0)) {
+        throw new Error('External Blueprint Docker client requires one local endpoint and machine-private configuration root.');
+    }
+    const systemRoot = source.SystemRoot ?? source.SYSTEMROOT ?? source.WINDIR;
+    const helperPath = [
+        (0, node_path_1.dirname)(docker),
+        '/usr/bin',
+        '/bin',
+        '/usr/sbin',
+        '/sbin',
+    ].filter((value, index, values) => values.indexOf(value) === index);
+    return {
+        DOCKER_CONFIG: canonicalPrivateRoot,
+        DOCKER_HOST: endpoint,
+        HOME: canonicalPrivateRoot,
+        PATH: helperPath.join(node_path_1.delimiter),
+        TEMP: canonicalPrivateRoot,
+        TMP: canonicalPrivateRoot,
+        TMPDIR: canonicalPrivateRoot,
+        XDG_CONFIG_HOME: canonicalPrivateRoot,
+        ...(process.platform === 'win32' && systemRoot
+            ? {
+                SystemRoot: systemRoot,
+                WINDIR: systemRoot,
+            }
+            : {}),
+    };
+}
+function ensureSandboxImage(docker, environment) {
+    if (sandboxImageReady)
+        return;
+    const inspect = (0, node_child_process_1.spawnSync)(docker, ['image', 'inspect', '--format={{.Id}}', container_images_js_1.EBK_NODE_22_ALPINE_IMAGE], {
+        encoding: 'utf8',
+        env: environment,
+        maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+        timeout: TERMINATION_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    if (inspect.status !== 0) {
+        const pull = (0, node_child_process_1.spawnSync)(docker, ['pull', '--quiet', container_images_js_1.EBK_NODE_22_ALPINE_IMAGE], {
+            encoding: 'utf8',
+            env: environment,
+            maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+            timeout: IMAGE_PULL_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        if (pull.error || pull.status !== 0) {
+            throw new Error(`External Blueprint execution requires the pinned sandbox image ${container_images_js_1.EBK_NODE_22_ALPINE_IMAGE}; Docker could not inspect or pull it.`);
+        }
+    }
+    sandboxImageReady = true;
+}
+function isLocalDockerEndpoint(value) {
+    return (value.length <= 2_048 &&
+        !value.includes('\0') &&
+        !value.includes('\r') &&
+        !value.includes('\n') &&
+        (value.startsWith('unix:///') || value.startsWith('npipe:////')));
+}
+function resolveLocalDockerEndpoint(docker, environment) {
+    const configuredHost = environment.DOCKER_HOST;
+    if (configuredHost !== undefined) {
+        if (!isLocalDockerEndpoint(configuredHost)) {
+            throw new Error('External Blueprint execution requires a local Unix-socket or Windows named-pipe Docker engine.');
+        }
+        return configuredHost;
+    }
+    let context = environment.DOCKER_CONTEXT;
+    if (context === undefined) {
+        const selected = (0, node_child_process_1.spawnSync)(docker, ['context', 'show'], {
+            encoding: 'utf8',
+            env: environment,
+            maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+            timeout: TERMINATION_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        context = selected.status === 0 ? selected.stdout.trim() : undefined;
+    }
+    if (!context || !/^[A-Za-z0-9_.-]{1,128}$/u.test(context)) {
+        throw new Error('External Blueprint execution could not resolve one bounded local Docker context.');
+    }
+    const inspected = (0, node_child_process_1.spawnSync)(docker, ['context', 'inspect', context, '--format={{json .Endpoints.docker.Host}}'], {
+        encoding: 'utf8',
+        env: environment,
+        maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+        timeout: TERMINATION_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    let endpoint;
+    try {
+        endpoint = JSON.parse(inspected.stdout.trim());
+    }
+    catch {
+        endpoint = undefined;
+    }
+    if (inspected.status !== 0 ||
+        typeof endpoint !== 'string' ||
+        !isLocalDockerEndpoint(endpoint)) {
+        throw new Error('External Blueprint execution requires a local Unix-socket or Windows named-pipe Docker context.');
+    }
+    return endpoint;
+}
+function createExternalBlueprintDockerAuthority(docker, endpoint) {
+    const privateRoot = (0, node_fs_1.realpathSync)((0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'ebk-blueprint-docker-')));
+    try {
+        (0, node_fs_1.chmodSync)(privateRoot, 0o700);
+        return {
+            environment: externalBlueprintDockerEnvironment(docker, endpoint, privateRoot),
+            remove: () => (0, node_fs_1.rmSync)(privateRoot, { force: true, recursive: true }),
+        };
+    }
+    catch (error) {
+        (0, node_fs_1.rmSync)(privateRoot, { force: true, recursive: true });
+        throw error;
+    }
+}
+function assertExternalBlueprintDockerSecurityOptions(value) {
+    if (!Array.isArray(value) ||
+        value.some((entry) => typeof entry !== 'string' ||
+            entry.length > 1_024 ||
+            /[\0\r\n]/u.test(entry))) {
+        throw new Error('External Blueprint execution could not establish bounded Docker security options.');
+    }
+    const remapped = value.find((entry) => /(?:^|[=,])(?:rootless|userns)(?:$|[=,])/iu.test(entry));
+    if (remapped) {
+        throw new Error('External Blueprint execution refuses rootless or userns-remapped Docker because private bind ownership is not proven.');
+    }
+}
+function assertDockerIdentityMapping(docker, environment) {
+    const inspected = (0, node_child_process_1.spawnSync)(docker, ['info', '--format={{json .SecurityOptions}}'], {
+        encoding: 'utf8',
+        env: environment,
+        maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+        timeout: TERMINATION_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    let securityOptions;
+    try {
+        securityOptions = JSON.parse(inspected.stdout.trim());
+    }
+    catch {
+        securityOptions = undefined;
+    }
+    if (inspected.status !== 0)
+        securityOptions = undefined;
+    assertExternalBlueprintDockerSecurityOptions(securityOptions);
+}
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}
+async function proveExternalBlueprintContainerAbsent(run, removalTarget, filter, options = {}) {
+    const attempts = options.attempts ?? 50;
+    const retryDelayMs = options.retryDelayMs ?? CLEANUP_RETRY_DELAY_MS;
+    let consecutiveAbsenceProofs = 0;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        run(['container', 'rm', '--force', removalTarget]);
+        const listed = run([
+            'container',
+            'ls',
+            '--all',
+            '--no-trunc',
+            '--quiet',
+            `--filter=${filter}`,
+        ]);
+        if (listed.status === 0 && listed.stdout.trim() === '') {
+            consecutiveAbsenceProofs += 1;
+            if (consecutiveAbsenceProofs === 2)
+                return true;
+        }
+        else {
+            consecutiveAbsenceProofs = 0;
+        }
+        if (attempt + 1 < attempts)
+            await delay(retryDelayMs);
+    }
+    return false;
+}
+async function proveContainerAbsent(docker, environment, removalTarget, filter) {
+    return proveExternalBlueprintContainerAbsent((args) => {
+        const result = (0, node_child_process_1.spawnSync)(docker, [...args], {
+            encoding: 'utf8',
+            env: environment,
+            maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+            timeout: TERMINATION_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        return { status: result.status, stdout: result.stdout ?? '' };
+    }, removalTarget, filter);
+}
+function executeCreatedExternalBlueprintContainer(execution) {
+    return new Promise((resolveExecution, rejectExecution) => {
+        const executionTimer = { current: undefined };
+        let clientCloseWatchdog;
+        const output = [];
+        let outputBytes = 0;
+        let diagnosticBytes = 0;
+        let forcedFailure;
+        let settled = false;
+        let finalizing = false;
+        let terminationStarted = false;
+        const settle = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            if (executionTimer.current)
+                clearTimeout(executionTimer.current);
+            if (error)
+                rejectExecution(error);
+            else
+                resolveExecution(value);
+        };
+        const settleAfterCleanup = async (error, value) => {
+            if (settled || finalizing)
+                return;
+            finalizing = true;
+            if (executionTimer.current)
+                clearTimeout(executionTimer.current);
+            try {
+                await execution.cleanup();
+            }
+            catch (cleanupError) {
+                settle(cleanupError instanceof Error
+                    ? cleanupError
+                    : new Error('External Blueprint sandbox cleanup failed.'));
+                return;
+            }
+            settle(error, value);
+        };
+        let child;
+        try {
+            child = execution.startClient();
+        }
+        catch {
+            void settleAfterCleanup(new Error('External Blueprint sandbox could not start Docker.'));
+            return;
+        }
+        const terminate = (error) => {
+            if (!forcedFailure)
+                forcedFailure = error;
+            if (!terminationStarted) {
+                terminationStarted = true;
+                child.stdin.destroy();
+                child.kill('SIGKILL');
+                clientCloseWatchdog = setTimeout(() => {
+                    // The Docker client is not the cleanup authority. Retry killing it,
+                    // but never let a missing `close` event bypass container cleanup.
+                    child.kill('SIGKILL');
+                }, TERMINATION_TIMEOUT_MS);
+                clientCloseWatchdog.unref?.();
+            }
+            void settleAfterCleanup(forcedFailure);
+        };
+        executionTimer.current = setTimeout(() => {
+            terminate(new Error(`External Blueprint publisher exceeded ${execution.timeoutMs}ms.`));
+        }, execution.timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            const bytes = node_buffer_1.Buffer.isBuffer(chunk) ? chunk : node_buffer_1.Buffer.from(chunk);
+            outputBytes += bytes.length;
+            if (outputBytes > RESULT_LIMIT_BYTES) {
+                terminate(new Error(`External Blueprint publisher exceeded the ${RESULT_LIMIT_BYTES}-byte result bound.`));
+                return;
+            }
+            output.push(bytes);
+        });
+        child.stderr.on('data', (chunk) => {
+            const bytes = node_buffer_1.Buffer.isBuffer(chunk) ? chunk : node_buffer_1.Buffer.from(chunk);
+            const remaining = Math.max(0, DIAGNOSTIC_LIMIT_BYTES - diagnosticBytes);
+            if (execution.diagnostics === 'inherit' && remaining > 0) {
+                process.stderr.write(bytes.subarray(0, remaining));
+            }
+            diagnosticBytes += bytes.length;
+            if (diagnosticBytes > DIAGNOSTIC_LIMIT_BYTES) {
+                terminate(new Error(`External Blueprint publisher exceeded the ${DIAGNOSTIC_LIMIT_BYTES}-byte diagnostic bound.`));
+            }
+        });
+        child.once('error', () => {
+            if (child.pid === undefined) {
+                void settleAfterCleanup(new Error('External Blueprint sandbox could not start Docker.'));
+            }
+            else {
+                terminate(new Error('External Blueprint sandbox Docker client failed.'));
+            }
+        });
+        child.once('close', (code) => {
+            if (executionTimer.current)
+                clearTimeout(executionTimer.current);
+            if (clientCloseWatchdog)
+                clearTimeout(clientCloseWatchdog);
+            if (forcedFailure) {
+                void settleAfterCleanup(forcedFailure);
+                return;
+            }
+            if (code !== 0) {
+                void settleAfterCleanup(new Error('External Blueprint publisher execution failed.'));
+                return;
+            }
+            try {
+                void settleAfterCleanup(undefined, JSON.parse(node_buffer_1.Buffer.concat(output).toString('utf8')));
+            }
+            catch {
+                void settleAfterCleanup(new Error('External Blueprint publisher returned invalid JSON.'));
+            }
+        });
+        child.stdin.on('error', () => undefined);
+        try {
+            child.stdin.end(execution.input);
+        }
+        catch {
+            terminate(new Error('External Blueprint sandbox Docker client failed.'));
+        }
+    });
+}
+async function runExternalBlueprintSandbox(context, options) {
+    const sandboxUserFlag = externalBlueprintSandboxUserFlag();
+    const workspaceRoot = (0, node_fs_1.realpathSync)(options.workspaceRoot);
+    const packageRoot = (0, node_fs_1.realpathSync)(options.packageRoot);
+    const generatorPath = (0, node_fs_1.realpathSync)(options.generatorPath);
+    if (!isContainedPath(workspaceRoot, packageRoot) ||
+        !isContainedPath(packageRoot, generatorPath) ||
+        mountPathIsUnsafe(packageRoot)) {
+        throw new Error('External Blueprint sandbox paths must be canonical, workspace-confined, and Docker-mount safe.');
+    }
+    const input = JSON.stringify(context);
+    if (node_buffer_1.Buffer.byteLength(input, 'utf8') > RESULT_LIMIT_BYTES) {
+        throw new Error('External Blueprint context exceeds its fixed byte bound.');
+    }
+    const closureAuthority = options.source === 'installed'
+        ? {
+            blueprint: options.blueprint,
+            lockfileDigest: options.lockfileDigest,
+            registryIntegrity: options.registryIntegrity,
+            source: options.source,
+        }
+        : { blueprint: options.blueprint, source: options.source };
+    const closure = stageExternalBlueprintClosure(workspaceRoot, packageRoot, generatorPath, closureAuthority);
+    if (mountPathIsUnsafe(closure.mountRoot)) {
+        closure.remove();
+        throw new Error('External Blueprint staged closure path is not Docker-mount safe.');
+    }
+    let docker;
+    let environment;
+    let removeDockerAuthority = () => undefined;
+    try {
+        docker = resolveDockerExecutable(workspaceRoot);
+        const discoveryEnvironment = externalBlueprintDockerDiscoveryEnvironment(docker);
+        const endpoint = resolveLocalDockerEndpoint(docker, discoveryEnvironment);
+        const dockerAuthority = createExternalBlueprintDockerAuthority(docker, endpoint);
+        environment = dockerAuthority.environment;
+        removeDockerAuthority = dockerAuthority.remove;
+        assertDockerIdentityMapping(docker, environment);
+        ensureSandboxImage(docker, environment);
+    }
+    catch (error) {
+        let closureRemoved = false;
+        let authorityRemoved = false;
+        try {
+            closure.remove();
+            closureRemoved = true;
+        }
+        catch {
+            closureRemoved = false;
+        }
+        try {
+            removeDockerAuthority();
+            authorityRemoved = true;
+        }
+        catch {
+            authorityRemoved = false;
+        }
+        if (!closureRemoved || !authorityRemoved) {
+            throw new Error('External Blueprint sandbox initialization failed and private authority cleanup was incomplete.');
+        }
+        throw error;
+    }
+    const containerName = `ebk-blueprint-${process.pid}-${(0, node_crypto_1.randomUUID)()
+        .replace(/-/g, '')
+        .slice(0, 12)}`;
+    const createArgs = [
+        'container',
+        'create',
+        exports.EXTERNAL_BLUEPRINT_CONTAINER_AUTO_REMOVE,
+        '--init',
+        '--interactive',
+        '--pull=never',
+        `--name=${containerName}`,
+        `--label=dev.empire-builder-kit.external-blueprint=${containerName}`,
+        sandboxUserFlag,
+        ...exports.EXTERNAL_BLUEPRINT_SANDBOX_FLAGS,
+        `--mount=type=bind,source=${closure.mountRoot},target=/sandbox,readonly`,
+        '--workdir=/sandbox',
+        '--env=HOME=/tmp',
+        '--env=NODE_ENV=production',
+        '--env=PATH=/usr/local/bin:/usr/bin:/bin',
+        ...CONTAINER_PROXY_ENVIRONMENT.map((name) => `--env=${name}=`),
+        '--entrypoint=/bin/busybox',
+        exports.EXTERNAL_BLUEPRINT_SANDBOX_IMAGE,
+        ...externalBlueprintSandboxTimeoutCommand(options.timeoutMs),
+        '--permission',
+        '--allow-fs-read=/sandbox',
+        '--input-type=module',
+        '--eval',
+        sandboxRunner,
+        closure.containerGeneratorUrl,
+    ];
+    const created = (0, node_child_process_1.spawnSync)(docker, createArgs, {
+        cwd: workspaceRoot,
+        encoding: 'utf8',
+        env: environment,
+        maxBuffer: DIAGNOSTIC_LIMIT_BYTES,
+        timeout: TERMINATION_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    const containerId = created.stdout.trim();
+    if (created.error ||
+        created.status !== 0 ||
+        !/^[a-f0-9]{64}$/u.test(containerId)) {
+        const absent = await proveContainerAbsent(docker, environment, containerName, `name=^/${containerName}$`);
+        if (!absent) {
+            try {
+                removeDockerAuthority();
+            }
+            catch {
+                throw new Error('External Blueprint sandbox creation failed, container absence was not proven, and private Docker authority cleanup was incomplete.');
+            }
+            throw new Error('External Blueprint sandbox creation failed and cleanup could not prove container absence.');
+        }
+        let closureRemoved = false;
+        let authorityRemoved = false;
+        try {
+            closure.remove();
+            closureRemoved = true;
+        }
+        catch {
+            closureRemoved = false;
+        }
+        try {
+            removeDockerAuthority();
+            authorityRemoved = true;
+        }
+        catch {
+            authorityRemoved = false;
+        }
+        if (!closureRemoved || !authorityRemoved) {
+            throw new Error('External Blueprint sandbox creation failed and private authority cleanup was incomplete.');
+        }
+        throw new Error('External Blueprint sandbox could not create one exact bounded container.');
+    }
+    return executeCreatedExternalBlueprintContainer({
+        cleanup: async () => {
+            const absent = await proveContainerAbsent(docker, environment, containerId, `id=${containerId}`);
+            let closureRemoved = false;
+            let authorityRemoved = false;
+            try {
+                if (absent) {
+                    closure.remove();
+                    closureRemoved = true;
+                }
+            }
+            catch {
+                closureRemoved = false;
+            }
+            try {
+                removeDockerAuthority();
+                authorityRemoved = true;
+            }
+            catch {
+                authorityRemoved = false;
+            }
+            if (!absent) {
+                throw new Error('External Blueprint sandbox cleanup could not prove container absence.');
+            }
+            if (!closureRemoved || !authorityRemoved) {
+                throw new Error('External Blueprint sandbox cleanup could not remove its private dependency or Docker authority.');
+            }
+        },
+        diagnostics: options.diagnostics,
+        input,
+        startClient: () => (0, node_child_process_1.spawn)(docker, ['container', 'start', '--attach', '--interactive', containerId], {
+            cwd: workspaceRoot,
+            env: environment,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        }),
+        timeoutMs: options.timeoutMs,
+    });
+}
+//# sourceMappingURL=external-sandbox.js.map