zyrk 0.4.8 → 0.5.0

package/README.md

@@ -141,8 +141,10 @@ zyrk add package-name                # edit this importer, preserve other select
 
 Frozen/offline installs, live peers, patches, mutable registry packages, inspection,
 and repair have workspace fixtures. Builds that reach live workspace sources are
-blocked before execution. Workspace npm-lock adoption and portable workspace
-export still need adapters and fail explicitly. Recursive execution supports
+blocked before execution. Existing npm v2/v3 workspace `package-lock.json` selections can be adopted with
+`zyrk import --from npm`, preserving exact versions, aliases and live members.
+Adoption validates the complete graph before project changes; npm shrinkwrap
+precedence and unsupported bundled/external links fail explicitly. Workspace-root production exports include live member closures and assets. Recursive execution supports
 member scripts; filters are exact names or paths, not arbitrary glob expressions.
 
 ### Run a one-off tool
@@ -230,9 +232,12 @@ node ./dist-runtime/dist/server.js
 
 The exporter validates that links stay inside the output and excludes the host
 store. Generic export supports shared production graphs and relocatable private
-JavaScript outputs, including selected patches and generated files. Native binaries,
-host-path-dependent outputs, workspace export, and arbitrary shell startup adapters
-remain unsupported. Exports validate active generation/profile metadata and reject
+JavaScript outputs, including selected patches and generated files. Workspace-root exports include live production members, peer contexts, cycles
+and assets. A restricted Linux x64 ELF64 N-API copy recipe supports dependency-free
+addons using `napi_create_int32` and `napi_set_named_property` with matching
+Node/ABI/build profiles. Native bytes are copied unchanged after loader validation.
+Other native formats/API imports, external libraries, loader paths, host-path-dependent
+outputs and arbitrary shell startup adapters remain unsupported. Exports validate active generation/profile metadata and reject
 credentials or escaping links. Structural validation does not prove application health. Run an
 application smoke test from the exported directory with host-store access removed.
 

package/VERSION

@@ -1 +1 @@
-v0.4.8
+v0.5.0

package/dist/commands/deploy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAyDA,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAwEF,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CA8YjB"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAmEA,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAwEF,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CA0ZjB"}

package/dist/commands/deploy.js

@@ -1,7 +1,11 @@
-/** Self-contained pure-package deployment and explicit local Docker commands. */
+/** Self-contained runtime deployment and explicit local Docker commands. */
 import { constants } from "node:fs";
 import { open, copyFile, chmod, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rename, rm, symlink, writeFile, } from "node:fs/promises";
 import * as path from "node:path";
+import { discoverWorkspaces, findWorkspaceRoot, } from "../install/workspaces.js";
+import { readWorkspaceLock } from "../install/workspace-lock.js";
+import { validateNativeExport } from "./native-export.js";
+import { workspaceRegistryOccurrences, workspaceContextId, } from "../install/workspace-graph.js";
 import { findProjectBoundary, resolveStoreRoot } from "../config/paths.js";
 import { ZyrkError } from "../errors.js";
 import { lockedGraph } from "../install/lock.js";
@@ -81,7 +85,8 @@ function output(options, result, human) {
         : human + "\n");
 }
 export async function runDeployCommand(options) {
-    const boundary = await findProjectBoundary(options.cwd);
+    const boundary = (await findWorkspaceRoot(options.cwd)) ??
+        (await findProjectBoundary(options.cwd));
     if (!boundary)
         throw error("ZYRK_MANIFEST_INVALID", "Cannot find a project to deploy.");
     const project = await realpath(boundary);
@@ -125,7 +130,7 @@ export async function runDeployCommand(options) {
         const rawLock = await readJson(path.join(project, "package-lock.json"));
         if (manifest.workspaces !== undefined ||
             (object(rawLock.zyrk) && rawLock.zyrk.version === 2))
-            throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Workspace runtime exports require a validated live-importer deployment adapter.");
+            return await exportWorkspace(options, project, manifest, state, out, parent, files, entry);
         const doc = validateLockDoc(rawLock, "project package-lock.json");
         const resolved = lockedGraph(doc);
         const privateGraph = state.linker === "private";
@@ -168,6 +173,8 @@ export async function runDeployCommand(options) {
             root: resolveStoreRoot({ env: options.env }).root,
         });
         store.requireInitialized();
+        if (within(store.root, out))
+            throw error("ZYRK_DEPLOY_ESCAPE", "Deployment output must be outside the managed store.");
         const barrier = await acquireLock(path.join(store.paths.locksDir, "liveness.lock"), { name: "portable deployment retention" });
         try {
             const installedKeys = new Set(Array.isArray(state.contexts)
@@ -261,9 +268,7 @@ export async function runDeployCommand(options) {
                             await symlink(e.target, target);
                         }
                         else {
-                            if (e.path.endsWith(".node"))
-                                throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Native addon runtime compatibility requires a validated deployment adapter.");
-                            await copyFile(path.join(sourceDir, e.path), target);
+                            await scanOrCopyPrivateFile(path.join(sourceDir, e.path), target, [project, store.root], privateBudget);
                             await chmod(target, e.mode === "exec" ? 0o755 : 0o644);
                         }
                     }
@@ -311,8 +316,7 @@ export async function runDeployCommand(options) {
                 const entryStat = await lstat(path.join(stage, entry)).catch(() => null);
                 if (!entryStat?.isFile())
                     throw error("ZYRK_DEPLOY_NONRELOCATABLE", "The selected runtime Node entry is missing.");
-                if (privateGraph)
-                    await scanPrivateExport(stage, [project, store.root], privateBudget);
+                await scanPrivateExport(stage, [project, store.root], privateBudget);
                 await validateLinks(stage, stage);
                 await writeFile(path.join(stage, "zyrk-deploy.json"), JSON.stringify({
                     schemaVersion: 1,
@@ -473,7 +477,7 @@ async function docker(options, project, manifest) {
                 buildScript: build ?? null,
                 port: Number(portText),
             }, null, 2) + "\n",
-            "ZYRK_DOCKER.md": `Review Dockerfile and .dockerignore before building. Runtime files: ${files.join(", ")}. Runtime entry: node ${entry}. Build script: ${build ?? "none"}. Container port: ${portText}.\n\nThe pinned CLI tarball must remain at its declared path. Dependencies are fetched with an optional BuildKit npmrc secret, then installed, built, and exported without networking or registry secrets. No host node_modules or store enters the runtime image. Adapt build inputs and credential exclusions to your project; generated files do not prove application health. Relocatable JavaScript output from ready private generations is supported, including patches and approved build output. Native outputs, embedded host paths, live workspace exports, and arbitrary shell start commands require a validated adapter and are rejected by this generic exporter.\n\nBuild: zyrk docker build --tag your-app:local\nRun: zyrk docker run --tag your-app:local --port ${portText}\nSupply private registry credentials to Docker BuildKit directly with docker build --secret id=npmrc,src=<credential-file> when required; zyrk never embeds them.\n`,
+            "ZYRK_DOCKER.md": `Review Dockerfile and .dockerignore before building. Runtime files: ${files.join(", ")}. Runtime entry: node ${entry}. Build script: ${build ?? "none"}. Container port: ${portText}.\n\nThe pinned CLI tarball must remain at its declared path. Dependencies are fetched with an optional BuildKit npmrc secret, then installed, built, and exported without networking or registry secrets. No host node_modules or store enters the runtime image. Adapt build inputs and credential exclusions to your project; generated files do not prove application health. Relocatable JavaScript output from ready private generations is supported, including patches and approved build output. Live workspace runtime closures and a restricted Linux ELF64 N-API native copy recipe are supported. The native v1 recipe is limited to Linux x64 ELF64 addons importing napi_create_int32 and napi_set_named_property (plus validated weak toolchain hooks), with exact installed Node/ABI/profile checks. It copies bytes unchanged and runs no package code during export. Native addons with external libraries, loader search paths, unknown formats or API imports, embedded absolute paths, and arbitrary shell start commands require another validated adapter and are rejected by this exporter. Workspace member payloads include their live files and assets except node_modules; credential filenames and links outside each source root are rejected.\n\nBuild: zyrk docker build --tag your-app:local\nRun: zyrk docker run --tag your-app:local --port ${portText}\nSupply private registry credentials to Docker BuildKit directly with docker build --secret id=npmrc,src=<credential-file> when required; zyrk never embeds them.\n`,
         };
         for (const name of Object.keys(contents))
             if (await lstat(path.join(project, name)).catch(() => null))
@@ -667,8 +671,23 @@ async function scanOrCopyPrivateFile(source, target, forbidden, budget) {
         const metadata = await input.stat();
         if (!metadata.isFile())
             throw error("ZYRK_DEPLOY_ESCAPE", "Private payload contains a special filesystem entry.");
-        if (/\.node$/i.test(source))
-            throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Native dependency outputs require a validated export adapter.");
+        let nativeSnapshot;
+        if (/\.node$/i.test(source)) {
+            if (metadata.size > 64 * 1024 * 1024)
+                throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Native addon exceeds the validated export size budget.");
+            const bytes = Buffer.alloc(metadata.size);
+            let offset = 0;
+            while (offset < bytes.length) {
+                const read = await input.read(bytes, offset, bytes.length - offset, offset);
+                if (!read.bytesRead)
+                    throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Native addon changed during export validation.");
+                offset += read.bytesRead;
+            }
+            validateNativeExport(bytes);
+            // Scan and copy these exact validated bytes. Private source files remain
+            // mutable; reopening or rereading them would discard the validation.
+            nativeSnapshot = bytes;
+        }
         if (target !== undefined)
             output = await open(target, "wx", metadata.mode & 0o111 ? 0o755 : 0o644);
         const needles = [
@@ -684,16 +703,23 @@ async function scanOrCopyPrivateFile(source, target, forbidden, budget) {
         let fileBytes = 0;
         const chunk = Buffer.allocUnsafe(1024 * 1024);
         for (;;) {
-            const { bytesRead } = await input.read(chunk, 0, chunk.length, null);
+            let bytes;
+            if (nativeSnapshot) {
+                bytes = nativeSnapshot.subarray(fileBytes, fileBytes + chunk.length);
+            }
+            else {
+                const read = await input.read(chunk, 0, chunk.length, null);
+                bytes = chunk.subarray(0, read.bytesRead);
+            }
+            const bytesRead = bytes.length;
             if (!bytesRead)
                 break;
-            const bytes = chunk.subarray(0, bytesRead);
             fileBytes += bytesRead;
             budget.bytes += bytesRead;
             checkPrivateBudget(budget);
             if (fileBytes > 512 * 1024 * 1024)
                 throw error("ZYRK_DEPLOY_NONRELOCATABLE", "A private generated file exceeds the deployment byte budget.");
-            if (first && nativeMagic(bytes))
+            if (first && nativeMagic(bytes) && !/\.node$/i.test(source))
                 throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Native dependency outputs require a validated export adapter.");
             first = false;
             const inspect = Buffer.concat([previous, bytes]);
@@ -759,3 +785,310 @@ async function scanPrivateExport(root, forbidden, budget) {
             await scanOrCopyPrivateFile(file, undefined, forbidden, budget);
     }
 }
+/** Export the selected importer closure; live files are copied, never entered into CAS. */
+async function exportWorkspace(options, project, manifest, state, out, parent, files, entry) {
+    const workspace = await discoverWorkspaces(project);
+    const locked = await readWorkspaceLock(project, workspace);
+    if (!locked ||
+        locked.doc.zyrk?.manifest !== workspace.manifestFingerprint ||
+        state.lockDigest !== sha512Hex(canonicalJson(locked.doc)))
+        throw error("ZYRK_LOCK_MISMATCH", "Workspace deployment manifests, lock and installed generation disagree.");
+    if (state.readiness !== "ready")
+        throw error("ZYRK_SCRIPT_BLOCKED", "Cannot export an unready workspace generation.");
+    if (state.platform !== process.platform || state.arch !== process.arch)
+        throw error("ZYRK_PLATFORM_UNSUPPORTED", "Workspace export requires the recorded target platform and architecture.");
+    const policy = object(manifest.zyrk) ? manifest.zyrk : {};
+    if (locked.doc.zyrk.scripts !== scriptPolicyFingerprint(policy.scripts))
+        throw error("ZYRK_LOCK_MISMATCH", "Workspace deployment build policy changed after installation.");
+    const origins = new Set(locked.graph.nodes
+        .filter((n) => n.kind === "registry")
+        .map((n) => n.origin));
+    if (origins.size > 1)
+        throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Mixed-origin workspace export requires a validated registry adapter.");
+    if (origins.size === 1) {
+        const patches = await loadProjectPatches(project);
+        const expected = configFingerprint({
+            registry: [...origins][0],
+            linker: "shared",
+            platform: currentPlatform(),
+            ...(Array.isArray(policy.mutablePackages)
+                ? { mutablePackages: policy.mutablePackages }
+                : {}),
+            ...(patches.length
+                ? {
+                    patches: sha512Hex(canonicalJson(patches.map((p) => ({
+                        sourceId: p.sourceId,
+                        digest: p.digest,
+                    })))),
+                }
+                : {}),
+        });
+        if (locked.doc.zyrk.config !== expected)
+            throw error("ZYRK_LOCK_MISMATCH", "Workspace deployment configuration or patches changed after installation.");
+    }
+    const store = await Store.open({
+        root: resolveStoreRoot({ env: options.env }).root,
+    });
+    store.requireInitialized();
+    if (within(store.root, out))
+        throw error("ZYRK_DEPLOY_ESCAPE", "Deployment output must be outside the managed store.");
+    const barrier = await acquireLock(path.join(store.paths.locksDir, "liveness.lock"), { name: "workspace deployment retention" });
+    try {
+        const graph = locked.graph, byKey = new Map(graph.nodes.map((n) => [n.key, n]));
+        const selected = new Set();
+        const visit = (key) => {
+            if (selected.has(key))
+                return;
+            const n = byKey.get(key);
+            if (!n)
+                throw error("ZYRK_OFFLINE_MISSING", "Workspace runtime edge is missing.");
+            selected.add(key);
+            for (const e of n.edges)
+                if (!(n.kind === "local" && e.kind === "dev"))
+                    visit(e.target);
+        };
+        const rootKey = graph.importers["."];
+        if (!rootKey)
+            throw error("ZYRK_LOCK_MISMATCH", "Workspace root importer is missing.");
+        visit(rootKey);
+        const directories = new Map();
+        for (const key of selected) {
+            const n = byKey.get(key);
+            if (n.kind === "local")
+                directories.set(key, workspace.importers.find((i) => i.id === n.importer).directory);
+        }
+        // Resolve recorded projection edges rather than enumerating arbitrary node_modules entries.
+        const queue = [...directories.keys()], checked = new Set();
+        while (queue.length) {
+            const key = queue.shift();
+            if (checked.has(key))
+                continue;
+            checked.add(key);
+            const n = byKey.get(key), directory = directories.get(key);
+            for (const e of n.edges) {
+                if (!selected.has(e.target) || (n.kind === "local" && e.kind === "dev"))
+                    continue;
+                const slot = n.kind === "local" || e.name === n.name
+                    ? path.join(directory, "node_modules", e.name)
+                    : path.join(directory, n.name.startsWith("@") ? "../.." : "..", e.name);
+                const actual = await realpath(slot).catch(() => null), meta = await lstat(slot).catch(() => null);
+                if (!actual ||
+                    !meta?.isSymbolicLink() ||
+                    (directories.has(e.target) && directories.get(e.target) !== actual))
+                    throw error("ZYRK_DEPLOY_ESCAPE", "Workspace dependency projection disagrees with its recorded context.");
+                directories.set(e.target, actual);
+                queue.push(e.target);
+            }
+        }
+        for (const [key, source] of directories)
+            if (key !== rootKey && (within(source, out) || within(out, source)))
+                throw error("ZYRK_DEPLOY_ESCAPE", "Deployment output overlaps a selected workspace runtime source.");
+        const registryNodes = workspaceRegistryOccurrences(graph);
+        const registryKeys = new Set(registryNodes.map((n) => n.key));
+        const privateKeys = new Set();
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const n of registryNodes)
+                if (!privateKeys.has(n.key) &&
+                    n.edges.some((e) => !registryKeys.has(e.target) || privateKeys.has(e.target))) {
+                    privateKeys.add(n.key);
+                    changed = true;
+                }
+        }
+        const sourceGraph = createGraphDoc(registryNodes.map((n) => ({
+            ...n,
+            deps: n.edges.filter((e) => registryKeys.has(e.target)),
+        })));
+        const pureGraph = createGraphDoc(registryNodes
+            .filter((n) => !privateKeys.has(n.key))
+            .map((n) => ({ ...n, deps: n.edges })));
+        const sharedDirectories = selectRealizationDirs(store, pureGraph);
+        const productionGraph = {
+            ...graph,
+            nodes: graph.nodes.map((n) => ({
+                ...n,
+                edges: n.edges.filter((e) => !(n.kind === "local" && e.kind === "dev")),
+            })),
+        };
+        const db = openStoreDb(store.paths.dbFile);
+        const registered = new Set();
+        try {
+            if (typeof state.generationId !== "string" ||
+                !/^gen1_[a-z2-7]+$/.test(state.generationId) ||
+                state.projectId !== `project1_${sha512Hex(project).slice(0, 32)}` ||
+                state.storeRoot !== store.root ||
+                state.workspaceRoot !== project)
+                throw error("ZYRK_STORE_CORRUPT", "Workspace generation identity is invalid.");
+            const generation = db
+                .prepare("SELECT readiness,state,graph_digest FROM generations WHERE generation_id=? AND project_id=?")
+                .get(state.generationId, state.projectId);
+            if (generation?.readiness !== "ready" ||
+                generation.state !== "active" ||
+                generation.graph_digest !== state.graphDigest)
+                throw error("ZYRK_STORE_CORRUPT", "Workspace deployment requires its active ready generation.");
+            const rows = db
+                .prepare("SELECT ri.path,ri.instance_id FROM generation_instances gi JOIN realization_instances ri ON gi.instance_id=ri.instance_id WHERE gi.generation_id=? AND ri.verification_state='verified'")
+                .all(state.generationId);
+            if (!Array.isArray(state.instances) ||
+                rows.length !== state.instances.length ||
+                rows.some((row) => !state.instances.includes(row.instance_id)))
+                throw error("ZYRK_STORE_CORRUPT", "Workspace instance metadata disagrees with its selected generation.");
+            rows.forEach((row) => registered.add(row.path));
+        }
+        finally {
+            db.close();
+        }
+        if (state.linker === "private" && !object(state.buildProfile))
+            throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Workspace private generation has no supported build profile.");
+        const nativeProfile = state.buildProfile;
+        if (object(nativeProfile) &&
+            (typeof nativeProfile.candidate !== "string" ||
+                !/^[0-9a-f]{128}$/.test(nativeProfile.candidate) ||
+                state.privateDir !==
+                    path.join(project, ".zyrk-local/generations", String(state.generationId))))
+            throw error("ZYRK_STORE_CORRUPT", "Workspace private generation profile or stable directory is invalid.");
+        if (object(nativeProfile) &&
+            (nativeProfile.node !== process.version ||
+                nativeProfile.abi !== process.versions.modules ||
+                nativeProfile.platform !== process.platform ||
+                nativeProfile.arch !== process.arch))
+            throw error("ZYRK_PLATFORM_UNSUPPORTED", "Workspace private artifacts require their exact recorded Node ABI and profile.");
+        for (const key of selected) {
+            const n = byKey.get(key), directory = directories.get(key);
+            if (!directory)
+                throw error("ZYRK_OFFLINE_MISSING", "A required workspace runtime package is not installed.");
+            if (n.kind === "registry") {
+                const context = n.name.startsWith("@")
+                    ? path.resolve(directory, "../../..")
+                    : path.resolve(directory, "../..");
+                if (!registered.has(context) ||
+                    (!within(store.paths.realizationsDir, context) &&
+                        !within(path.join(project, ".zyrk-local/generations", String(state.generationId)), context)))
+                    throw error("ZYRK_DEPLOY_ESCAPE", "Workspace registry dependency is outside its registered realization.");
+                if (within(store.paths.realizationsDir, context)) {
+                    if (privateKeys.has(key) ||
+                        packageDirIn(sharedDirectories.get(key), n.name) !== directory)
+                        throw error("ZYRK_DEPLOY_ESCAPE", "Shared workspace registry dependency selects an unexpected context.");
+                    await verifyRealization({
+                        store,
+                        graph: pureGraph,
+                        rootKey: key,
+                        contextId: contextIdFor(pureGraph, key),
+                        realizationDirs: sharedDirectories,
+                    });
+                }
+                else {
+                    const expectedContexts = privateKeys.has(key)
+                        ? [
+                            workspaceContextId(graph, key, String(state.projectId)),
+                            workspaceContextId(productionGraph, key, String(state.projectId)),
+                        ]
+                        : [contextIdFor(sourceGraph, key)];
+                    if (!expectedContexts.some((id) => path.join(project, ".zyrk-local/generations", String(state.generationId), id) === context))
+                        throw error("ZYRK_DEPLOY_ESCAPE", "Private workspace dependency selects an unexpected live context.");
+                }
+                const m = await readJson(path.join(directory, "package.json"));
+                if (m.name !== n.name || m.version !== n.version)
+                    throw error("ZYRK_STORE_CORRUPT", "Workspace runtime package identity disagrees with its lock.");
+            }
+        }
+        const stage = await mkdtemp(path.join(parent, ".zyrk-deploy-"));
+        try {
+            const budget = { entries: 0, bytes: 0, started: Date.now() }, targets = new Map([[rootKey, stage]]);
+            for (const key of selected)
+                if (key !== rootKey)
+                    targets.set(key, packageDirIn(path.join(stage, "node_modules/.zyrk/portable", sha512Hex(key).slice(0, 40)), byKey.get(key).name));
+            for (const file of files)
+                await copyApplication(path.join(project, file), path.join(stage, file), project);
+            for (const key of selected) {
+                const n = byKey.get(key), target = targets.get(key), source = directories.get(key);
+                if (key !== rootKey) {
+                    const skip = new Set();
+                    if (n.kind === "local")
+                        skip.add("node_modules");
+                    else
+                        for (const e of n.edges)
+                            if (e.name === n.name)
+                                skip.add(path.join("node_modules", ...e.name.split("/")));
+                    await copyPrivatePayload(source, target, source, target, skip, [project, store.root], budget);
+                }
+                const sourceManifest = n.kind === "local"
+                    ? workspace.importers.find((i) => i.id === n.importer).manifest
+                    : await readJson(path.join(source, "package.json"));
+                const exported = { ...sourceManifest };
+                delete exported.devDependencies;
+                delete exported.zyrk;
+                delete exported.packageManager;
+                delete exported.workspaces;
+                await writeFile(path.join(target, "package.json"), JSON.stringify(exported, null, 2) + "\n");
+            }
+            for (const key of selected) {
+                const n = byKey.get(key);
+                for (const e of n.edges)
+                    if (selected.has(e.target) &&
+                        !(n.kind === "local" && e.kind === "dev")) {
+                        await relativeLink(path.join(targets.get(key), "node_modules", e.name), targets.get(e.target));
+                        const child = byKey.get(e.target);
+                        const rawBin = child.kind === "registry"
+                            ? child.bin
+                            : workspace.importers.find((i) => i.id === child.importer)
+                                .manifest.bin;
+                        const bins = typeof rawBin === "string"
+                            ? { [child.name.split("/").at(-1)]: rawBin }
+                            : object(rawBin)
+                                ? rawBin
+                                : {};
+                        for (const [name, relative] of Object.entries(bins)) {
+                            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name) ||
+                                typeof relative !== "string")
+                                throw error("ZYRK_DEPLOY_ESCAPE", "Workspace executable declaration is unsafe.");
+                            const pkg = targets.get(e.target), file = path.resolve(pkg, relative);
+                            if (!within(pkg, file))
+                                throw error("ZYRK_DEPLOY_ESCAPE", "Workspace executable escapes its runtime package.");
+                            const metadata = await lstat(file).catch(() => null);
+                            if (!metadata?.isFile())
+                                throw error("ZYRK_DEPLOY_NONRELOCATABLE", "A required workspace executable is missing.");
+                            const binDir = path.join(targets.get(key), "node_modules/.bin");
+                            await mkdir(binDir, { recursive: true });
+                            if (await lstat(path.join(binDir, name)).catch(() => null))
+                                throw error("ZYRK_DEPLOY_NONRELOCATABLE", "Workspace runtime executable names conflict.");
+                            if (metadata.mode & 0o111)
+                                await relativeLink(path.join(binDir, name), file);
+                            else
+                                await writeFile(path.join(binDir, name), '#!/bin/sh\nexec node "$(dirname "$0")"/' +
+                                    shellQuote(path.relative(binDir, file).split(path.sep).join("/")) +
+                                    ' "$@"\n', { mode: 0o755 });
+                        }
+                    }
+            }
+            if (!(await lstat(path.join(stage, entry)).catch(() => null))?.isFile())
+                throw error("ZYRK_DEPLOY_NONRELOCATABLE", "The selected runtime Node entry is missing.");
+            await scanPrivateExport(stage, [project, store.root], budget);
+            await validateLinks(stage, stage);
+            await writeFile(path.join(stage, "zyrk-deploy.json"), JSON.stringify({
+                schemaVersion: 1,
+                platform: process.platform,
+                arch: process.arch,
+                node: process.version,
+                entry: ["node", entry],
+                requirements: ["Node.js " + process.versions.node.split(".")[0]],
+                packages: selected.size - 1,
+                files,
+                validation: "structural; application smoke test not run",
+            }, null, 2) + "\n");
+            await rename(stage, out);
+            output(options, {
+                packages: selected.size - 1,
+                entry: ["node", entry],
+                validation: "structural",
+            }, `Exported ${selected.size - 1} workspace runtime packages. Start with: node ${entry}. Structural validation passed; no application smoke test ran.`);
+            return 0;
+        }
+        finally {
+            await rm(stage, { recursive: true, force: true });
+        }
+    }
+    finally {
+        await barrier.release();
+    }
+}

package/dist/commands/native-export.d.ts

@@ -0,0 +1,2 @@
+export declare function validateNativeExport(bytes: Buffer): void;
+//# sourceMappingURL=native-export.d.ts.map

package/dist/commands/native-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-export.d.ts","sourceRoot":"","sources":["../../src/commands/native-export.ts"],"names":[],"mappings":"AAYA,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CA4MxD"}

package/dist/commands/native-export.js

@@ -0,0 +1,192 @@
+/**
+ * Validated Linux ELF64 N-API copy recipe (§12.3.1).
+ *
+ * Only position-independent addons with no external dynamic-library imports,
+ * loader search paths or text relocations qualify. Undefined symbols are Node's
+ * tested integer/property entry points and the weak ELF toolchain hooks below.
+ * This recipe
+ * copies bytes unchanged; it never executes package code or rewrites binaries.
+ * The caller checks the exact build profile and scans host paths/credentials.
+ * Other native formats and dependency recipes require dedicated adapters.
+ */
+import { ZyrkError } from "../errors.js";
+export function validateNativeExport(bytes) {
+    const fail = () => {
+        throw new ZyrkError("ZYRK_DEPLOY_NONRELOCATABLE", "Native artifact is outside the supported Linux ELF64 N-API export recipe.", {
+            remedy: "Use a position-independent N-API addon without external dynamic libraries or loader paths, or supply a validated target rebuild adapter.",
+        });
+    };
+    const range = (offset, size) => {
+        if (!Number.isSafeInteger(offset) ||
+            !Number.isSafeInteger(size) ||
+            offset < 0 ||
+            size < 0 ||
+            offset + size > bytes.length)
+            fail();
+    };
+    if (process.platform !== "linux" ||
+        process.arch !== "x64" ||
+        bytes.length < 64 ||
+        bytes.length > 64 * 1024 * 1024 ||
+        bytes.subarray(0, 4).toString("hex") !== "7f454c46" ||
+        bytes[4] !== 2 ||
+        bytes[5] !== 1 ||
+        bytes[6] !== 1)
+        fail();
+    if (bytes.readUInt16LE(16) !== 3 ||
+        bytes.readUInt16LE(18) !== 62 ||
+        bytes.readUInt16LE(52) !== 64 ||
+        bytes.readUInt32LE(20) !== 1)
+        fail();
+    const programs = Number(bytes.readBigUInt64LE(32)), programSize = bytes.readUInt16LE(54), programCount = bytes.readUInt16LE(56);
+    if (programSize !== 56 || programCount === 0 || programCount > 1024)
+        fail();
+    range(programs, programSize * programCount);
+    let loaderDynamic;
+    const segments = [];
+    for (let i = 0; i < programCount; i++) {
+        const p = programs + i * programSize, type = bytes.readUInt32LE(p), offset = Number(bytes.readBigUInt64LE(p + 8)), fileSize = Number(bytes.readBigUInt64LE(p + 32)), memorySize = Number(bytes.readBigUInt64LE(p + 40)), address = Number(bytes.readBigUInt64LE(p + 16));
+        if (!Number.isSafeInteger(address) ||
+            !Number.isSafeInteger(memorySize) ||
+            fileSize > memorySize)
+            fail();
+        range(offset, fileSize);
+        if (type === 3)
+            fail();
+        if (type === 1)
+            segments.push({ offset, size: fileSize, address });
+        if (type === 2) {
+            if (loaderDynamic)
+                fail();
+            if (fileSize !== memorySize)
+                fail();
+            loaderDynamic = { offset, size: fileSize, address };
+        }
+    }
+    const table = Number(bytes.readBigUInt64LE(40)), size = bytes.readUInt16LE(58), count = bytes.readUInt16LE(60);
+    if (size !== 64 || count === 0 || count > 4096)
+        fail();
+    range(table, size * count);
+    const section = (index) => {
+        if (index < 0 || index >= count)
+            fail();
+        const p = table + index * size;
+        return {
+            type: bytes.readUInt32LE(p + 4),
+            address: Number(bytes.readBigUInt64LE(p + 16)),
+            offset: Number(bytes.readBigUInt64LE(p + 24)),
+            size: Number(bytes.readBigUInt64LE(p + 32)),
+            link: bytes.readUInt32LE(p + 40),
+            entry: Number(bytes.readBigUInt64LE(p + 56)),
+        };
+    };
+    const mapped = (region) => {
+        if (!segments.some((segment) => region.offset >= segment.offset &&
+            region.offset + region.size <= segment.offset + segment.size &&
+            region.address === segment.address + region.offset - segment.offset))
+            fail();
+    };
+    const tags = new Map();
+    let symbols, strings;
+    let registration = false, api = false, dynamic = false;
+    const validatedApi = new Set([
+        "napi_create_int32",
+        "napi_set_named_property",
+    ]);
+    const weakHooks = new Set([
+        "__cxa_finalize",
+        "__gmon_start__",
+        "_ITM_registerTMCloneTable",
+        "_ITM_deregisterTMCloneTable",
+    ]);
+    for (let i = 0; i < count; i++) {
+        const s = section(i);
+        if (s.type !== 6 && s.type !== 11)
+            continue;
+        range(s.offset, s.size);
+        if (s.type === 6) {
+            if (dynamic ||
+                !loaderDynamic ||
+                loaderDynamic.offset !== s.offset ||
+                loaderDynamic.size !== s.size ||
+                loaderDynamic.address !== s.address)
+                fail();
+            mapped(s);
+            dynamic = true;
+            if (s.entry !== 16 || s.size % 16 !== 0)
+                fail();
+            let terminated = false;
+            for (let p = s.offset; p < s.offset + s.size; p += 16) {
+                const tag = bytes.readBigInt64LE(p), value = bytes.readBigUInt64LE(p + 8);
+                if (tag === 0n) {
+                    terminated = true;
+                    break;
+                }
+                if ([5n, 6n, 10n, 11n].includes(tag) && tags.has(tag))
+                    fail();
+                tags.set(tag, value);
+                if ([
+                    1n,
+                    15n,
+                    22n,
+                    29n,
+                    0x7fffffffn,
+                    0x7ffffffdn,
+                    0x6ffffefbn,
+                    0x6ffffefcn,
+                ].includes(tag) ||
+                    (tag === 30n && (value & 4n) !== 0n))
+                    fail();
+            }
+            if (!terminated)
+                fail();
+        }
+        else {
+            if (symbols)
+                fail();
+            symbols = s;
+            mapped(s);
+            if (s.entry !== 24 || s.size % 24 !== 0)
+                fail();
+            const names = section(s.link);
+            strings = names;
+            mapped(names);
+            if (names.type !== 3)
+                fail();
+            range(names.offset, names.size);
+            for (let p = s.offset; p < s.offset + s.size; p += 24) {
+                const nameOffset = bytes.readUInt32LE(p), info = bytes[p + 4], index = bytes.readUInt16LE(p + 6);
+                if (nameOffset >= names.size)
+                    fail();
+                const start = names.offset + nameOffset, end = bytes.indexOf(0, start);
+                if (end < start || end >= names.offset + names.size)
+                    fail();
+                const name = bytes.subarray(start, end).toString("utf8");
+                if (index === 0 && name) {
+                    if (validatedApi.has(name))
+                        api = true;
+                    else if (!(info >> 4 === 2 && weakHooks.has(name)))
+                        fail();
+                }
+                if (name === "napi_register_module_v1" &&
+                    index !== 0 &&
+                    (info & 15) === 2)
+                    registration = true;
+            }
+        }
+    }
+    if (!dynamic || !registration || !api || !symbols || !strings)
+        return fail();
+    if (tags.get(6n) !== BigInt(symbols.address) ||
+        tags.get(11n) !== 24n ||
+        tags.get(5n) !== BigInt(strings.address) ||
+        tags.get(10n) !== BigInt(strings.size))
+        fail();
+    // The dependency-free recipe has no legitimate external filesystem prerequisite.
+    // Reject literal absolute path strings; encoded paths require another adapter.
+    for (const text of bytes.toString("latin1").split("\0")) {
+        if (/^[\x20-\x7e]{4,}$/.test(text) &&
+            /(?:^|[\s"'=])(?:\/[A-Za-z0-9_.~-]|[A-Za-z]:[\\/])/.test(text))
+            fail();
+    }
+}

package/dist/install/import-npm-workspace.d.ts

@@ -0,0 +1,5 @@
+import type { NpmLockDoc } from "../lockfile/types.ts";
+import type { WorkspaceProject } from "./workspaces.ts";
+import type { WorkspaceGraph } from "./workspace-graph.ts";
+export declare function importNpmWorkspaceLock(doc: NpmLockDoc, project: WorkspaceProject, origin: string): WorkspaceGraph;
+//# sourceMappingURL=import-npm-workspace.d.ts.map

package/dist/install/import-npm-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-npm-workspace.d.ts","sourceRoot":"","sources":["../../src/install/import-npm-workspace.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAQvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,sBAAsB,CAAC;AAE9B,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,GACb,cAAc,CAyThB"}

package/dist/install/import-npm-workspace.js

@@ -0,0 +1,283 @@
+/** Translate npm's physical virtual tree without selecting new registry versions. */
+import * as path from "node:path";
+import { satisfies } from "semver";
+import { validateLockDoc } from "../lockfile/read.js";
+import { sha512Hex } from "../util/hash.js";
+import { canonicalJson } from "../util/json.js";
+import { importNpmLock } from "./import-npm.js";
+import { lockMismatch, cleanUrl } from "./lock.js";
+import { ZyrkError } from "../errors.js";
+import { assertWorkspacePlatform } from "./workspace-graph.js";
+export function importNpmWorkspaceLock(doc, project, origin) {
+    if (!doc ||
+        typeof doc !== "object" ||
+        Array.isArray(doc) ||
+        !doc.packages ||
+        typeof doc.packages !== "object" ||
+        Array.isArray(doc.packages) ||
+        Object.values(doc.packages).some((e) => !e || typeof e !== "object" || Array.isArray(e)))
+        throw lockMismatch("npm workspace lock has malformed package entries");
+    const portable = structuredClone(doc);
+    // Relative file declarations are representable only when they name a
+    // discovered live importer. Validate their targets before URL validation.
+    const importerIds = new Set(project.importers.map((i) => (i.id === "." ? "" : i.id)));
+    for (const [location, entry] of Object.entries(portable.packages ?? {}))
+        for (const group of [
+            "dependencies",
+            "devDependencies",
+            "optionalDependencies",
+            "peerDependencies",
+        ])
+            if (entry[group] && typeof entry[group] === "object")
+                for (const [name, spec] of Object.entries(entry[group]))
+                    if (typeof spec === "string" && spec.startsWith("file:")) {
+                        const relative = spec.slice(5);
+                        if (!importerIds.has(location) ||
+                            relative.startsWith("/") ||
+                            relative.includes("\\") ||
+                            /^[A-Za-z]:/.test(relative) ||
+                            !importerIds.has(path.posix.normalize(path.posix.join(location, relative))))
+                            throw lockMismatch("npm file declaration is not a declared workspace");
+                        entry[group][name] = "workspace:*";
+                    }
+    // npm v2 also has a redundant legacy dependency view. Do not adopt a
+    // second authority; it is still scanned for unsafe metadata.
+    const sanitizeLegacyLinks = (value) => {
+        if (typeof value === "string" &&
+            value.startsWith("file:") &&
+            importerIds.has(value.slice(5)))
+            return "workspace:*";
+        if (Array.isArray(value))
+            return value.map(sanitizeLegacyLinks);
+        if (value && typeof value === "object")
+            return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+                key,
+                sanitizeLegacyLinks(child),
+            ]));
+        return value;
+    };
+    if (portable.dependencies)
+        portable.dependencies = sanitizeLegacyLinks(portable.dependencies);
+    validateLockDoc(portable, "package-lock.json");
+    if (doc.zyrk ||
+        ![2, 3].includes(doc.lockfileVersion ?? 0) ||
+        !doc.packages ||
+        !cleanUrl(origin))
+        throw lockMismatch("workspace adoption needs an unannotated npm v2/v3 lock");
+    const packages = doc.packages;
+    const graph = { nodes: [], importers: {}, omissions: [] };
+    const locations = new Map();
+    const local = new Map(project.importers.map((i) => [i.id === "." ? "" : i.id, i]));
+    for (const [location, entry] of Object.entries(packages)) {
+        if (location.includes("\\") ||
+            location.startsWith("/") ||
+            location.split("/").some((s) => s === ".." || s === ".") ||
+            location.includes("\0"))
+            throw lockMismatch("unsafe npm package location");
+        if (entry.link === true &&
+            (typeof entry.resolved !== "string" ||
+                !local.has(entry.resolved) ||
+                entry.resolved === ""))
+            throw lockMismatch("npm link does not select a declared workspace");
+        if (entry.inBundle === true)
+            throw lockMismatch("bundled npm selections are unsupported");
+    }
+    for (const [location, importer] of local) {
+        const entry = packages[location];
+        if (!entry || entry.link)
+            throw lockMismatch("npm lock lacks a workspace importer");
+        for (const field of [
+            "dependencies",
+            "devDependencies",
+            "optionalDependencies",
+            "peerDependencies",
+            "peerDependenciesMeta",
+            "workspaces",
+        ])
+            if (canonicalJson(entry[field] ?? {}) !==
+                canonicalJson(importer.manifest[field] ?? {}))
+                throw lockMismatch("npm workspace manifest declarations differ");
+        if (location &&
+            ((entry.name !== undefined && entry.name !== importer.manifest.name) ||
+                entry.version !== importer.manifest.version))
+            throw lockMismatch("npm workspace identity differs");
+        const node = {
+            kind: "local",
+            key: `workspace:${importer.id}`,
+            name: importer.manifest.name ?? "workspace-root",
+            version: importer.manifest.version ?? "0.0.0",
+            importer: importer.id,
+            edges: [],
+            peers: {},
+            optionalPeers: [],
+        };
+        graph.importers[importer.id] = node.key;
+        graph.nodes.push(node);
+        locations.set(location, node);
+    }
+    const find = (from, name) => {
+        let current = from;
+        for (;;) {
+            if (!current.endsWith("node_modules")) {
+                const slot = `${current ? current + "/" : ""}node_modules/${name}`;
+                if (Object.hasOwn(packages, slot))
+                    return slot;
+            }
+            if (!current)
+                return undefined;
+            current = current.includes("/")
+                ? current.slice(0, current.lastIndexOf("/"))
+                : "";
+        }
+    };
+    const populated = new Set();
+    const load = (location, name, spec, from) => {
+        const entry = packages[location];
+        if (entry.link === true) {
+            const target = locations.get(entry.resolved);
+            const range = spec.startsWith("workspace:") ? spec.slice(10) : spec;
+            if (spec.startsWith("file:")
+                ? path.posix.normalize(path.posix.join(from, spec.slice(5))) !==
+                    (target.kind === "local" ? target.importer : "")
+                : name !== target.name ||
+                    (!["*", "^", "~"].includes(range) &&
+                        !satisfies(target.version, range)))
+                throw lockMismatch("npm workspace link disagrees with requirement");
+            return target;
+        }
+        // Reuse the strict single-selection adapter's archive, alias, source and
+        // platform validation. Dependencies are wired below using npm locations.
+        const shallow = { ...entry };
+        delete shallow.dependencies;
+        delete shallow.optionalDependencies;
+        delete shallow.peerDependencies;
+        const selected = importNpmLock({
+            lockfileVersion: 3,
+            packages: { "": {}, [`node_modules/${name}`]: shallow },
+        }, { [name]: spec }, origin).nodes[0];
+        let node = locations.get(location);
+        if (!node) {
+            const { peerBindings: _bindings, ...source } = selected;
+            node = {
+                ...source,
+                key: `${selected.name}@${selected.version}#${sha512Hex(location).slice(0, 16)}`,
+                kind: "registry",
+                edges: [],
+                peers: {},
+                optionalPeers: [],
+            };
+            assertWorkspacePlatform({ nodes: [node], importers: {}, omissions: [] });
+            graph.nodes.push(node);
+            locations.set(location, node);
+        }
+        try {
+            populate(location, node);
+        }
+        catch (cause) {
+            populated.delete(location);
+            locations.delete(location);
+            graph.nodes = graph.nodes.filter((n) => n !== node);
+            throw cause;
+        }
+        return node;
+    };
+    const populate = (location, node) => {
+        if (populated.has(location))
+            return;
+        if (populated.size >= 10000)
+            throw lockMismatch("npm import resource limit exceeded");
+        populated.add(location);
+        const entry = packages[location];
+        const requirements = new Map();
+        for (const [field, kind] of [
+            ["dependencies", "prod"],
+            ["devDependencies", "dev"],
+            ["optionalDependencies", "optional"],
+            ["peerDependencies", "peer"],
+        ]) {
+            if (kind === "dev" && node.kind !== "local")
+                continue;
+            const values = entry[field];
+            if (values === undefined)
+                continue;
+            if (!values || typeof values !== "object" || Array.isArray(values))
+                throw lockMismatch("invalid npm dependency declarations");
+            for (const [name, spec] of Object.entries(values)) {
+                if (typeof spec !== "string")
+                    throw lockMismatch("invalid npm dependency requirement");
+                // A peer declaration does not replace an existing regular dependency.
+                if (kind !== "peer" || !requirements.has(name))
+                    requirements.set(name, { spec, kind });
+            }
+        }
+        for (const [name, requirement] of requirements) {
+            const meta = entry.peerDependenciesMeta;
+            const optionalPeer = requirement.kind === "peer" && meta?.[name]?.optional === true;
+            if (optionalPeer)
+                node.optionalPeers.push(name);
+            const targetLocation = find(location, name);
+            if (targetLocation === undefined) {
+                if (optionalPeer) {
+                    node.peers[name] = null;
+                    continue;
+                }
+                if (requirement.kind === "optional")
+                    continue;
+                throw lockMismatch("npm workspace lock is missing a required selection");
+            }
+            let target;
+            try {
+                target = load(targetLocation, name, requirement.spec, location);
+            }
+            catch (cause) {
+                if (requirement.kind === "optional" &&
+                    cause instanceof ZyrkError &&
+                    cause.code === "ZYRK_PLATFORM_UNSUPPORTED") {
+                    graph.omissions.push({ name, parent: node.key, reason: "platform" });
+                    continue;
+                }
+                throw cause;
+            }
+            node.edges.push({ name, target: target.key, ...requirement });
+            if (requirement.kind === "peer")
+                node.peers[name] = target.key;
+        }
+        // npm allows the same name in dependencies and peerDependencies. Its
+        // ordinary edge keeps its kind, but the peer range and binding still apply.
+        const peers = entry.peerDependencies;
+        const meta = entry.peerDependenciesMeta;
+        for (const [name, spec] of Object.entries(peers ?? {})) {
+            if (Object.hasOwn(node.peers, name))
+                continue;
+            const optional = meta?.[name]?.optional === true;
+            if (optional)
+                node.optionalPeers.push(name);
+            const targetLocation = find(location, name);
+            if (targetLocation === undefined) {
+                if (!optional)
+                    throw lockMismatch("npm workspace lock is missing a required peer");
+                node.peers[name] = null;
+                continue;
+            }
+            const target = load(targetLocation, name, spec, location);
+            node.peers[name] = target.key;
+            if (!node.edges.some((edge) => edge.name === name))
+                node.edges.push({ name, target: target.key, kind: "peer", spec });
+        }
+    };
+    for (const [location] of local)
+        populate(location, locations.get(location));
+    const reachable = new Set(), pending = Object.values(graph.importers), byKey = new Map(graph.nodes.map((n) => [n.key, n]));
+    while (pending.length) {
+        const key = pending.pop();
+        if (reachable.has(key))
+            continue;
+        reachable.add(key);
+        for (const edge of byKey.get(key).edges)
+            pending.push(edge.target);
+    }
+    graph.nodes = graph.nodes.filter((n) => reachable.has(n.key));
+    graph.omissions = graph.omissions.filter((o) => reachable.has(o.parent));
+    graph.nodes.sort((a, b) => a.key.localeCompare(b.key));
+    return graph;
+}

package/dist/install/workspace-install.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace-install.d.ts","sourceRoot":"","sources":["../../src/install/workspace-install.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AA8E9D,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC,CAmpBxB"}
+{"version":3,"file":"workspace-install.d.ts","sourceRoot":"","sources":["../../src/install/workspace-install.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAyH9D,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC,CAopBxB"}

package/dist/install/workspace-install.js

@@ -4,6 +4,7 @@ import { constants } from "node:fs";
 import * as path from "node:path";
 import { discoverWorkspaces, findWorkspaceRoot, assertNoLiveSourceBuilds, } from "./workspaces.js";
 import { resolveWorkspaceGraph, workspaceRegistryOccurrences, workspaceContextId, assertWorkspacePlatform, } from "./workspace-graph.js";
+import { importNpmWorkspaceLock } from "./import-npm-workspace.js";
 import { readWorkspaceLock, workspaceLockDoc } from "./workspace-lock.js";
 import { publishWorkspaceProjection, recoverWorkspaceProjection, workspaceProjectionPaths, } from "./workspace-transaction.js";
 import { ZyrkError } from "../errors.js";
@@ -48,10 +49,40 @@ async function realDirectory(directory) {
     if (!st.isDirectory() || st.isSymbolicLink())
         throw lockMismatch("workspace control parent must be a real directory");
 }
+async function readNpmWorkspaceImport(root, project, options) {
+    if (options.frozen || options.offline)
+        throw lockMismatch("npm workspace adoption needs a non-frozen online install");
+    if (await pathExists(path.join(root, "npm-shrinkwrap.json")))
+        throw lockMismatch("npm-shrinkwrap.json takes npm precedence; workspace adoption currently supports package-lock.json only");
+    let npmDoc;
+    try {
+        npmDoc = JSON.parse(await readFile(path.join(root, "package-lock.json"), "utf8"));
+    }
+    catch {
+        throw lockMismatch("npm workspace adoption needs an existing readable JSON lock");
+    }
+    const graph = importNpmWorkspaceLock(npmDoc, project, options.registry.origin);
+    // Prove the complete graph and ordinary npm projection are representable
+    // before any project state is created. Actual policy fingerprints are added
+    // under the install lock after policy validation.
+    workspaceLockDoc(project, graph, {
+        manifest: project.manifestFingerprint,
+        scripts: scriptPolicyFingerprint(undefined),
+        config: configFingerprint({
+            registry: options.registry.origin,
+            linker: "shared",
+        }),
+    });
+    return graph;
+}
 export async function installWorkspaceProject(options) {
     const root = await findWorkspaceRoot(options.projectDir);
     if (!root)
         throw lockMismatch("no authoritative workspace root");
+    // Refuse untranslatable locks before creating control directories or
+    // recovering a previous generation. Revalidate under the project lock below.
+    if (options.importNpm)
+        await readNpmWorkspaceImport(root, await discoverWorkspaces(root), options);
     await realDirectory(path.join(root, ".zyrk-local"));
     const held = await acquireLock(path.join(root, ".zyrk-local/project.lock"), {
         name: "workspace install",
@@ -66,8 +97,6 @@ export async function installWorkspaceProject(options) {
             i.id,
             await readFile(path.join(i.directory, "package.json"), "utf8"),
         ])));
-        if (options.importNpm)
-            unsupported("Workspace npm-lock adoption needs its multi-importer adapter.");
         const mutation = await prepareWorkspaceMutation(project, options);
         if (manifest.overrides !== undefined ||
             manifest.bundledDependencies !== undefined ||
@@ -110,7 +139,12 @@ export async function installWorkspaceProject(options) {
                 ...(patchDigest ? { patches: patchDigest } : {}),
             }),
         };
-        let existing = await readWorkspaceLock(root, project, options.registry.origin), graph;
+        const imported = options.importNpm
+            ? await readNpmWorkspaceImport(root, project, options)
+            : undefined;
+        let existing = options.importNpm
+            ? null
+            : await readWorkspaceLock(root, project, options.registry.origin), graph = imported;
         if (existing) {
             const ext = existing.doc.zyrk;
             if (!mutation.changed &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyrk",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "Storage-efficient Node package manager: one verified store per user, shared across projects through links.",
   "license": "MIT",
   "type": "module",
@@ -32,7 +32,7 @@
   },
   "devDependencies": {
     "@npmcli/arborist": "10.0.3",
-    "@types/node": "^24.19.2",
+    "@types/node": "^26.6.5",
     "@types/semver": "^7.8.0",
     "prettier": "3.9.10",
     "typescript": "^7.0.2",