@elizaos/app-core 2.0.0-beta.3 → 2.0.3-beta.3

package/scripts/copy-runtime-node-modules.ts

@@ -55,9 +55,31 @@ const TRACKED_PACKAGE_CACHE = path.join(
 const PUBLISHED_PACKAGE_FETCH_TIMEOUT_MS = 10_000;
 const ALLOW_REGISTRY_FETCH =
   process.env.ELIZA_RUNTIME_COPY_ALLOW_REGISTRY_FETCH === "1";
-const DEP_SKIP = new Set(["typescript", "@types/node", "lucide-react"]);
-const ALWAYS_HOISTED_PACKAGES = new Set(["@elizaos/core"]);
-const PACKAGED_DEPENDENCY_SKIPS = new Map<string, Set<string>>();
+const DEP_SKIP = new Set(["typescript", "@types/node"]);
+const ALWAYS_HOISTED_PACKAGES = new Set([
+  // @brighter/storage-adapter-s3 accepts broad S3 client ranges; reuse the
+  // runtime root copy instead of nesting a private AWS SDK tree that exceeds
+  // Electrobun's tar-safe path limits.
+  "@aws-sdk/client-s3",
+  "@elizaos/core",
+  "commander",
+  "pg",
+  "pg-pool",
+]);
+const PATCH_COMPATIBLE_HOISTED_PACKAGES = new Set([
+  "@walletconnect/core",
+  "@walletconnect/sign-client",
+  "@walletconnect/types",
+  "@walletconnect/universal-provider",
+  "@walletconnect/utils",
+]);
+const PACKAGED_DEPENDENCY_SKIPS = new Map<string, Set<string>>([
+  // git-workspace-service declares @octokit/rest as both a dependency (^20)
+  // and a peer (>=20). Desktop bundles it via plugin-agent-orchestrator,
+  // which ships @octokit/rest@22 at the runtime root. Re-copying the private
+  // Bun fallback produces tar-unsafe nested paths on Windows.
+  ["git-workspace-service", new Set(["@octokit/rest"])],
+]);
 const RUNTIME_COPY_PRUNED_DIR_NAMES = new Set([
   ".git",
   ".gradle",
@@ -90,6 +112,14 @@ const TAR_SAFE_BASENAME_MAX = Number.parseInt(
   process.env.ELIZA_RUNTIME_TAR_SAFE_BASENAME_MAX ?? "100",
   10,
 );
+const RUNTIME_COPY_LOCK_TIMEOUT_MS = Number.parseInt(
+  process.env.ELIZA_RUNTIME_COPY_LOCK_TIMEOUT_MS ?? "600000",
+  10,
+);
+const RUNTIME_COPY_LOCK_STALE_MS = Number.parseInt(
+  process.env.ELIZA_RUNTIME_COPY_LOCK_STALE_MS ?? "1800000",
+  10,
+);
 const PLATFORM_ALIASES = new Map<string, string>([
   ["android", "android"],
   ["aix", "aix"],
@@ -133,6 +163,13 @@ const registryPackageIndex = new Map<string, ResolvedPackage>();
 const trackedPackageIndex = new Map<string, ResolvedPackage>();
 const workspacePackageIndex = new Map<string, ResolvedPackage[]>();
 let workspacePackageIndexBuilt = false;
+let activeRuntimeCopyTargetNodeModules: string | null = null;
+
+function resolveBunCommand(): string {
+  return path.basename(process.execPath).startsWith("bun")
+    ? process.execPath
+    : (process.env.BUN ?? "bun");
+}
 
 function isRequiredRuntimeDocDirectory(entryPath: string): boolean {
   const normalizedPath = entryPath.split(path.sep).join("/");
@@ -150,8 +187,15 @@ function parseArgs(argv: string[]): Options {
     if (!arg.startsWith("--")) continue;
     const [rawKey, inlineValue] = arg.slice(2).split("=", 2);
     const key = rawKey.trim();
-    const value = inlineValue ?? argv[i + 1];
-    if (!inlineValue) i += 1;
+    let value = inlineValue;
+    if (value === undefined) {
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        value = next;
+        i += 1;
+      }
+    }
+    if (value === undefined) continue;
     opts[key] = value;
   }
 
@@ -164,6 +208,172 @@ function readJson<T>(filePath: string): T {
   return JSON.parse(fs.readFileSync(filePath, "utf8")) as T;
 }
 
+function sleepSync(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function isEnoentError(error: unknown): boolean {
+  return Boolean(
+    error &&
+      typeof error === "object" &&
+      (error as { code?: string }).code === "ENOENT",
+  );
+}
+
+function isRetryableRemoveError(error: unknown): boolean {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = (error as { code?: string }).code;
+  return (
+    code === "EBUSY" ||
+    code === "EMFILE" ||
+    code === "ENFILE" ||
+    code === "ENOTEMPTY" ||
+    code === "EPERM"
+  );
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (
+      error &&
+      typeof error === "object" &&
+      (error as { code?: string }).code === "ESRCH"
+    ) {
+      return false;
+    }
+    return true;
+  }
+}
+
+function readRuntimeCopyLockOwnerPid(lockDir: string): number | null {
+  try {
+    const owner = readJson<{ pid?: unknown }>(path.join(lockDir, "owner.json"));
+    return typeof owner.pid === "number" && owner.pid > 0 ? owner.pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function rmRecursive(pathToRemove: string): void {
+  const maxAttempts = 8;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      fs.rmSync(pathToRemove, {
+        force: true,
+        maxRetries: 5,
+        recursive: true,
+        retryDelay: 100,
+      });
+      return;
+    } catch (error) {
+      if (!isRetryableRemoveError(error)) {
+        throw error;
+      }
+      if (attempt === maxAttempts - 1) break;
+      sleepSync(100 * (attempt + 1));
+    }
+  }
+
+  if (!fs.existsSync(pathToRemove)) {
+    return;
+  }
+
+  const parentDir = path.dirname(pathToRemove);
+  const tombstone = path.join(
+    parentDir,
+    `.${path.basename(pathToRemove)}.delete-${process.pid}-${Date.now()}`,
+  );
+  try {
+    fs.renameSync(pathToRemove, tombstone);
+  } catch (error) {
+    if (!fs.existsSync(pathToRemove)) {
+      return;
+    }
+    throw error;
+  }
+
+  try {
+    fs.rmSync(tombstone, {
+      force: true,
+      maxRetries: 10,
+      recursive: true,
+      retryDelay: 100,
+    });
+  } catch (error) {
+    console.warn(
+      `[runtime-copy] warning: moved retry-resistant path aside but could not fully remove ${tombstone}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+function acquireRuntimeCopyLock(targetDist: string): () => void {
+  const lockDir = path.join(targetDist, ".runtime-copy.lock");
+  const startedAt = Date.now();
+
+  while (true) {
+    try {
+      fs.mkdirSync(lockDir, { recursive: false });
+      fs.writeFileSync(
+        path.join(lockDir, "owner.json"),
+        `${JSON.stringify(
+          {
+            pid: process.pid,
+            startedAt: new Date().toISOString(),
+            targetDist,
+          },
+          null,
+          2,
+        )}\n`,
+      );
+      return () => {
+        fs.rmSync(lockDir, { force: true, recursive: true });
+      };
+    } catch (error) {
+      if (
+        !error ||
+        typeof error !== "object" ||
+        (error as { code?: string }).code !== "EEXIST"
+      ) {
+        throw error;
+      }
+
+      let ageMs = 0;
+      try {
+        ageMs = Date.now() - fs.statSync(lockDir).mtimeMs;
+      } catch (statError) {
+        if (isEnoentError(statError)) {
+          continue;
+        }
+        throw statError;
+      }
+
+      const ownerPid = readRuntimeCopyLockOwnerPid(lockDir);
+      if (ownerPid !== null && !isProcessAlive(ownerPid)) {
+        rmRecursive(lockDir);
+        continue;
+      }
+
+      if (ageMs > RUNTIME_COPY_LOCK_STALE_MS) {
+        rmRecursive(lockDir);
+        continue;
+      }
+
+      if (Date.now() - startedAt > RUNTIME_COPY_LOCK_TIMEOUT_MS) {
+        throw new Error(
+          `[runtime-copy] timed out waiting for runtime copy lock: ${lockDir}`,
+        );
+      }
+
+      sleepSync(250);
+    }
+  }
+}
+
 function packagePath(name: string, baseDir: string): string {
   if (name.startsWith("@")) {
     const [scope, pkg] = name.split("/");
@@ -172,6 +382,14 @@ function packagePath(name: string, baseDir: string): string {
   return path.join(baseDir, name);
 }
 
+function isPathInsideOrEqual(candidate: string, parent: string): boolean {
+  const relative = path.relative(parent, candidate);
+  return (
+    relative === "" ||
+    (!relative.startsWith("..") && !path.isAbsolute(relative))
+  );
+}
+
 function addWorkspacePackageCandidate(
   name: string,
   resolved: ResolvedPackage,
@@ -299,8 +517,8 @@ function buildWorkspacePackageIndex(): void {
 
   indexWorkspacePackages(ROOT);
 
-  // The desktop wrapper repo builds from /milady while the active Eliza
-  // workspace lives at /milady/eliza. Prefer those local packages over stale
+  // The desktop wrapper repo builds from /eliza while the active Eliza
+  // workspace lives at /eliza/eliza. Prefer those local packages over stale
   // published node_modules copies so deep runtime imports match the code that
   // tsdown just compiled.
   const nestedElizaRoot = path.join(ROOT, "eliza");
@@ -482,12 +700,6 @@ export function shouldKeepPackageRelativePath(
     }
   }
 
-  if (packageName === "onnxruntime-web") {
-    if (normalizedPath === "lib" || normalizedPath.startsWith("lib/")) {
-      return false;
-    }
-  }
-
   if (packageName === "@elizaos/app-core") {
     if (
       normalizedPath === ".tmp" ||
@@ -503,7 +715,7 @@ export function shouldKeepPackageRelativePath(
     }
   }
 
-  if (packageName === "@elizaos/app-companion") {
+  if (packageName === "@elizaos/plugin-companion") {
     if (
       normalizedPath === "public_src" ||
       normalizedPath.startsWith("public_src/")
@@ -573,11 +785,48 @@ function shouldPreservePrunedPackageEntry(
   packageDir: string | undefined,
   entryPath: string,
 ): boolean {
+  const relativePath = packageDir
+    ? toPosixPath(path.relative(packageDir, entryPath))
+    : "";
+  if (
+    packageName === "@elizaos/skills" &&
+    relativePath.startsWith("skills/") &&
+    /\.(?:md|markdown)$/i.test(relativePath)
+  ) {
+    return true;
+  }
+
+  if (
+    packageName === "googleapis" &&
+    (relativePath === "build/src/apis/docs" ||
+      relativePath.startsWith("build/src/apis/docs/"))
+  ) {
+    return true;
+  }
+
+  if (
+    packageName === "three" &&
+    (relativePath === "examples" ||
+      relativePath === "examples/jsm" ||
+      relativePath.startsWith("examples/jsm/") ||
+      relativePath === "examples/fonts" ||
+      relativePath.startsWith("examples/fonts/"))
+  ) {
+    return true;
+  }
+
+  if (
+    packageName === "@elizaos/ui" &&
+    (relativePath === "dist/cloud-ui/components/docs" ||
+      relativePath.startsWith("dist/cloud-ui/components/docs/"))
+  ) {
+    return true;
+  }
+
   if (packageName !== "@elevenlabs/elevenlabs-js" || !packageDir) {
     return false;
   }
 
-  const relativePath = toPosixPath(path.relative(packageDir, entryPath));
   return (
     relativePath === "api/resources/conversationalAi/resources/tests" ||
     relativePath.startsWith(
@@ -591,14 +840,47 @@ function shouldPreservePrunedPackageEntry(
   );
 }
 
+function shouldPrunePackageRelativePath(
+  packageName: string,
+  relativePath: string,
+): boolean {
+  const normalizedPath = relativePath.split(path.sep).join("/");
+
+  if (packageName === "@elizaos/plugin-local-inference") {
+    return (
+      normalizedPath === "native/llama.cpp/tools/server/webui" ||
+      normalizedPath.startsWith("native/llama.cpp/tools/server/webui/") ||
+      /^native\/llama\.cpp\/build(?:[-/]|$)/.test(normalizedPath) ||
+      /^native\/omnivoice\.cpp\/build(?:[-/]|$)/.test(normalizedPath)
+    );
+  }
+
+  return false;
+}
+
 function pruneCopiedPackageDir(name: string, packageDir: string): void {
   if (!fs.existsSync(packageDir)) return;
 
   const visit = (currentDir: string): void => {
-    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (error) {
+      if (isEnoentError(error)) {
+        return;
+      }
+      throw error;
+    }
+
+    for (const entry of entries) {
       const entryPath = path.join(currentDir, entry.name);
       const relativePath = path.relative(packageDir, entryPath);
 
+      if (shouldPrunePackageRelativePath(name, relativePath)) {
+        fs.rmSync(entryPath, { recursive: true, force: true });
+        continue;
+      }
+
       if (
         entry.name === "node_modules" ||
         (RUNTIME_COPY_PRUNED_DIR_NAMES.has(entry.name) &&
@@ -611,7 +893,8 @@ function pruneCopiedPackageDir(name: string, packageDir: string): void {
 
       if (
         entry.isFile() &&
-        RUNTIME_COPY_PRUNED_FILE_EXTENSIONS.has(path.extname(entry.name))
+        RUNTIME_COPY_PRUNED_FILE_EXTENSIONS.has(path.extname(entry.name)) &&
+        !shouldPreservePrunedPackageEntry(name, packageDir, entryPath)
       ) {
         fs.rmSync(entryPath, { force: true });
         continue;
@@ -631,7 +914,10 @@ function pruneCopiedPackageDir(name: string, packageDir: string): void {
 
       if (entry.isDirectory()) {
         visit(entryPath);
-        if (fs.readdirSync(entryPath).length === 0) {
+        if (
+          fs.existsSync(entryPath) &&
+          fs.readdirSync(entryPath).length === 0
+        ) {
           fs.rmdirSync(entryPath);
         }
       }
@@ -642,6 +928,78 @@ function pruneCopiedPackageDir(name: string, packageDir: string): void {
   visit(packageDir);
 }
 
+function copyPackageDirSync(
+  name: string,
+  sourceDir: string,
+  copyDest: string,
+  destIsInsideSource: boolean,
+): void {
+  const sourceDistDir = path.join(sourceDir, "dist");
+  const workspacePublishEntries = getWorkspacePackageRuntimeCopyEntries(
+    name,
+    sourceDir,
+  );
+  const maxAttempts = 5;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      fs.cpSync(sourceDir, copyDest, {
+        recursive: true,
+        force: true,
+        dereference: true,
+        filter: (entry) => {
+          if (!shouldCopyPackageEntry(entry, name, sourceDir)) {
+            return false;
+          }
+          if (name === "@elizaos/app-core") {
+            const relativeEntry = path
+              .relative(sourceDir, entry)
+              .split(path.sep)
+              .join("/");
+            if (shouldSkipPackagedAppCoreEntry(relativeEntry)) {
+              return false;
+            }
+          }
+          if (
+            workspacePublishEntries &&
+            !shouldCopyWorkspacePublishEntry(
+              entry,
+              sourceDir,
+              workspacePublishEntries,
+            )
+          ) {
+            return false;
+          }
+          if (!destIsInsideSource) {
+            return true;
+          }
+          const relativeToDist = path.relative(sourceDistDir, entry);
+          return (
+            relativeToDist !== "" &&
+            (relativeToDist.startsWith("..") || path.isAbsolute(relativeToDist))
+          );
+        },
+      });
+      return;
+    } catch (error) {
+      if (
+        error &&
+        typeof error === "object" &&
+        (error as { code?: string }).code === "ENAMETOOLONG"
+      ) {
+        throw new Error(
+          `[runtime-copy] path too long while copying ${name} from ${sourceDir} to ${copyDest}`,
+          { cause: error },
+        );
+      }
+      if (!isEnoentError(error) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      rmRecursive(copyDest);
+      sleepSync(100 * (attempt + 1));
+    }
+  }
+}
+
 function copyPackageDir(
   name: string,
   sourceDir: string,
@@ -649,7 +1007,7 @@ function copyPackageDir(
   rootDestDir: string,
 ): boolean {
   const dest = packagePath(name, targetNodeModules);
-  fs.rmSync(dest, { recursive: true, force: true });
+  rmRecursive(dest);
   fs.mkdirSync(path.dirname(dest), { recursive: true });
   const relativeDest = path.relative(sourceDir, dest);
   const destIsInsideSource =
@@ -659,34 +1017,7 @@ function copyPackageDir(
   const copyDest = destIsInsideSource
     ? fs.mkdtempSync(path.join(os.tmpdir(), "eliza-runtime-package-copy-"))
     : dest;
-  const sourceDistDir = path.join(sourceDir, "dist");
-  fs.cpSync(sourceDir, copyDest, {
-    recursive: true,
-    force: true,
-    dereference: true,
-    filter: (entry) => {
-      if (!shouldCopyPackageEntry(entry, name, sourceDir)) {
-        return false;
-      }
-      if (name === "@elizaos/app-core") {
-        const relativeEntry = path
-          .relative(sourceDir, entry)
-          .split(path.sep)
-          .join("/");
-        if (shouldSkipPackagedAppCoreEntry(relativeEntry)) {
-          return false;
-        }
-      }
-      if (!destIsInsideSource) {
-        return true;
-      }
-      const relativeToDist = path.relative(sourceDistDir, entry);
-      return (
-        relativeToDist !== "" &&
-        (relativeToDist.startsWith("..") || path.isAbsolute(relativeToDist))
-      );
-    },
-  });
+  copyPackageDirSync(name, sourceDir, copyDest, destIsInsideSource);
   if (destIsInsideSource) {
     fs.renameSync(copyDest, dest);
   }
@@ -713,17 +1044,167 @@ function shouldSkipPackagedAppCoreEntry(relativeEntry: string): boolean {
     relativeEntry.startsWith("platforms/electrobun/build/") ||
     relativeEntry === "platforms/electrobun/artifacts" ||
     relativeEntry.startsWith("platforms/electrobun/artifacts/") ||
+    relativeEntry === "platforms/electrobun/src/libMacWindowEffects.dylib" ||
     relativeEntry === "dist/platforms/electrobun/build" ||
     relativeEntry.startsWith("dist/platforms/electrobun/build/") ||
     relativeEntry === "dist/platforms/electrobun/artifacts" ||
-    relativeEntry.startsWith("dist/platforms/electrobun/artifacts/")
+    relativeEntry.startsWith("dist/platforms/electrobun/artifacts/") ||
+    relativeEntry ===
+      "dist/platforms/electrobun/src/libMacWindowEffects.dylib" ||
+    relativeEntry === "scripts/bun-riscv64" ||
+    relativeEntry.startsWith("scripts/bun-riscv64/") ||
+    relativeEntry === "dist/scripts/bun-riscv64" ||
+    relativeEntry.startsWith("dist/scripts/bun-riscv64/")
   );
 }
 
 type PackageJsonManifest = {
-  exports?: Record<string, unknown>;
+  exports?: unknown;
+  files?: unknown;
+  main?: string;
+  module?: string;
 };
 
+const PACKAGE_METADATA_ENTRY_NAMES = new Set([
+  "LICENSE",
+  "LICENSE.md",
+  "LICENSE.txt",
+  "README.md",
+  "package.json",
+]);
+const NON_RUNTIME_EXPORT_CONDITIONS = new Set(["eliza-source", "types"]);
+
+function getTopLevelPublishEntry(rawEntry: string): string | null {
+  if (rawEntry.trim().startsWith("!")) {
+    return null;
+  }
+
+  const normalized = rawEntry
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/\/+$/, "");
+
+  if (!normalized || normalized === ".") {
+    return null;
+  }
+
+  const [topLevel] = normalized.split("/");
+  if (!topLevel || topLevel.includes("*")) {
+    return null;
+  }
+
+  return topLevel;
+}
+
+function addRuntimeManifestEntryTopLevel(
+  entries: Set<string>,
+  entryPath: unknown,
+): void {
+  if (typeof entryPath !== "string" || !entryPath.startsWith("./")) {
+    return;
+  }
+
+  const topLevel = getTopLevelPublishEntry(entryPath);
+  if (topLevel) {
+    entries.add(topLevel);
+  }
+}
+
+function addRuntimeExportTopLevelEntries(
+  entries: Set<string>,
+  exportValue: unknown,
+): void {
+  if (typeof exportValue === "string") {
+    addRuntimeManifestEntryTopLevel(entries, exportValue);
+    return;
+  }
+
+  if (!exportValue || typeof exportValue !== "object") {
+    return;
+  }
+
+  if (Array.isArray(exportValue)) {
+    for (const item of exportValue) {
+      addRuntimeExportTopLevelEntries(entries, item);
+    }
+    return;
+  }
+
+  for (const [condition, value] of Object.entries(exportValue)) {
+    if (NON_RUNTIME_EXPORT_CONDITIONS.has(condition)) {
+      continue;
+    }
+    addRuntimeExportTopLevelEntries(entries, value);
+  }
+}
+
+function isWorkspacePackageSourceDir(sourceDir: string): boolean {
+  const relative = path.relative(ROOT, sourceDir);
+  return (
+    Boolean(relative) &&
+    !relative.startsWith("..") &&
+    !path.isAbsolute(relative) &&
+    !relative.split(path.sep).includes("node_modules")
+  );
+}
+
+export function getWorkspacePackageRuntimeCopyEntries(
+  name: string,
+  sourceDir: string,
+): Set<string> | null {
+  if (!isWorkspacePackageSourceDir(sourceDir)) {
+    return null;
+  }
+
+  const manifestPath = path.join(sourceDir, "package.json");
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+
+  const manifest = readJson<PackageJsonManifest>(manifestPath);
+  if (
+    !Array.isArray(manifest.files) ||
+    manifest.files.some((entry) => typeof entry !== "string")
+  ) {
+    return null;
+  }
+
+  const entries = new Set(PACKAGE_METADATA_ENTRY_NAMES);
+  for (const fileEntry of manifest.files) {
+    const topLevel = getTopLevelPublishEntry(fileEntry);
+    if (topLevel) {
+      entries.add(topLevel);
+    }
+  }
+
+  addRuntimeManifestEntryTopLevel(entries, manifest.main);
+  addRuntimeManifestEntryTopLevel(entries, manifest.module);
+  addRuntimeExportTopLevelEntries(entries, manifest.exports);
+
+  // @elizaos/agent still exposes Bun runtime source conditions. Keep its
+  // source tree so packaged Bun resolution cannot select a missing entry.
+  if (name === "@elizaos/agent" && fs.existsSync(path.join(sourceDir, "src"))) {
+    entries.add("src");
+  }
+
+  return entries;
+}
+
+export function shouldCopyWorkspacePublishEntry(
+  entry: string,
+  sourceDir: string,
+  allowedTopLevelEntries: ReadonlySet<string>,
+): boolean {
+  const relativeEntry = path.relative(sourceDir, entry);
+  if (!relativeEntry) {
+    return true;
+  }
+
+  const [topLevel] = relativeEntry.split(path.sep);
+  return allowedTopLevelEntries.has(topLevel);
+}
+
 type AgentDeepImportExportEntry = {
   exportKey: string;
   jsPath: string;
@@ -871,13 +1352,23 @@ function visitFiles(rootDir: string, visit: (filePath: string) => void): void {
     return;
   }
 
-  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+
+  for (const entry of entries) {
     const entryPath = path.join(rootDir, entry.name);
     if (entry.isDirectory()) {
       visitFiles(entryPath, visit);
       continue;
     }
-    if (entry.isFile()) {
+    if (entry.isFile() && fs.existsSync(entryPath)) {
       visit(entryPath);
     }
   }
@@ -959,6 +1450,9 @@ function patchCopiedElevenLabsTarSafePaths(
     if (!filePath.endsWith(".js")) {
       return;
     }
+    if (!fs.existsSync(filePath)) {
+      return;
+    }
 
     let source = fs.readFileSync(filePath, "utf8");
     const original = source;
@@ -999,6 +1493,35 @@ function patchCopiedAiSdkProviderRuntimeSurface(packageDir: string): void {
   }
 }
 
+function writeRuntimeShimIfMissing(filePath: string, source: string): void {
+  if (fs.existsSync(filePath)) {
+    return;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, source);
+}
+
+function patchCopiedPluginSqlRuntimeSurface(packageDir: string): void {
+  const srcDist = path.join(packageDir, "src", "dist");
+  const nodeEntry = path.join(srcDist, "node", "index.node.js");
+  if (!fs.existsSync(nodeEntry)) {
+    return;
+  }
+
+  writeRuntimeShimIfMissing(
+    path.join(srcDist, "index.js"),
+    "export * from './node/index.node.js';\nexport { default } from './node/index.node.js';\n",
+  );
+  writeRuntimeShimIfMissing(
+    path.join(srcDist, "drizzle", "index.js"),
+    "export { and, asc, count, desc, eq, gt, gte, inArray, isNull, lt, lte, ne, or, sql } from 'drizzle-orm';\n",
+  );
+  writeRuntimeShimIfMissing(
+    path.join(srcDist, "schema", "index.js"),
+    "export * from '../node/index.node.js';\n",
+  );
+}
+
 function patchCopiedPackageRuntimeSurface(
   name: string,
   packageDir: string,
@@ -1012,6 +1535,10 @@ function patchCopiedPackageRuntimeSurface(
     patchCopiedAiSdkProviderRuntimeSurface(packageDir);
     return;
   }
+  if (name === "@elizaos/plugin-sql") {
+    patchCopiedPluginSqlRuntimeSurface(packageDir);
+    return;
+  }
   if (name === "@elevenlabs/elevenlabs-js") {
     patchCopiedElevenLabsTarSafePaths(packageDir, rootDestDir);
     return;
@@ -1069,7 +1596,10 @@ export function shouldCopyPackageEntry(
   ) {
     return false;
   }
-  if (RUNTIME_COPY_PRUNED_FILE_EXTENSIONS.has(path.extname(entry))) {
+  if (
+    RUNTIME_COPY_PRUNED_FILE_EXTENSIONS.has(path.extname(entry)) &&
+    !shouldPreservePrunedPackageEntry(packageName, packageRoot, entry)
+  ) {
     return false;
   }
   if (entry.endsWith(".d.ts") || entry.endsWith(".d.ts.map")) {
@@ -1298,8 +1828,8 @@ function detectCurrentLibc(): string | null {
   }
 
   try {
-    const report = process.report?.getReport();
-    return report?.header?.glibcVersionRuntime ? "glibc" : "musl";
+    const report = process.report.getReport();
+    return report.header?.glibcVersionRuntime ? "glibc" : "musl";
   } catch {
     return null;
   }
@@ -1322,6 +1852,21 @@ export function isPackageCompatibleWithCurrentPlatform(
   );
 }
 
+function hasRootPackageOverride(name: string): boolean {
+  try {
+    const manifest = readJson<{
+      overrides?: Record<string, unknown>;
+      resolutions?: Record<string, unknown>;
+    }>(PACKAGE_JSON_PATH);
+    return (
+      Object.hasOwn(manifest.overrides ?? {}, name) ||
+      Object.hasOwn(manifest.resolutions ?? {}, name)
+    );
+  } catch {
+    return false;
+  }
+}
+
 function collectInstalledPackageDirs(
   name: string,
   requesterDir: string,
@@ -1332,6 +1877,12 @@ function collectInstalledPackageDirs(
 
   const addCandidate = (candidate: string): void => {
     if (!fs.existsSync(candidate) || seen.has(candidate)) return;
+    if (
+      activeRuntimeCopyTargetNodeModules &&
+      isPathInsideOrEqual(candidate, activeRuntimeCopyTargetNodeModules)
+    ) {
+      return;
+    }
     seen.add(candidate);
     candidates.push(candidate);
   };
@@ -1343,6 +1894,13 @@ function collectInstalledPackageDirs(
     }
   }
 
+  // Root overrides/resolutions are the package manager's answer for peers.
+  // Prefer that install over requester-local Bun store fallbacks so runtime
+  // packaging follows the same graph used by app-core builds.
+  if (hasRootPackageOverride(name)) {
+    addCandidate(packagePath(name, ROOT_NODE_MODULES));
+  }
+
   let dir = requesterDir;
   while (true) {
     addCandidate(packagePath(name, path.join(dir, "node_modules")));
@@ -1506,6 +2064,38 @@ export function getRuntimeDependencies(pkgPath: string): string[] {
   return getRuntimeDependencyEntries(pkgPath).map((entry) => entry.name);
 }
 
+function shouldHoistRuntimePackage(name: string): boolean {
+  return ALWAYS_HOISTED_PACKAGES.has(name) || name.startsWith("@solana/");
+}
+
+function getMajorMinorVersion(version: string | null): string | null {
+  if (!version) return null;
+  const match = version.match(/^(\d+)\.(\d+)\./);
+  return match ? `${match[1]}.${match[2]}` : null;
+}
+
+function shouldReuseTopLevelRuntimePackage(
+  name: string,
+  topLevelVersion: string | null,
+  resolvedVersion: string | null,
+): boolean {
+  if (topLevelVersion === resolvedVersion) {
+    return true;
+  }
+
+  if (!PATCH_COMPATIBLE_HOISTED_PACKAGES.has(name)) {
+    return false;
+  }
+
+  const topLevelMajorMinor = getMajorMinorVersion(topLevelVersion);
+  const resolvedMajorMinor = getMajorMinorVersion(resolvedVersion);
+  return (
+    topLevelMajorMinor !== null &&
+    resolvedMajorMinor !== null &&
+    topLevelMajorMinor === resolvedMajorMinor
+  );
+}
+
 type CopyTargetOptions = {
   name: string;
   requesterDestDir: string;
@@ -1515,6 +2105,42 @@ type CopyTargetOptions = {
   resolvedVersion: string | null;
 };
 
+function findReusableAncestorNodeModules({
+  name,
+  requesterDestDir,
+  rootDestDir,
+  resolvedVersion,
+}: Pick<
+  CopyTargetOptions,
+  "name" | "requesterDestDir" | "rootDestDir" | "resolvedVersion"
+>): string | null {
+  const root = path.resolve(rootDestDir);
+  let currentDir = requesterDestDir;
+
+  while (true) {
+    const candidateNodeModules = path.join(currentDir, "node_modules");
+    const candidatePackageDir = packagePath(name, candidateNodeModules);
+    const candidateManifest = path.join(candidatePackageDir, "package.json");
+
+    if (
+      fs.existsSync(candidateManifest) &&
+      getPackageVersion(candidateManifest) === resolvedVersion
+    ) {
+      return candidateNodeModules;
+    }
+
+    if (path.resolve(currentDir) === root) {
+      return null;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
 export function selectCopyTargetNodeModules({
   name,
   requesterDestDir,
@@ -1527,7 +2153,7 @@ export function selectCopyTargetNodeModules({
     return targetNodeModules;
   }
 
-  if (ALWAYS_HOISTED_PACKAGES.has(name) && topLevelVersions.has(name)) {
+  if (shouldHoistRuntimePackage(name) && topLevelVersions.has(name)) {
     return targetNodeModules;
   }
 
@@ -1535,11 +2161,23 @@ export function selectCopyTargetNodeModules({
     return targetNodeModules;
   }
 
-  const topLevelVersion = topLevelVersions.get(name);
-  if (topLevelVersion === resolvedVersion) {
+  const topLevelVersion = topLevelVersions.get(name) ?? null;
+  if (
+    shouldReuseTopLevelRuntimePackage(name, topLevelVersion, resolvedVersion)
+  ) {
     return targetNodeModules;
   }
 
+  const reusableAncestorNodeModules = findReusableAncestorNodeModules({
+    name,
+    requesterDestDir,
+    rootDestDir,
+    resolvedVersion,
+  });
+  if (reusableAncestorNodeModules) {
+    return reusableAncestorNodeModules;
+  }
+
   return path.join(requesterDestDir, "node_modules");
 }
 
@@ -1565,6 +2203,202 @@ function copyPgliteCompatibilityAssets(targetDist: string): void {
   }
 }
 
+function isRuntimeManifestEntryPath(value: string): boolean {
+  if (!value.startsWith("./") || value.includes("*")) {
+    return false;
+  }
+  if (/\.(?:d\.)?ts$/i.test(value) || /\.d\.[cm]?ts$/i.test(value)) {
+    return false;
+  }
+  return true;
+}
+
+function runtimeManifestEntryExists(
+  packageDir: string,
+  entryPath: string,
+): boolean {
+  const resolved = path.resolve(packageDir, entryPath);
+  const relative = path.relative(packageDir, resolved);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    return false;
+  }
+
+  if (fs.existsSync(resolved)) {
+    return true;
+  }
+
+  if (!path.extname(resolved)) {
+    return [
+      ".js",
+      ".mjs",
+      ".cjs",
+      "/index.js",
+      "/index.mjs",
+      "/index.cjs",
+    ].some((suffix) => fs.existsSync(`${resolved}${suffix}`));
+  }
+
+  return false;
+}
+
+function collectRuntimeExportEntryPaths(value: unknown): string[] {
+  if (typeof value === "string") {
+    return isRuntimeManifestEntryPath(value) ? [value] : [];
+  }
+
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectRuntimeExportEntryPaths(entry));
+  }
+
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+
+  const entries = Object.entries(value as Record<string, unknown>);
+  const hasSubpathKeys = entries.some(
+    ([key]) => key === "." || key.startsWith("./"),
+  );
+  if (hasSubpathKeys) {
+    return entries.flatMap(([, entry]) =>
+      collectRuntimeExportEntryPaths(entry),
+    );
+  }
+
+  return entries.flatMap(([condition, entry]) => {
+    if (condition === "types" || condition === "typings") {
+      return [];
+    }
+    return collectRuntimeExportEntryPaths(entry);
+  });
+}
+
+function getRequiredRuntimeEntryPaths(pkgJsonPath: string): string[] {
+  const manifest = readJson<PackageJsonManifest>(pkgJsonPath);
+  const entries = new Set<string>();
+
+  for (const entry of [manifest.main, manifest.module]) {
+    if (typeof entry === "string" && isRuntimeManifestEntryPath(entry)) {
+      entries.add(entry);
+    }
+  }
+
+  for (const entry of collectRuntimeExportEntryPaths(manifest.exports)) {
+    entries.add(entry);
+  }
+
+  return [...entries].sort();
+}
+
+function workspacePackageNeedsRuntimeBuild(packageJsonPath: string): boolean {
+  for (const entryPath of getRequiredRuntimeEntryPaths(packageJsonPath)) {
+    if (!runtimeManifestEntryExists(path.dirname(packageJsonPath), entryPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function packageHasBuildScript(packageJsonPath: string): boolean {
+  try {
+    const manifest = readJson<{ scripts?: Record<string, unknown> }>(
+      packageJsonPath,
+    );
+    return typeof manifest.scripts?.build === "string";
+  } catch {
+    return false;
+  }
+}
+
+function ensureWorkspaceRuntimeEntriesBuilt(
+  packageNames: Iterable<string>,
+): void {
+  buildWorkspacePackageIndex();
+  const built = new Set<string>();
+
+  for (const packageName of [...new Set(packageNames)].sort()) {
+    if (!isPackageNameCompatibleWithCurrentPlatform(packageName)) continue;
+
+    for (const candidate of workspacePackageIndex.get(packageName) ?? []) {
+      if (built.has(candidate.sourceDir)) continue;
+      if (!isPackageCompatibleWithCurrentPlatform(candidate.packageJsonPath)) {
+        continue;
+      }
+      if (!workspacePackageNeedsRuntimeBuild(candidate.packageJsonPath)) {
+        continue;
+      }
+      if (!packageHasBuildScript(candidate.packageJsonPath)) {
+        continue;
+      }
+
+      console.log(
+        `[runtime-copy] building ${packageName} workspace runtime entries`,
+      );
+      try {
+        execFileSync(resolveBunCommand(), ["run", "build"], {
+          cwd: candidate.sourceDir,
+          env: { ...process.env, FORCE_COLOR: "0" },
+          stdio: "inherit",
+        });
+      } catch (error) {
+        if (workspacePackageNeedsRuntimeBuild(candidate.packageJsonPath)) {
+          throw error;
+        }
+        console.warn(
+          `[runtime-copy] warning: ${packageName} build exited non-zero after producing required runtime entries; continuing`,
+        );
+      }
+      built.add(candidate.sourceDir);
+    }
+  }
+}
+
+// Post-copy assertion: missingAlwaysBundled catches resolve failures, but
+// can't catch a transitive-walk filter silently skipping a CORE plugin or
+// pruneCopiedPackageDir removing a load-bearing package.json or entrypoint.
+export function assertRequiredBundledPackagesLanded(
+  targetNodeModules: string,
+  alwaysBundled: ReadonlySet<string>,
+): void {
+  const missing: string[] = [];
+  const missingEntrypoints: string[] = [];
+  const baselinePackages = new Set(BASELINE_BUNDLED_RUNTIME_PACKAGES);
+  for (const name of alwaysBundled) {
+    if (!isPackageNameCompatibleWithCurrentPlatform(name)) continue;
+    const packageDir = packagePath(name, targetNodeModules);
+    const pkgJsonPath = path.join(packageDir, "package.json");
+    if (!fs.existsSync(pkgJsonPath)) {
+      missing.push(name);
+      continue;
+    }
+
+    if (!baselinePackages.has(name)) {
+      continue;
+    }
+
+    for (const entryPath of getRequiredRuntimeEntryPaths(pkgJsonPath)) {
+      if (!runtimeManifestEntryExists(packageDir, entryPath)) {
+        missingEntrypoints.push(
+          `${name}  (missing runtime entry ${path.join(packageDir, entryPath)})`,
+        );
+      }
+    }
+  }
+  if (missing.length === 0 && missingEntrypoints.length === 0) return;
+  throw new Error(
+    [
+      `[runtime-copy] ${missing.length + missingEntrypoints.length} required runtime package check(s) failed after copy + prune:`,
+      ...missing
+        .sort()
+        .map(
+          (n) =>
+            `  ${n}  (missing ${path.join(packagePath(n, targetNodeModules), "package.json")})`,
+        ),
+      ...missingEntrypoints.sort().map((entry) => `  ${entry}`),
+      "This usually means a filter in the transitive-walk, build output, or a rule in pruneCopiedPackageDir accidentally excluded a required package entry. Bundle is unsafe to ship.",
+    ].join("\n"),
+  );
+}
+
 function assertTarSafeRuntimePaths(targetDist: string): void {
   const unsafe: string[] = [];
 
@@ -1602,6 +2436,7 @@ function assertTarSafeRuntimePaths(targetDist: string): void {
 function main(): void {
   const { scanDir, targetDist } = parseArgs(process.argv.slice(2));
   const targetNodeModules = path.join(targetDist, "node_modules");
+  activeRuntimeCopyTargetNodeModules = targetNodeModules;
 
   if (!fs.existsSync(scanDir)) {
     throw new Error(`scan dir does not exist: ${scanDir}`);
@@ -1611,166 +2446,186 @@ function main(): void {
   }
 
   buildBunPackageIndex();
+  const releaseRuntimeCopyLock = acquireRuntimeCopyLock(targetDist);
 
-  fs.rmSync(targetNodeModules, { recursive: true, force: true });
-  fs.mkdirSync(targetNodeModules, { recursive: true });
+  try {
+    rmRecursive(targetNodeModules);
+    fs.mkdirSync(targetNodeModules, { recursive: true });
 
-  const alwaysBundled = new Set(
-    discoverAlwaysBundledPackages(PACKAGE_JSON_PATH),
-  );
-  for (const packageName of BASELINE_BUNDLED_RUNTIME_PACKAGES) {
-    if (alwaysBundled.has(packageName)) {
-      continue;
-    }
-    if (resolvePackage(packageName, null, ROOT, { includeWorkspace: false })) {
-      alwaysBundled.add(packageName);
-    }
-  }
-  const rootDependencySpecs = new Map(
-    getRuntimeDependencyEntries(PACKAGE_JSON_PATH).map((entry) => [
-      entry.name,
-      entry.spec,
-    ]),
-  );
-  const filteredOptionalPlugins = new Set<string>();
-  const discovered = new Set(
-    discoverRuntimePackages(scanDir).filter((packageName) => {
-      const shouldBundle = shouldBundleDiscoveredPackage(
-        packageName,
-        alwaysBundled,
-      );
-      if (!shouldBundle) {
-        filteredOptionalPlugins.add(packageName);
+    const alwaysBundled = new Set(
+      discoverAlwaysBundledPackages(PACKAGE_JSON_PATH),
+    );
+    for (const packageName of BASELINE_BUNDLED_RUNTIME_PACKAGES) {
+      if (alwaysBundled.has(packageName)) {
+        continue;
+      }
+      if (
+        resolvePackage(packageName, null, ROOT, { includeWorkspace: false })
+      ) {
+        alwaysBundled.add(packageName);
       }
-      return shouldBundle;
-    }),
-  );
-  const queue: QueueEntry[] = [...new Set([...alwaysBundled, ...discovered])]
-    .sort()
-    .map((name) => ({
-      name,
-      spec: rootDependencySpecs.get(name) ?? null,
-      requesterDir: ROOT,
-      requesterDestDir: targetDist,
-    }));
-
-  const copiedDestinations = new Set<string>();
-  const copiedNames = new Set<string>();
-  const missingAlwaysBundled = new Set<string>();
-  const missingDiscovered = new Set<string>();
-  const topLevelVersions = new Map<string, string | null>();
-
-  while (queue.length > 0) {
-    const request = queue.shift();
-    if (!request) continue;
-
-    const { name, spec, requesterDir, requesterDestDir } = request;
-    if (
-      !name ||
-      DEP_SKIP.has(name) ||
-      !isPackageNameCompatibleWithCurrentPlatform(name)
-    ) {
-      continue;
     }
+    const rootDependencySpecs = new Map(
+      getRuntimeDependencyEntries(PACKAGE_JSON_PATH).map((entry) => [
+        entry.name,
+        entry.spec,
+      ]),
+    );
+    const filteredOptionalPlugins = new Set<string>();
+    const discovered = new Set(
+      discoverRuntimePackages(scanDir).filter((packageName) => {
+        const shouldBundle = shouldBundleDiscoveredPackage(
+          packageName,
+          alwaysBundled,
+        );
+        if (!shouldBundle) {
+          filteredOptionalPlugins.add(packageName);
+        }
+        return shouldBundle;
+      }),
+    );
+    ensureWorkspaceRuntimeEntriesBuilt([...alwaysBundled, ...discovered]);
+    const queue: QueueEntry[] = [...new Set([...alwaysBundled, ...discovered])]
+      .sort()
+      .map((name) => ({
+        name,
+        spec: rootDependencySpecs.get(name) ?? null,
+        requesterDir: ROOT,
+        requesterDestDir: targetDist,
+      }));
+
+    const copiedDestinations = new Set<string>();
+    const copiedNames = new Set<string>();
+    const missingAlwaysBundled = new Set<string>();
+    const missingDiscovered = new Set<string>();
+    const topLevelVersions = new Map<string, string | null>();
+
+    while (queue.length > 0) {
+      const request = queue.shift();
+      if (!request) continue;
+
+      const { name, spec, requesterDir, requesterDestDir } = request;
+      if (
+        !name ||
+        DEP_SKIP.has(name) ||
+        !isPackageNameCompatibleWithCurrentPlatform(name)
+      ) {
+        continue;
+      }
+
+      const resolved = resolvePackage(name, spec, requesterDir);
+      if (!resolved) {
+        if (alwaysBundled.has(name)) {
+          missingAlwaysBundled.add(name);
+        } else {
+          missingDiscovered.add(name);
+        }
+        continue;
+      }
 
-    const resolved = resolvePackage(name, spec, requesterDir);
-    if (!resolved) {
-      if (alwaysBundled.has(name)) {
-        missingAlwaysBundled.add(name);
-      } else {
-        missingDiscovered.add(name);
+      if (!isPackageCompatibleWithCurrentPlatform(resolved.packageJsonPath)) {
+        missingAlwaysBundled.delete(name);
+        missingDiscovered.delete(name);
+        continue;
       }
-      continue;
-    }
 
-    if (!isPackageCompatibleWithCurrentPlatform(resolved.packageJsonPath)) {
-      missingAlwaysBundled.delete(name);
-      missingDiscovered.delete(name);
-      continue;
-    }
+      const resolvedVersion = getPackageVersion(resolved.packageJsonPath);
+      const copyTargetNodeModules = selectCopyTargetNodeModules({
+        name,
+        requesterDestDir,
+        rootDestDir: targetDist,
+        targetNodeModules,
+        topLevelVersions,
+        resolvedVersion,
+      });
+      const destination = packagePath(name, copyTargetNodeModules);
 
-    const resolvedVersion = getPackageVersion(resolved.packageJsonPath);
-    const copyTargetNodeModules = selectCopyTargetNodeModules({
-      name,
-      requesterDestDir,
-      rootDestDir: targetDist,
-      targetNodeModules,
-      topLevelVersions,
-      resolvedVersion,
-    });
-    const destination = packagePath(name, copyTargetNodeModules);
+      if (copiedDestinations.has(destination)) {
+        missingAlwaysBundled.delete(name);
+        missingDiscovered.delete(name);
+        copiedNames.add(name);
+        continue;
+      }
+
+      if (
+        !copyPackageDir(
+          name,
+          resolved.sourceDir,
+          copyTargetNodeModules,
+          targetDist,
+        )
+      ) {
+        if (alwaysBundled.has(name)) {
+          missingAlwaysBundled.add(name);
+        } else {
+          missingDiscovered.add(name);
+        }
+        continue;
+      }
 
-    if (copiedDestinations.has(destination)) {
       missingAlwaysBundled.delete(name);
       missingDiscovered.delete(name);
+      copiedDestinations.add(destination);
       copiedNames.add(name);
-      continue;
-    }
-
-    if (
-      !copyPackageDir(
-        name,
-        resolved.sourceDir,
-        copyTargetNodeModules,
-        targetDist,
-      )
-    ) {
-      if (alwaysBundled.has(name)) {
-        missingAlwaysBundled.add(name);
-      } else {
-        missingDiscovered.add(name);
+      if (copyTargetNodeModules === targetNodeModules) {
+        topLevelVersions.set(name, resolvedVersion);
       }
-      continue;
-    }
 
-    missingAlwaysBundled.delete(name);
-    missingDiscovered.delete(name);
-    copiedDestinations.add(destination);
-    copiedNames.add(name);
-    if (copyTargetNodeModules === targetNodeModules) {
-      topLevelVersions.set(name, resolvedVersion);
-    }
+      for (const dep of getRuntimeDependencyEntries(resolved.packageJsonPath)) {
+        if (shouldSkipPackagedDependency(name, dep.name)) {
+          continue;
+        }
 
-    for (const dep of getRuntimeDependencyEntries(resolved.packageJsonPath)) {
-      if (shouldSkipPackagedDependency(name, dep.name)) {
-        continue;
-      }
+        // Same filter as initial discovery: non-alwaysBundled plugins are
+        // post-release-installable and must not enter the transitive walk.
+        // Without this, a peerDep on an optional plugin drags its entire
+        // deep tree (e.g. @solana/codecs* nested 8 levels) into the bundle
+        // and trips assertTarSafeRuntimePaths.
+        if (!shouldBundleDiscoveredPackage(dep.name, alwaysBundled)) {
+          filteredOptionalPlugins.add(dep.name);
+          continue;
+        }
 
-      queue.push({
-        name: dep.name,
-        spec: dep.spec,
-        requesterDir: resolved.sourceDir,
-        requesterDestDir: destination,
-      });
+        queue.push({
+          name: dep.name,
+          spec: dep.spec,
+          requesterDir: resolved.sourceDir,
+          requesterDestDir: destination,
+        });
+      }
     }
-  }
 
-  copyPgliteCompatibilityAssets(targetDist);
-  assertTarSafeRuntimePaths(targetDist);
+    copyPgliteCompatibilityAssets(targetDist);
+    assertTarSafeRuntimePaths(targetDist);
+    assertRequiredBundledPackagesLanded(targetNodeModules, alwaysBundled);
 
-  console.log(
-    `[runtime-copy] bundled ${copiedNames.size} package(s) into ${targetNodeModules}`,
-  );
-  for (const name of [...copiedNames].sort()) {
-    console.log(`  copied ${name}`);
-  }
-
-  if (missingAlwaysBundled.size > 0) {
-    throw new Error(
-      `[runtime-copy] missing installed runtime package(s): ${[...missingAlwaysBundled].sort().join(", ")}`,
+    console.log(
+      `[runtime-copy] bundled ${copiedNames.size} package(s) into ${targetNodeModules}`,
     );
-  }
+    for (const name of [...copiedNames].sort()) {
+      console.log(`  copied ${name}`);
+    }
 
-  if (missingDiscovered.size > 0) {
-    console.warn(
-      `[runtime-copy] skipped unresolved optional package(s): ${[...missingDiscovered].sort().join(", ")}`,
-    );
-  }
+    if (missingAlwaysBundled.size > 0) {
+      throw new Error(
+        `[runtime-copy] missing installed runtime package(s): ${[...missingAlwaysBundled].sort().join(", ")}`,
+      );
+    }
 
-  if (filteredOptionalPlugins.size > 0) {
-    console.log(
-      `[runtime-copy] excluded post-release plugin package(s): ${[...filteredOptionalPlugins].sort().join(", ")}`,
-    );
+    if (missingDiscovered.size > 0) {
+      console.warn(
+        `[runtime-copy] skipped unresolved optional package(s): ${[...missingDiscovered].sort().join(", ")}`,
+      );
+    }
+
+    if (filteredOptionalPlugins.size > 0) {
+      console.log(
+        `[runtime-copy] excluded post-release plugin package(s): ${[...filteredOptionalPlugins].sort().join(", ")}`,
+      );
+    }
+  } finally {
+    activeRuntimeCopyTargetNodeModules = null;
+    releaseRuntimeCopyLock();
   }
 }