@layerzerolabs/vm-tooling 1.2.30 → 1.2.31

package/dist/scoped-workspace/tests/scoped-workspace.test.js

@@ -1,725 +0,0 @@
-import { afterAll, describe, it, globalExpect } from '../../LBCSKMFZ.js';
-import { createScopedWorkspace } from '../../HIFVOL6G.js';
-import { resolveWorkspaceDependencyGraph } from '../../HMZV72VO.js';
-import { copyWorkspaceSources, DEFAULT_SOURCE_COPY_PATTERNS, DEFAULT_SOURCE_COPY_EXCLUDE_PATTERNS } from '../../5SLPZRAL.js';
-import '../../XMRVBPGX.js';
-import '../../TJ5HTUVM.js';
-import { copyRootNodeModulesSymlinks, getPnpmVirtualStoreMount } from '../../5PX53N66.js';
-import '../../CYP6J4VH.js';
-import '../../N3I7SNFG.js';
-import { init_esm_shims, __name } from '../../JWJXCZMP.js';
-import { mkdtempSync, rmSync, mkdirSync, realpathSync, symlinkSync, existsSync, lstatSync, readlinkSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-// src/scoped-workspace/tests/scoped-workspace.test.ts
-init_esm_shims();
-var TMP = mkdtempSync(join(tmpdir(), "lz-scoped-workspace-test-"));
-var GENERATED_SCOPED_ROOTS = [];
-var trackScopedRoot = /* @__PURE__ */ __name((scopedRoot) => {
-  GENERATED_SCOPED_ROOTS.push(scopedRoot);
-  return scopedRoot;
-}, "trackScopedRoot");
-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 scopedRoot of GENERATED_SCOPED_ROOTS) {
-    rmSync(scopedRoot, {
-      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("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",
-      "dependencies/generated-crate/src/lib.rs": "pub fn generated() {}",
-      "target/deploy/program.so": "compiled",
-      "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 scopedRoot = trackScopedRoot(result.scopedRoot);
-    globalExpect(result.copiedWorkspaceDependencies).toHaveLength(1);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "dependencies"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "target"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "node_modules"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "node_modules", "pkg", "index.js"))).toBe(false);
-    globalExpect(lstatSync(join(scopedRoot, "packages", "dep", "node_modules", "linked-pkg")).isSymbolicLink()).toBe(true);
-    globalExpect(readlinkSync(join(scopedRoot, "packages", "dep", "node_modules", "linked-pkg"))).toBe("../../../../node_modules/.pnpm/linked-pkg@1.0.0/node_modules/linked-pkg");
-    globalExpect(lstatSync(join(scopedRoot, "packages", "dep", "src-link.ts")).isSymbolicLink()).toBe(true);
-    globalExpect(readlinkSync(join(scopedRoot, "packages", "dep", "src-link.ts"))).toBe("src/index.ts");
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "dist", "index.js"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "artifacts"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "apps", "current"))).toBe(false);
-  });
-  it("applies glob-compatible scoped-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/**",
-        ...DEFAULT_SOURCE_COPY_EXCLUDE_PATTERNS
-      ]
-    });
-    const scopedRoot = trackScopedRoot(result.scopedRoot);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "apps", "current"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "programs", "demo", "src", "lib.rs"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "README.md"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "LICENSE"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "sdk"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "scripts"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "tests"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "programs", "demo", "tests"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "node_modules", "pkg"))).toBe(false);
-    globalExpect(lstatSync(join(scopedRoot, "packages", "dep", "node_modules", "dep-link")).isSymbolicLink()).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "target"))).toBe(false);
-  });
-  it("tolerates identical package-local symlinks copied twice (nested workspace package layout)", async () => {
-    const repo = createRepo("workspace-source-duplicate-symlink");
-    const current = join(repo, "apps", "current");
-    const parent = join(repo, "apps", "parent");
-    const nested = join(parent, "nested-pkg");
-    createPackage(current, "@layerzerolabs/current");
-    createPackage(parent, "@layerzerolabs/parent", {
-      "src/index.ts": "export const parent = true"
-    });
-    createPackage(nested, "@layerzerolabs/nested", {
-      "src/index.ts": "export const nested = true"
-    });
-    mkdirSync(join(nested, "node_modules", "@layerzerolabs"), {
-      recursive: true
-    });
-    symlinkSync("../../../../../../tools/vm-tooling/vm-tooling-stellar", join(nested, "node_modules", "@layerzerolabs", "vm-tooling-stellar"));
-    mkdirSync(join(parent, "node_modules", "@layerzerolabs"), {
-      recursive: true
-    });
-    symlinkSync("../../../../tools/vm-tooling/vm-tooling-stellar", join(parent, "node_modules", "@layerzerolabs", "vm-tooling-stellar"));
-    const dependencyGraph = {
-      repoRoot: repo,
-      packageRoot: current,
-      packageRelativePath: "apps/current",
-      rootNodeModulesDependencyNames: [],
-      includedWorkspaceDependencies: [
-        {
-          name: "@layerzerolabs/parent",
-          importerRelativePath: "apps/current",
-          relativePath: "apps/parent",
-          absolutePath: parent,
-          version: "link:../parent"
-        },
-        {
-          name: "@layerzerolabs/nested",
-          importerRelativePath: "apps/parent",
-          relativePath: "apps/parent/nested-pkg",
-          absolutePath: nested,
-          version: "link:./nested-pkg"
-        }
-      ]
-    };
-    const result = await copyWorkspaceSources({
-      dependencyGraph
-    });
-    const scopedRoot = trackScopedRoot(result.scopedRoot);
-    const nestedLink = join(scopedRoot, "apps", "parent", "nested-pkg", "node_modules", "@layerzerolabs", "vm-tooling-stellar");
-    globalExpect(lstatSync(nestedLink).isSymbolicLink()).toBe(true);
-    globalExpect(readlinkSync(nestedLink)).toBe("../../../../../../tools/vm-tooling/vm-tooling-stellar");
-  });
-  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 scopedRoot = trackScopedRoot(result.scopedRoot);
-    globalExpect(existsSync(join(scopedRoot, "apps", "current"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "anchor-dep", "Anchor.toml"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "anchor-dep", "programs", "demo", "Cargo.toml"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "anchor-dep", "programs", "demo", "src", "lib.rs"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "anchor-dep", "programs", "demo", "tests"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "utility-dep", "src", "index.ts"))).toBe(true);
-  });
-  it("copies pruner-selected build outputs under otherwise-excluded directories", async () => {
-    const repo = createRepo("workspace-source-build-output-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",
-      "target/wasm32v1-none/release/dep.wasm": "wasm",
-      "target/wasm32v1-none/release/dep.d": "deps"
-    });
-    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,
-      packagePrunePatterns: {
-        "packages/dep": [
-          "target/wasm32v1-none/release/*.d",
-          "target/wasm32v1-none/release/*.wasm"
-        ]
-      }
-    });
-    const scopedRoot = trackScopedRoot(result.scopedRoot);
-    const releaseDir = join(scopedRoot, "packages", "dep", "target", "wasm32v1-none", "release");
-    globalExpect(existsSync(join(releaseDir, "dep.wasm"))).toBe(true);
-    globalExpect(existsSync(join(releaseDir, "dep.d"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "src"))).toBe(false);
-  });
-});
-describe(createScopedWorkspace, () => {
-  it("uses the unpruned source-copy fallback when no pruner is configured", async () => {
-    const repo = createRepo("scoped-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 createScopedWorkspace({
-      cwd: current
-    });
-    const scopedRoot = trackScopedRoot(result.scopedRoot);
-    globalExpect(result.prunerName).toBeUndefined();
-    globalExpect(result.diagnostics).toEqual([
-      "No scoped-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(scopedRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "apps", "current"))).toBe(false);
-  });
-  it("uses a configured pruner to filter dependency package copies", async () => {
-    const repo = createRepo("scoped-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 createScopedWorkspace({
-      cwd: current,
-      pruner
-    });
-    const scopedRoot = trackScopedRoot(result.scopedRoot);
-    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(scopedRoot, "apps", "current"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "src", "index.ts"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "dep", "tests"))).toBe(false);
-  });
-  it("uses default dependency copies for pruned packages without package-specific patterns", async () => {
-    const repo = createRepo("scoped-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 createScopedWorkspace({
-      cwd: current,
-      pruner
-    });
-    const scopedRoot = trackScopedRoot(result.scopedRoot);
-    globalExpect(existsSync(join(scopedRoot, "packages", "pruned-dep", "src", "index.ts"))).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "packages", "pruned-dep", "tests"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "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 scopedRoot = join(TMP, "scoped-node-modules-symlinks");
-    const dep = join(repo, "apps", "oapp-app", "contracts", "solana");
-    createPackage(dep, "@layerzerolabs/oapp-solana-contracts");
-    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(scopedRoot, "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-contracts"));
-    symlinkSync("../..", join(repo, "node_modules", "@layerzerolabs", "whole-repo-link"));
-    const result = await copyRootNodeModulesSymlinks({
-      repoRoot: repo,
-      scopedRoot,
-      dependencyNames: [
-        "@layerzerolabs/oapp-solana-contracts",
-        "@types/node",
-        "eslint"
-      ]
-    });
-    globalExpect(result.nodeModulesPath).toBe(join(scopedRoot, "node_modules"));
-    globalExpect(result.symlinks).toEqual([
-      "@layerzerolabs/oapp-solana-contracts",
-      "@types/node",
-      "eslint"
-    ]);
-    globalExpect(readlinkSync(join(scopedRoot, "node_modules", "eslint"))).toBe(".pnpm/eslint@1.0.0/node_modules/eslint");
-    globalExpect(lstatSync(join(scopedRoot, "node_modules", ".pnpm")).isDirectory()).toBe(true);
-    globalExpect(existsSync(join(scopedRoot, "node_modules", ".bin", "real-file"))).toBe(false);
-    globalExpect(existsSync(join(scopedRoot, "node_modules", ".bin", "tsc"))).toBe(false);
-    globalExpect(lstatSync(join(scopedRoot, "node_modules", "@types", "node")).isSymbolicLink()).toBe(true);
-    globalExpect(lstatSync(join(scopedRoot, "node_modules", "@layerzerolabs", "oapp-solana-contracts")).isSymbolicLink()).toBe(true);
-    globalExpect(readlinkSync(join(scopedRoot, "node_modules", "@layerzerolabs", "oapp-solana-contracts"))).toBe("../../apps/oapp-app/contracts/solana");
-    globalExpect(existsSync(join(scopedRoot, "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=scoped-workspace.test.js.map
-//# sourceMappingURL=scoped-workspace.test.js.map