@layerzerolabs/vm-tooling 0.2.113 → 0.2.114

package/dist/mini-workspace/mini-workspace.test.js

@@ -0,0 +1,643 @@
+import { afterAll, describe, it, globalExpect } from '../5GPTK3MH.js';
+import { createMiniWorkspace } from '../WIT6LHNF.js';
+import { resolveWorkspaceDependencyGraph } from '../ID575YY3.js';
+import { copyWorkspaceSources, DEFAULT_SOURCE_COPY_PATTERNS } from '../BTTCOAYB.js';
+import '../SKMNEOBU.js';
+import { copyRootNodeModulesSymlinks, getPnpmVirtualStoreMount } from '../ZBEXHZRK.js';
+import '../LYF4JPSK.js';
+import '../UBSQYHMB.js';
+import { init_esm_shims, __dirname as __dirname$1, __name } from '../6M2RYAT4.js';
+import { mkdtempSync, rmSync, mkdirSync, realpathSync, symlinkSync, existsSync, lstatSync, readlinkSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+// src/mini-workspace/mini-workspace.test.ts
+init_esm_shims();
+var TMP = mkdtempSync(join(tmpdir(), "lz-mini-workspace-test-"));
+var GENERATED_MINI_ROOTS = [];
+var trackMiniRoot = /* @__PURE__ */ __name((miniRoot) => {
+  GENERATED_MINI_ROOTS.push(miniRoot);
+  return miniRoot;
+}, "trackMiniRoot");
+var createPackage = /* @__PURE__ */ __name((dir, name, files = {}) => {
+  mkdirSync(dir, {
+    recursive: true
+  });
+  writeFileSync(join(dir, "package.json"), JSON.stringify({
+    name,
+    version: "0.0.0"
+  }));
+  for (const [file, content] of Object.entries(files)) {
+    const filePath = join(dir, file);
+    mkdirSync(join(filePath, ".."), {
+      recursive: true
+    });
+    writeFileSync(filePath, content);
+  }
+}, "createPackage");
+var createRepo = /* @__PURE__ */ __name((name) => {
+  const repo = join(TMP, name);
+  mkdirSync(repo, {
+    recursive: true
+  });
+  writeFileSync(join(repo, "pnpm-workspace.yaml"), 'packages:\n  - "**"\n');
+  return repo;
+}, "createRepo");
+var writeLockfile = /* @__PURE__ */ __name((repo, body) => {
+  writeFileSync(join(repo, "pnpm-lock.yaml"), [
+    "lockfileVersion: '9.0'",
+    "",
+    "settings:",
+    "  autoInstallPeers: true",
+    "",
+    "importers:",
+    body.trimEnd(),
+    "",
+    "packages:",
+    ""
+  ].join("\n"));
+}, "writeLockfile");
+afterAll(() => {
+  rmSync(TMP, {
+    recursive: true,
+    force: true
+  });
+  for (const miniRoot of GENERATED_MINI_ROOTS) {
+    rmSync(miniRoot, {
+      recursive: true,
+      force: true
+    });
+  }
+});
+describe(resolveWorkspaceDependencyGraph, () => {
+  it("follows transitive workspace link deps", async () => {
+    const repo = createRepo("dependency-graph");
+    const current = join(repo, "apps", "current");
+    const depA = join(repo, "packages", "dep-a");
+    const depB = join(repo, "packages", "dep-b");
+    const tooling = join(repo, "tools", "vm-utils", "solana", "build-utils");
+    createPackage(current, "@layerzerolabs/current");
+    createPackage(depA, "@layerzerolabs/dep-a");
+    createPackage(depB, "@layerzerolabs/dep-b");
+    createPackage(tooling, "@layerzerolabs/build-utils-solana");
+    writeLockfile(repo, `
+  apps/current:
+    dependencies:
+      '@layerzerolabs/dep-a':
+        specifier: workspace:*
+        version: link:../../packages/dep-a
+      '@layerzerolabs/build-utils-solana':
+        specifier: workspace:*
+        version: link:../../tools/vm-utils/solana/build-utils
+
+  .:
+    devDependencies:
+      eslint:
+        specifier: ^9.0.0
+        version: 9.0.0
+      '@layerzerolabs/dep-a':
+        specifier: workspace:*
+        version: link:packages/dep-a
+      '@layerzerolabs/build-utils-solana':
+        specifier: workspace:*
+        version: link:tools/vm-utils/solana/build-utils
+
+  packages/dep-a:
+    dependencies:
+      eslint:
+        specifier: ^9.0.0
+        version: 9.0.0
+      '@layerzerolabs/dep-b':
+        specifier: workspace:*
+        version: link:../dep-b
+
+  packages/dep-b:
+    dependencies:
+      '@layerzerolabs/dep-a':
+        specifier: workspace:*
+        version: link:../dep-a
+
+  tools/vm-utils/solana/build-utils:
+    devDependencies: {}
+`);
+    const dependencyGraph = await resolveWorkspaceDependencyGraph({
+      cwd: current,
+      repoRoot: repo
+    });
+    const includedRelativePaths = dependencyGraph.includedWorkspaceDependencies.map((dependency) => dependency.relativePath);
+    globalExpect(includedRelativePaths).toHaveLength(3);
+    globalExpect(includedRelativePaths).toEqual(globalExpect.arrayContaining([
+      "packages/dep-a",
+      "packages/dep-b",
+      "tools/vm-utils/solana/build-utils"
+    ]));
+    globalExpect(dependencyGraph.rootNodeModulesDependencyNames).toHaveLength(3);
+    globalExpect(dependencyGraph.rootNodeModulesDependencyNames).toEqual(globalExpect.arrayContaining([
+      "@layerzerolabs/build-utils-solana",
+      "@layerzerolabs/dep-a",
+      "eslint"
+    ]));
+  });
+  it("resolves nested command directories to their ancestor package importer", async () => {
+    const repo = createRepo("nested-current");
+    const current = join(repo, "packages", "onesig", "onesig-starknet");
+    const contracts = join(current, "contracts");
+    const dep = join(repo, "packages", "protocol-starknet-v2");
+    createPackage(current, "@layerzerolabs/onesig-starknet", {
+      "contracts/Scarb.toml": '[package]\nname = "onesig"\n'
+    });
+    createPackage(dep, "@layerzerolabs/protocol-starknet-v2");
+    mkdirSync(contracts, {
+      recursive: true
+    });
+    writeLockfile(repo, `
+  packages/onesig/onesig-starknet:
+    devDependencies:
+      '@layerzerolabs/protocol-starknet-v2':
+        specifier: workspace:*
+        version: link:../../protocol-starknet-v2
+
+  .:
+    devDependencies:
+      '@layerzerolabs/protocol-starknet-v2':
+        specifier: workspace:*
+        version: link:packages/protocol-starknet-v2
+
+  packages/protocol-starknet-v2:
+    devDependencies: {}
+`);
+    const dependencyGraph = await resolveWorkspaceDependencyGraph({
+      cwd: contracts,
+      repoRoot: repo
+    });
+    globalExpect(dependencyGraph.packageRoot).toBe(realpathSync(current));
+    globalExpect(dependencyGraph.packageRelativePath).toBe("packages/onesig/onesig-starknet");
+    globalExpect(dependencyGraph.includedWorkspaceDependencies.map((dependency) => dependency.relativePath)).toEqual([
+      "packages/protocol-starknet-v2"
+    ]);
+    globalExpect(dependencyGraph.rootNodeModulesDependencyNames).toEqual([
+      "@layerzerolabs/protocol-starknet-v2"
+    ]);
+  });
+  it("uses the real repository lockfile to include transitive anchor-trait for console-oft", async () => {
+    const repo = join(__dirname$1, "..", "..", "..", "..", "..");
+    const dependencyGraph = await resolveWorkspaceDependencyGraph({
+      cwd: join(repo, "apps/project-types/console-oft-app/contracts/solana"),
+      repoRoot: repo
+    });
+    globalExpect(dependencyGraph.includedWorkspaceDependencies.map((dependency) => dependency.name)).toContain("@layerzerolabs/framework-solana-anchor-trait");
+  });
+  it("invalidates cached lockfile importers when the lockfile changes", async () => {
+    const repo = createRepo("dependency-graph-cache-invalidation");
+    const current = join(repo, "apps", "current");
+    const depA = join(repo, "packages", "dep-a");
+    const depB = join(repo, "packages", "dep-b");
+    createPackage(current, "@layerzerolabs/current");
+    createPackage(depA, "@layerzerolabs/dep-a");
+    createPackage(depB, "@layerzerolabs/dep-b");
+    writeLockfile(repo, `
+  apps/current:
+    dependencies:
+      '@layerzerolabs/dep-a':
+        specifier: workspace:*
+        version: link:../../packages/dep-a
+
+  packages/dep-a:
+    devDependencies: {}
+`);
+    const firstGraph = await resolveWorkspaceDependencyGraph({
+      cwd: current,
+      repoRoot: repo
+    });
+    writeLockfile(repo, `
+  apps/current:
+    dependencies:
+      '@layerzerolabs/dep-b':
+        specifier: workspace:*
+        version: link:../../packages/dep-b
+
+  packages/dep-b:
+    devDependencies: {}
+
+  # Keep the rewritten lockfile size different so mtime+size invalidation is exercised.
+`);
+    const secondGraph = await resolveWorkspaceDependencyGraph({
+      cwd: current,
+      repoRoot: repo
+    });
+    globalExpect(firstGraph.includedWorkspaceDependencies.map((dependency) => dependency.relativePath)).toEqual([
+      "packages/dep-a"
+    ]);
+    globalExpect(secondGraph.includedWorkspaceDependencies.map((dependency) => dependency.relativePath)).toEqual([
+      "packages/dep-b"
+    ]);
+  });
+});
+describe(copyWorkspaceSources, () => {
+  it("copies dependency sources and dist outputs while excluding the current package and heavyweight generated output directories", async () => {
+    const repo = createRepo("workspace-source-copy");
+    const current = join(repo, "apps", "current");
+    const dep = join(repo, "packages", "dep");
+    createPackage(current, "@layerzerolabs/current", {
+      "src/index.ts": "export const current = true",
+      "target/deploy/current.so": "compiled"
+    });
+    createPackage(dep, "@layerzerolabs/dep", {
+      "src/index.ts": "export const dep = true",
+      "target/deploy/program.so": "compiled",
+      "target/wasm32v1-none/release/program.d": "program.wasm: src/lib.rs",
+      "target/wasm32v1-none/release/program.wasm": "compiled wasm",
+      "node_modules/pkg/index.js": "module.exports = {}",
+      "dist/index.js": "module.exports = {}",
+      "artifacts/contracts/Contract.json": "{}"
+    });
+    symlinkSync("../../../../node_modules/.pnpm/linked-pkg@1.0.0/node_modules/linked-pkg", join(dep, "node_modules", "linked-pkg"));
+    symlinkSync("src/index.ts", join(dep, "src-link.ts"));
+    const dependencyGraph = {
+      repoRoot: repo,
+      packageRoot: current,
+      packageRelativePath: "apps/current",
+      rootNodeModulesDependencyNames: [],
+      includedWorkspaceDependencies: [
+        {
+          name: "@layerzerolabs/dep",
+          importerRelativePath: "apps/current",
+          relativePath: "packages/dep",
+          absolutePath: dep,
+          version: "link:../../packages/dep"
+        }
+      ]
+    };
+    const result = await copyWorkspaceSources({
+      dependencyGraph
+    });
+    const miniRoot = trackMiniRoot(result.miniRoot);
+    globalExpect(result.copiedWorkspaceDependencies).toHaveLength(1);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "target", "deploy"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "target", "wasm32v1-none", "release", "program.d"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "target", "wasm32v1-none", "release", "program.wasm"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "node_modules"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "node_modules", "pkg", "index.js"))).toBe(false);
+    globalExpect(lstatSync(join(miniRoot, "packages", "dep", "node_modules", "linked-pkg")).isSymbolicLink()).toBe(true);
+    globalExpect(readlinkSync(join(miniRoot, "packages", "dep", "node_modules", "linked-pkg"))).toBe("../../../../node_modules/.pnpm/linked-pkg@1.0.0/node_modules/linked-pkg");
+    globalExpect(lstatSync(join(miniRoot, "packages", "dep", "src-link.ts")).isSymbolicLink()).toBe(true);
+    globalExpect(readlinkSync(join(miniRoot, "packages", "dep", "src-link.ts"))).toBe("src/index.ts");
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "dist", "index.js"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "artifacts"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "apps", "current"))).toBe(false);
+  });
+  it("applies glob-compatible mini-workspace prune patterns to dependency source copies", async () => {
+    const repo = createRepo("workspace-source-pattern-copy");
+    const current = join(repo, "apps", "current");
+    const dep = join(repo, "packages", "dep");
+    createPackage(current, "@layerzerolabs/current");
+    createPackage(dep, "@layerzerolabs/dep", {
+      "src/index.ts": "export const dep = true",
+      "README.md": "# dep",
+      LICENSE: "MIT",
+      "sdk/client.ts": "export const sdk = true",
+      "scripts/dev.ts": "export const dev = true",
+      "tests/fixture.ts": "export const secret = true",
+      "node_modules/pkg/index.js": "module.exports = {}",
+      "programs/demo/src/lib.rs": "pub fn process() {}",
+      "programs/demo/tests/integration.rs": "#[test] fn it_works() {}",
+      "target/deploy/program.so": "compiled"
+    });
+    symlinkSync("../src/index.ts", join(dep, "node_modules", "dep-link"));
+    const dependencyGraph = {
+      repoRoot: repo,
+      packageRoot: current,
+      packageRelativePath: "apps/current",
+      rootNodeModulesDependencyNames: [],
+      includedWorkspaceDependencies: [
+        {
+          name: "@layerzerolabs/dep",
+          importerRelativePath: "apps/current",
+          relativePath: "packages/dep",
+          absolutePath: dep,
+          version: "link:../../packages/dep"
+        }
+      ]
+    };
+    const result = await copyWorkspaceSources({
+      dependencyGraph,
+      prunePatterns: [
+        ...DEFAULT_SOURCE_COPY_PATTERNS,
+        "!**/*.md",
+        "!**/LICENSE",
+        "!sdk/**",
+        "!scripts/**",
+        "!tests/**",
+        "!programs/**/tests/**"
+      ]
+    });
+    const miniRoot = trackMiniRoot(result.miniRoot);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "apps", "current"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "programs", "demo", "src", "lib.rs"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "README.md"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "LICENSE"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "sdk"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "scripts"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "tests"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "programs", "demo", "tests"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "node_modules", "pkg"))).toBe(false);
+    globalExpect(lstatSync(join(miniRoot, "packages", "dep", "node_modules", "dep-link")).isSymbolicLink()).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "target"))).toBe(false);
+  });
+  it("falls back to default patterns when global prune patterns are empty", async () => {
+    const repo = createRepo("workspace-source-package-pattern-copy");
+    const current = join(repo, "apps", "current");
+    const anchorDep = join(repo, "packages", "anchor-dep");
+    const utilityDep = join(repo, "packages", "utility-dep");
+    createPackage(current, "@layerzerolabs/current", {
+      "src/index.ts": "export const current = true",
+      "tests/secret.ts": "export const secret = true"
+    });
+    createPackage(anchorDep, "@layerzerolabs/anchor-dep", {
+      "Anchor.toml": '[programs.localnet]\nanchor_dep = "11111111111111111111111111111111"',
+      "programs/demo/Cargo.toml": '[package]\nname = "demo"',
+      "programs/demo/src/lib.rs": "pub fn process() {}",
+      "programs/demo/tests/integration.rs": "#[test] fn it_works() {}"
+    });
+    createPackage(utilityDep, "@layerzerolabs/utility-dep", {
+      "src/index.ts": "export const utility = true"
+    });
+    const dependencyGraph = {
+      repoRoot: repo,
+      packageRoot: current,
+      packageRelativePath: "apps/current",
+      rootNodeModulesDependencyNames: [],
+      includedWorkspaceDependencies: [
+        {
+          name: "@layerzerolabs/anchor-dep",
+          importerRelativePath: "apps/current",
+          relativePath: "packages/anchor-dep",
+          absolutePath: anchorDep,
+          version: "link:../../packages/anchor-dep"
+        },
+        {
+          name: "@layerzerolabs/utility-dep",
+          importerRelativePath: "apps/current",
+          relativePath: "packages/utility-dep",
+          absolutePath: utilityDep,
+          version: "link:../../packages/utility-dep"
+        }
+      ]
+    };
+    const result = await copyWorkspaceSources({
+      dependencyGraph,
+      prunePatterns: [],
+      packagePrunePatterns: {
+        "apps/current": [
+          "src/**"
+        ],
+        "packages/anchor-dep": [
+          "Anchor.toml",
+          "programs/*/Cargo.toml",
+          "programs/*/src/**"
+        ]
+      }
+    });
+    const miniRoot = trackMiniRoot(result.miniRoot);
+    globalExpect(existsSync(join(miniRoot, "apps", "current"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "anchor-dep", "Anchor.toml"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "anchor-dep", "programs", "demo", "Cargo.toml"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "anchor-dep", "programs", "demo", "src", "lib.rs"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "anchor-dep", "programs", "demo", "tests"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "utility-dep", "src", "index.ts"))).toBe(true);
+  });
+});
+describe(createMiniWorkspace, () => {
+  it("uses the unpruned source-copy fallback when no pruner is configured", async () => {
+    const repo = createRepo("mini-workspace-fallback");
+    const current = join(repo, "apps", "current");
+    const dep = join(repo, "packages", "dep");
+    mkdirSync(join(repo, "node_modules", ".pnpm"), {
+      recursive: true
+    });
+    createPackage(current, "@layerzerolabs/current", {
+      "src/index.ts": "export const current = true"
+    });
+    createPackage(dep, "@layerzerolabs/dep", {
+      "src/index.ts": "export const dep = true"
+    });
+    writeLockfile(repo, `
+  apps/current:
+    dependencies:
+      '@layerzerolabs/dep':
+        specifier: workspace:*
+        version: link:../../packages/dep
+
+  packages/dep:
+    devDependencies: {}
+`);
+    const result = await createMiniWorkspace({
+      cwd: current
+    });
+    const miniRoot = trackMiniRoot(result.miniRoot);
+    globalExpect(result.prunerName).toBeUndefined();
+    globalExpect(result.diagnostics).toEqual([
+      "No mini-workspace pruner configured; using unpruned package-level source copy fallback."
+    ]);
+    globalExpect(result.copiedWorkspacePackageCount).toBe(1);
+    globalExpect(result.copiedWorkspacePackagePaths).toEqual({
+      "packages/dep": realpathSync(dep)
+    });
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "apps", "current"))).toBe(false);
+  });
+  it("uses a configured pruner to filter dependency package copies", async () => {
+    const repo = createRepo("mini-workspace-pruner");
+    const current = join(repo, "apps", "current");
+    const dep = join(repo, "packages", "dep");
+    const inputs = [];
+    const pruner = {
+      name: "test-pruner",
+      createPrunePlan: /* @__PURE__ */ __name(async (input) => {
+        inputs.push(input);
+        return {
+          patterns: [],
+          packagePatterns: {
+            "apps/current": [
+              "src/**"
+            ],
+            "packages/dep": [
+              ...DEFAULT_SOURCE_COPY_PATTERNS,
+              "!tests/**"
+            ]
+          },
+          diagnostics: [
+            "planned current package inputs"
+          ]
+        };
+      }, "createPrunePlan")
+    };
+    mkdirSync(join(repo, "node_modules", ".pnpm"), {
+      recursive: true
+    });
+    createPackage(current, "@layerzerolabs/current", {
+      "src/index.ts": "export const current = true",
+      "tests/secret.ts": "export const secret = true"
+    });
+    createPackage(dep, "@layerzerolabs/dep", {
+      "src/index.ts": "export const dep = true",
+      "tests/fixture.ts": "export const secret = true"
+    });
+    writeLockfile(repo, `
+  apps/current:
+    dependencies:
+      '@layerzerolabs/dep':
+        specifier: workspace:*
+        version: link:../../packages/dep
+
+  packages/dep:
+    devDependencies: {}
+`);
+    const result = await createMiniWorkspace({
+      cwd: current,
+      pruner
+    });
+    const miniRoot = trackMiniRoot(result.miniRoot);
+    globalExpect(inputs).toHaveLength(1);
+    const firstInput = inputs[0];
+    globalExpect(firstInput).toMatchObject({
+      repoRoot: realpathSync(repo),
+      packageRoot: realpathSync(current),
+      packageRelativePath: "apps/current",
+      cwd: current
+    });
+    globalExpect(firstInput.dependencyGraph.includedWorkspaceDependencies.map(({ relativePath }) => relativePath)).toEqual([
+      "packages/dep"
+    ]);
+    globalExpect(result.prunerName).toBe("test-pruner");
+    globalExpect(result.diagnostics).toEqual([
+      "planned current package inputs"
+    ]);
+    globalExpect(result.copiedWorkspacePackageCount).toBe(1);
+    globalExpect(result.copiedWorkspacePackagePaths).toEqual({
+      "packages/dep": realpathSync(dep)
+    });
+    globalExpect(existsSync(join(miniRoot, "apps", "current"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "dep", "tests"))).toBe(false);
+  });
+  it("uses default dependency copies for pruned packages without package-specific patterns", async () => {
+    const repo = createRepo("mini-workspace-empty-global-patterns");
+    const current = join(repo, "apps", "current");
+    const prunedDep = join(repo, "packages", "pruned-dep");
+    const defaultDep = join(repo, "packages", "default-dep");
+    const pruner = {
+      name: "test-pruner",
+      createPrunePlan: /* @__PURE__ */ __name(async () => ({
+        patterns: [],
+        packagePatterns: {
+          "packages/pruned-dep": [
+            "src/**"
+          ]
+        }
+      }), "createPrunePlan")
+    };
+    mkdirSync(join(repo, "node_modules", ".pnpm"), {
+      recursive: true
+    });
+    createPackage(current, "@layerzerolabs/current", {
+      "src/index.ts": "export const current = true"
+    });
+    createPackage(prunedDep, "@layerzerolabs/pruned-dep", {
+      "src/index.ts": "export const pruned = true",
+      "tests/fixture.ts": "export const fixture = true"
+    });
+    createPackage(defaultDep, "@layerzerolabs/default-dep", {
+      "src/index.ts": "export const defaultDep = true"
+    });
+    writeLockfile(repo, `
+  apps/current:
+    dependencies:
+      '@layerzerolabs/pruned-dep':
+        specifier: workspace:*
+        version: link:../../packages/pruned-dep
+      '@layerzerolabs/default-dep':
+        specifier: workspace:*
+        version: link:../../packages/default-dep
+
+  packages/default-dep:
+    devDependencies: {}
+
+  packages/pruned-dep:
+    devDependencies: {}
+`);
+    const result = await createMiniWorkspace({
+      cwd: current,
+      pruner
+    });
+    const miniRoot = trackMiniRoot(result.miniRoot);
+    globalExpect(existsSync(join(miniRoot, "packages", "pruned-dep", "src", "index.ts"))).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "packages", "pruned-dep", "tests"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "packages", "default-dep", "src", "index.ts"))).toBe(true);
+  });
+});
+describe(copyRootNodeModulesSymlinks, () => {
+  it("copies only selected root dependency symlinks without copying dependency contents", async () => {
+    const repo = createRepo("node-modules-symlinks");
+    const miniRoot = join(TMP, "mini-node-modules-symlinks");
+    const dep = join(repo, "apps", "oapp-app", "contracts", "solana");
+    createPackage(dep, "@layerzerolabs/oapp-solana-impl");
+    mkdirSync(join(repo, "node_modules", ".pnpm"), {
+      recursive: true
+    });
+    mkdirSync(join(repo, "node_modules", ".bin"), {
+      recursive: true
+    });
+    mkdirSync(join(repo, "node_modules", "@types"), {
+      recursive: true
+    });
+    mkdirSync(join(repo, "node_modules", "@layerzerolabs"), {
+      recursive: true
+    });
+    writeFileSync(join(repo, "node_modules", ".bin", "real-file"), "do not copy");
+    mkdirSync(join(miniRoot, "apps", "oapp-app", "contracts", "solana"), {
+      recursive: true
+    });
+    symlinkSync(".pnpm/eslint@1.0.0/node_modules/eslint", join(repo, "node_modules", "eslint"));
+    symlinkSync("../.pnpm/typescript@1.0.0/node_modules/typescript/bin/tsc", join(repo, "node_modules", ".bin", "tsc"));
+    symlinkSync("../.pnpm/@types+node@1.0.0/node_modules/@types/node", join(repo, "node_modules", "@types", "node"));
+    symlinkSync("../../apps/oapp-app/contracts/solana", join(repo, "node_modules", "@layerzerolabs", "oapp-solana-impl"));
+    symlinkSync("../..", join(repo, "node_modules", "@layerzerolabs", "whole-repo-link"));
+    const result = await copyRootNodeModulesSymlinks({
+      repoRoot: repo,
+      miniRoot,
+      dependencyNames: [
+        "@layerzerolabs/oapp-solana-impl",
+        "@types/node",
+        "eslint"
+      ]
+    });
+    globalExpect(result.nodeModulesPath).toBe(join(miniRoot, "node_modules"));
+    globalExpect(result.symlinks).toEqual([
+      "@layerzerolabs/oapp-solana-impl",
+      "@types/node",
+      "eslint"
+    ]);
+    globalExpect(readlinkSync(join(miniRoot, "node_modules", "eslint"))).toBe(".pnpm/eslint@1.0.0/node_modules/eslint");
+    globalExpect(lstatSync(join(miniRoot, "node_modules", ".pnpm")).isDirectory()).toBe(true);
+    globalExpect(existsSync(join(miniRoot, "node_modules", ".bin", "real-file"))).toBe(false);
+    globalExpect(existsSync(join(miniRoot, "node_modules", ".bin", "tsc"))).toBe(false);
+    globalExpect(lstatSync(join(miniRoot, "node_modules", "@types", "node")).isSymbolicLink()).toBe(true);
+    globalExpect(lstatSync(join(miniRoot, "node_modules", "@layerzerolabs", "oapp-solana-impl")).isSymbolicLink()).toBe(true);
+    globalExpect(readlinkSync(join(miniRoot, "node_modules", "@layerzerolabs", "oapp-solana-impl"))).toBe("../../apps/oapp-app/contracts/solana");
+    globalExpect(existsSync(join(miniRoot, "node_modules", "@layerzerolabs", "whole-repo-link"))).toBe(false);
+  });
+});
+describe(getPnpmVirtualStoreMount, () => {
+  it("describes a read-only .pnpm mount without requiring root node_modules copy", () => {
+    globalExpect(getPnpmVirtualStoreMount("/repo")).toEqual({
+      hostPath: "/repo/node_modules/.pnpm",
+      containerPath: "/workspace/node_modules/.pnpm",
+      readOnly: true
+    });
+  });
+});
+//# sourceMappingURL=mini-workspace.test.js.map
+//# sourceMappingURL=mini-workspace.test.js.map