@s2script/sdk 0.32.0 → 0.34.0

package/dist/cli.js

@@ -3517,7 +3517,7 @@ function stripJsonComments(src) {
 // src/gamedata/types.ts
 var PLATFORM = "linuxsteamrt64";
 var ARG_KINDS = ["bool", "int", "float", "string", "utlstring", "vector", "entity", "ptr"];
-var RET_KINDS = ["void", "bool", "int", "float", "entity", "ptr"];
+var RET_KINDS = ["void", "bool", "int", "float", "entity", "ptr", "utlstringlist"];
 var INT_CLASS_ARGS = /* @__PURE__ */ new Set(["bool", "int", "string", "utlstring", "vector", "entity", "ptr"]);
 var MAX_INT_ARGS = 9;
 var MAX_FLOAT_ARGS = 8;
@@ -3587,11 +3587,14 @@ function validatePluginGamedata(gd, opts) {
     }
     const decl = rawDecl;
     const recv = decl.receiver;
-    if (!recv || recv.kind !== "entity" && recv.kind !== "none") {
-      errs.push(`${where2}: receiver.kind must be "entity" or "none"`);
-    } else if (recv.kind === "none") {
+    if (!recv || recv.kind !== "entity" && recv.kind !== "none" && recv.kind !== "interface") {
+      errs.push(`${where2}: receiver.kind must be "entity", "none" or "interface"`);
+    } else if (recv.kind === "none" || recv.kind === "interface") {
       if (recv.via !== void 0) {
-        errs.push(`${where2}: receiver.kind "none" cannot carry a 'via' sub-object hop`);
+        errs.push(`${where2}: receiver.kind "${recv.kind}" cannot carry a 'via' sub-object hop`);
+      }
+      if (recv.kind === "interface" && (typeof recv.name !== "string" || !recv.name.length)) {
+        errs.push(`${where2}: receiver.kind "interface" needs a 'name' (the interface version string)`);
       }
     } else if (recv.via !== void 0) {
       const via = recv.via;
@@ -3959,14 +3962,15 @@ var RET_TS = {
   int: "number | null",
   float: "number | null",
   entity: "EntityRef | null",
-  ptr: "Ptr | null"
+  ptr: "Ptr | null",
+  utlstringlist: "string[] | null"
 };
 function generateGamedataTypes(gd) {
   const calls = gd.calls ?? {};
   const lines = Object.keys(calls).sort().map((name) => {
     const decl = calls[name];
     const names = decl.argNames;
-    const receiverless = decl.receiver?.kind === "none";
+    const receiverless = decl.receiver?.kind === "none" || decl.receiver?.kind === "interface";
     const params = [
       ...receiverless ? [] : ["self: EntityRef"],
       ...decl.args.map((a2, i2) => `${names?.[i2] ?? `a${i2}`}: ${ARG_TS[a2]}`)
@@ -6591,7 +6595,7 @@ function positionals(args, flagsWithValue) {
 
 // src/workspace/build-all.ts
 import { writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/workspace/graph.ts
 function topoOrder(batch, warn = console.warn) {
@@ -6701,6 +6705,8 @@ function formatRangeViolations(violations) {
 }
 
 // src/workspace/bundle.ts
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "node:fs";
+import { join as join14 } from "node:path";
 var MAX_BUNDLE_MEMBERS = 64;
 function isBundleWorkspace(ws) {
   return ws.pkg.s2script?.kind === "bundle";
@@ -6710,11 +6716,50 @@ function scopeOf(name) {
   const slash = name.indexOf("/");
   return slash > 1 ? name.slice(1, slash) : null;
 }
-function bundleProblems(ws) {
-  if (!isBundleWorkspace(ws)) return [];
-  const pkg = ws.pkg;
-  const problems = [];
+function bundlesField(ws) {
+  return ws.pkg.s2script?.workspace?.bundles;
+}
+function bundleSources(ws) {
+  const raw = bundlesField(ws);
   const where2 = "package.json (workspace root)";
+  if (raw === void 0) return { sources: [], problems: [] };
+  if (!Array.isArray(raw) || raw.some((g) => typeof g !== "string" || g === "")) {
+    return { sources: [], problems: [`${where2}: s2script.workspace.bundles must be an array of directories or globs`] };
+  }
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  const sources2 = [];
+  for (const glob of raw) {
+    const dirs = expandDirGlob(ws.root, glob).filter((rel) => existsSync11(join14(ws.root, rel, "package.json")));
+    if (dirs.length === 0) {
+      problems.push(`${where2}: s2script.workspace.bundles entry ${JSON.stringify(glob)} matches no directory with a package.json`);
+      continue;
+    }
+    for (const rel of dirs) {
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      const dir = join14(ws.root, rel);
+      try {
+        sources2.push({ relDir: rel, dir, pkg: JSON.parse(readFileSync12(join14(dir, "package.json"), "utf8")) });
+      } catch (e) {
+        sources2.push({ relDir: rel, dir, pkg: null, error: `cannot read ${rel}/package.json: ${e.message}` });
+      }
+    }
+  }
+  return { sources: sources2.sort((a2, b) => a2.relDir < b.relDir ? -1 : 1), problems };
+}
+function isUnder(relDir, bundleRel) {
+  return bundleRel === "" || relDir.startsWith(`${bundleRel}/`);
+}
+function membersOf(ws, bundleRel) {
+  return ws.plugins.filter((p) => !p.private && isUnder(p.relDir, bundleRel));
+}
+function optionalOf(pkg) {
+  const optional = pkg.s2script?.bundle?.optional;
+  return Array.isArray(optional) ? optional.filter((o) => typeof o === "string") : [];
+}
+function declarationProblems(where2, pkg, members) {
+  const problems = [];
   if (typeof pkg.name !== "string" || pkg.name === "") {
     problems.push(`${where2}: a bundle needs a "name" \u2014 it is the bundle's registry name`);
   }
@@ -6723,13 +6768,12 @@ function bundleProblems(ws) {
   }
   if (pkg.private === true) {
     problems.push(
-      `${where2}: s2script.kind is "bundle" but the root is "private": true \u2014 a private root is never published; remove "private" or drop the bundle kind`
+      `${where2}: s2script.kind is "bundle" but the package is "private": true \u2014 a private bundle is never published; remove "private" or drop the bundle kind`
     );
   }
   if (pkg.main !== void 0 || pkg.s2script?.main !== void 0) {
     problems.push(`${where2}: a bundle has no code of its own \u2014 remove "main"`);
   }
-  const members = ws.plugins.filter((p) => !p.private);
   if (members.length === 0) {
     problems.push(`${where2}: a bundle needs at least one non-private plugin in s2script.workspace.plugins`);
   }
@@ -6762,7 +6806,7 @@ function bundleProblems(ws) {
   for (const name of optional) {
     if (!memberNames.has(name)) {
       problems.push(
-        `${where2}: s2script.bundle.optional names ${JSON.stringify(name)}, which is not a non-private plugin of this workspace`
+        `${where2}: s2script.bundle.optional names ${JSON.stringify(name)}, which is not a non-private plugin of this bundle`
       );
     }
   }
@@ -6771,16 +6815,78 @@ function bundleProblems(ws) {
   }
   return problems;
 }
-function readBundle(ws) {
-  if (!isBundleWorkspace(ws)) return null;
-  const optional = ws.pkg.s2script.bundle?.optional ?? [];
+function bundleProblems(ws) {
+  const rootBundle = isBundleWorkspace(ws);
+  const { sources: sources2, problems } = bundleSources(ws);
+  if (rootBundle && bundlesField(ws) !== void 0) {
+    problems.push(
+      `package.json (workspace root): s2script.kind is "bundle" and s2script.workspace.bundles is set \u2014 a root bundle cannot also contain bundles; drop the root's kind, or drop the bundles list`
+    );
+    return problems;
+  }
+  if (rootBundle) return [...problems, ...declarationProblems("package.json (workspace root)", ws.pkg, membersOf(ws, ""))];
+  const memberDirs = new Set([...ws.plugins, ...ws.libs].map((m) => m.relDir));
+  const byName = /* @__PURE__ */ new Map();
+  for (const src of sources2) {
+    const where2 = `${src.relDir}/package.json`;
+    if (src.pkg === null) {
+      problems.push(src.error);
+      continue;
+    }
+    if (src.pkg.s2script?.kind !== "bundle") {
+      problems.push(`${where2}: is listed in s2script.workspace.bundles but has no s2script.kind "bundle"`);
+      continue;
+    }
+    if (src.pkg.s2script.workspace !== void 0) {
+      problems.push(
+        `${where2}: a bundle directory must not carry s2script.workspace \u2014 s2s would treat it as its own workspace root when run inside it; remove the block (the parent root is the workspace)`
+      );
+    }
+    if (memberDirs.has(src.relDir)) {
+      problems.push(
+        `${src.relDir}: is both a workspace package and a bundle directory \u2014 narrow the root's "workspaces" globs so the bundle descriptor is not a package`
+      );
+    }
+    const nested = sources2.find((o) => o !== src && isUnder(src.relDir, o.relDir));
+    if (nested) {
+      problems.push(`${src.relDir}: is inside bundle directory ${nested.relDir} \u2014 bundle directories cannot nest`);
+    }
+    if (typeof src.pkg.name === "string" && src.pkg.name !== "") {
+      const first = byName.get(src.pkg.name);
+      if (first !== void 0) {
+        problems.push(`${src.relDir}: duplicate bundle name ${JSON.stringify(src.pkg.name)} \u2014 already declared by ${first}`);
+      } else {
+        byName.set(src.pkg.name, src.relDir);
+      }
+    }
+    problems.push(...declarationProblems(where2, src.pkg, membersOf(ws, src.relDir)));
+  }
+  return problems;
+}
+function toBundle(ws, relDir, dir, pkg) {
   return {
-    name: ws.pkg.name,
-    version: ws.pkg.version,
-    members: ws.plugins.filter((p) => !p.private),
-    optional: new Set(optional)
+    name: pkg.name,
+    version: pkg.version,
+    dir,
+    relDir,
+    pkg,
+    members: membersOf(ws, relDir),
+    optional: new Set(optionalOf(pkg))
   };
 }
+function readBundle(ws) {
+  return isBundleWorkspace(ws) ? toBundle(ws, "", ws.root, ws.pkg) : null;
+}
+function readBundles(ws) {
+  const root = readBundle(ws);
+  if (root) return [root];
+  return bundleSources(ws).sources.filter((s) => s.pkg?.s2script?.kind === "bundle").map((s) => toBundle(ws, s.relDir, s.dir, s.pkg));
+}
+function bundleOfPlugin(bundles) {
+  const out = /* @__PURE__ */ new Map();
+  for (const b of bundles) for (const m of b.members) out.set(m.name, b.name);
+  return out;
+}
 function bundleMembers(bundle) {
   const out = {};
   for (const m of bundle.members) {
@@ -6911,7 +7017,7 @@ function stampWorkspaceVersion(ws, version) {
         dirty = true;
       }
     }
-    if (dirty) writeFileSync4(join14(p.dir, "package.json"), `${JSON.stringify(next, null, 2)}
+    if (dirty) writeFileSync4(join15(p.dir, "package.json"), `${JSON.stringify(next, null, 2)}
 `);
   }
   return result;
@@ -8392,11 +8498,11 @@ async function runWorkspace(argv2, root, interactive, filters, stampVersion) {
 import { resolve as resolve16 } from "node:path";
 
 // src/registry/deploy.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync15 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync16 } from "node:fs";
 import { resolve as resolve15 } from "node:path";
 
 // src/types-pack.ts
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 
 // src/tar.ts
 import { gzipSync } from "node:zlib";
@@ -8452,7 +8558,7 @@ function packTar(files, opts = {}) {
 
 // src/types-pack.ts
 function packTypesTarball(input) {
-  const dts = readFileSync12(input.typesPath);
+  const dts = readFileSync13(input.typesPath);
   const pkgJson = Buffer.from(
     JSON.stringify(
       {
@@ -8477,8 +8583,8 @@ function packTypesTarball(input) {
 
 // src/source-pack.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync5 } from "node:fs";
-import { dirname as dirname6, join as join15, relative as relative3, resolve as resolve14, sep as sep4 } from "node:path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
+import { dirname as dirname6, join as join16, relative as relative3, resolve as resolve14, sep as sep4 } from "node:path";
 
 // ../../node_modules/balanced-match/dist/esm/index.js
 var balanced = (a2, b, str) => {
@@ -10376,7 +10482,7 @@ function readIgnoreFile(dir) {
   for (const name of [".npmignore", ".gitignore"]) {
     let text3;
     try {
-      text3 = readFileSync13(join15(dir, name), "utf8");
+      text3 = readFileSync14(join16(dir, name), "utf8");
     } catch {
       continue;
     }
@@ -10433,7 +10539,7 @@ function entryPoints(pkg) {
 function npmWorkspaceRoot(absDir) {
   for (let d = dirname6(absDir); ; d = dirname6(d)) {
     try {
-      const pj = JSON.parse(readFileSync13(join15(d, "package.json"), "utf8"));
+      const pj = JSON.parse(readFileSync14(join16(d, "package.json"), "utf8"));
       if (pj && pj.workspaces) return d;
     } catch {
     }
@@ -10452,7 +10558,7 @@ function workspaceRulesets(absDir) {
 }
 function listPackageFiles(dir, pkg) {
   const absDir = resolve14(dir);
-  const pj = pkg ?? JSON.parse(readFileSync13(join15(absDir, "package.json"), "utf8"));
+  const pj = pkg ?? JSON.parse(readFileSync14(join16(absDir, "package.json"), "utf8"));
   const files = filesPatterns(pj.files);
   const never = (0, import_ignore.default)().add(NEVER_PACKED);
   const forced = new Set(entryPoints(pj));
@@ -10465,7 +10571,7 @@ function listPackageFiles(dir, pkg) {
       (a2, b) => a2.name < b.name ? -1 : a2.name > b.name ? 1 : 0
     );
     for (const entry of entries) {
-      const childAbs = join15(abs, entry.name);
+      const childAbs = join16(abs, entry.name);
       const rel = toPosix2(relative3(absDir, childAbs));
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
@@ -10490,8 +10596,8 @@ function listPackageFiles(dir, pkg) {
 function packSourceTarball(dir, pkg) {
   const absDir = resolve14(dir);
   const files = listPackageFiles(absDir, pkg).map((path2) => {
-    const abs = join15(absDir, path2);
-    const content = readFileSync13(abs);
+    const abs = join16(absDir, path2);
+    const content = readFileSync14(abs);
     const mode = statSync5(abs).mode & 73 ? 493 : 420;
     return { path: path2, content, mode };
   });
@@ -10518,11 +10624,11 @@ function tarballFilename(name, version) {
 }
 
 // src/registry/credentials.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function credentialsPath() {
-  return join16(homedir(), ".s2script", "credentials.json");
+  return join17(homedir(), ".s2script", "credentials.json");
 }
 function normalizeRegistryUrl(url) {
   const trimmed = url.replace(/\/$/, "");
@@ -10540,9 +10646,9 @@ function loadCredentials() {
     return { registryUrl: defaultRegistryUrl(), token: fromEnv };
   }
   const p = credentialsPath();
-  if (!existsSync11(p)) return null;
+  if (!existsSync12(p)) return null;
   try {
-    const j = JSON.parse(readFileSync14(p, "utf8"));
+    const j = JSON.parse(readFileSync15(p, "utf8"));
     if (!j.token) return null;
     return {
       registryUrl: normalizeRegistryUrl(j.registryUrl || defaultRegistryUrl()),
@@ -10553,7 +10659,7 @@ function loadCredentials() {
   }
 }
 function saveCredentials(creds) {
-  const dir = join16(homedir(), ".s2script");
+  const dir = join17(homedir(), ".s2script");
   mkdirSync4(dir, { recursive: true });
   writeFileSync5(
     credentialsPath(),
@@ -10804,7 +10910,7 @@ function readPackageReadme(pluginDir) {
   const names = readdirSync6(pluginDir).filter((n3) => /^readme(\.(md|markdown))?$/i.test(n3));
   if (names.length === 0) return null;
   const name = names.find((n3) => n3 === "README.md") ?? names.sort()[0];
-  const text3 = readFileSync15(resolve15(pluginDir, name), "utf8").trim();
+  const text3 = readFileSync16(resolve15(pluginDir, name), "utf8").trim();
   if (!text3) return null;
   if (text3.length > MAX_README_CHARS) {
     throw new Error(
@@ -10828,7 +10934,7 @@ function assembleDeployArchive(pluginDir, pkg, outPath, opts = {}) {
   const absDir = resolve15(pluginDir);
   const access = opts.access ?? resolveAccess(pkg);
   if (packageKind(pkg) === "library") {
-    const lib = readFileSync15(outPath);
+    const lib = readFileSync16(outPath);
     const manifestEntry2 = unzipSync(lib)["manifest.json"];
     if (!manifestEntry2) {
       throw new Error(`built archive missing manifest.json: ${outPath}`);
@@ -10845,7 +10951,7 @@ function assembleDeployArchive(pluginDir, pkg, outPath, opts = {}) {
   }
   const gate = assertPublishesTypes(pkg, absDir);
   if (!gate.ok) throw new Error(`publish gate failed: ${gate.error}`);
-  const s2sp = readFileSync15(outPath);
+  const s2sp = readFileSync16(outPath);
   const manifestEntry = unzipSync(s2sp)["manifest.json"];
   if (!manifestEntry) {
     throw new Error(`built archive missing manifest.json: ${outPath}`);
@@ -10871,7 +10977,7 @@ function assembleDeployArchive(pluginDir, pkg, outPath, opts = {}) {
 }
 async function deployPlugin(opts) {
   const absDir = resolve15(opts.dir);
-  const pkg = JSON.parse(readFileSync15(resolve15(absDir, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync16(resolve15(absDir, "package.json"), "utf8"));
   assertDeployable(pkg, absDir);
   const access = resolveAccess(pkg, opts.access);
   assertAccessAllowed(pkg.name ?? absDir, access);
@@ -10966,7 +11072,8 @@ async function uploadPlan(plan, built, client, opts = {}) {
       const archive = assembleDeployArchive(b.plugin.dir, b.plugin.pkg, b.outPath, {
         access: opts.access
       });
-      if (opts.bundle !== void 0) archive.manifest = { ...archive.manifest, bundle: opts.bundle };
+      const bundle = typeof opts.bundle === "string" ? opts.bundle : opts.bundle?.get(entry.plugin.name);
+      if (bundle !== void 0) archive.manifest = { ...archive.manifest, bundle };
       const res = await client.deploy(archive);
       results.push({ plugin: entry.plugin, status: "published", detail: res.reviewState });
     } catch (e) {
@@ -11128,11 +11235,17 @@ async function runWorkspaceDeploy(opts) {
   }
   const { ordered, built, unpublishableLibraries } = builtPluginsFromOutcomes(ws, build3.outcomes);
   const plan = await computePlan(ordered, (name, version) => isAlreadyPublished(client, name, version));
-  const bundle = readBundle(ws);
-  const bundleEntry = bundle ? await planBundle(bundle, client) : null;
+  const inRun = new Set(ordered.map((p) => p.name));
+  const bundles = readBundles(ws);
+  const planned = bundles.filter((b) => b.members.every((m) => inRun.has(m.name)));
+  const bundleEntries = [];
+  for (const b of planned) bundleEntries.push(await planBundle(b, client));
   label("plan:");
   console.log(formatPlan(plan));
-  if (bundleEntry) console.log(formatBundlePlan(bundleEntry));
+  for (const entry of bundleEntries) console.log(formatBundlePlan(entry));
+  for (const b of bundles) {
+    if (!planned.includes(b)) console.log(`    ${b.name} ${b.version}   skip (not every member is in --filter)`);
+  }
   if (unpublishableLibraries.length > 0) {
     console.log(formatUnpublishableLibraries(unpublishableLibraries));
   }
@@ -11143,14 +11256,15 @@ async function runWorkspaceDeploy(opts) {
     assertAccessAllowed(e.plugin.name, a2);
     if (a2 === "restricted") restricted.push(e.plugin.name);
   }
-  if (bundleEntry?.reason === "PUBLISH") {
-    const a2 = accessFlag ?? resolveAccess(ws.pkg);
-    assertAccessAllowed(bundleEntry.bundle.name, a2);
-    if (a2 !== void 0) bundleEntry.manifest = { ...bundleEntry.manifest, access: a2 };
-    if (a2 === "restricted") restricted.push(bundleEntry.bundle.name);
+  for (const entry of bundleEntries) {
+    if (entry.reason !== "PUBLISH") continue;
+    const a2 = accessFlag ?? resolveAccess(entry.bundle.pkg);
+    assertAccessAllowed(entry.bundle.name, a2);
+    if (a2 !== void 0) entry.manifest = { ...entry.manifest, access: a2 };
+    if (a2 === "restricted") restricted.push(entry.bundle.name);
   }
   if (restricted.length > 0) console.log(`    restricted: ${restricted.join(", ")}`);
-  const bundlePublishes = bundleEntry?.reason === "PUBLISH" ? 1 : 0;
+  const bundlePublishes = bundleEntries.filter((e) => e.reason === "PUBLISH").length;
   const toPublish = publishCount(plan) + bundlePublishes;
   const noun = (n3) => `${n3} package${n3 === 1 ? "" : "s"}`;
   if (toPublish === 0) {
@@ -11182,7 +11296,7 @@ async function runWorkspaceDeploy(opts) {
       process.exit(130);
     }
   }
-  const results = await uploadPlan(plan, built, client, { bundle: bundle?.name, access: accessFlag });
+  const results = await uploadPlan(plan, built, client, { bundle: bundleOfPlugin(bundles), access: accessFlag });
   let failures = 0;
   for (const r2 of results) {
     if (r2.status === "failed") failures++;
@@ -11193,8 +11307,9 @@ async function runWorkspaceDeploy(opts) {
       console.log(line);
     }
   }
-  if (bundleEntry) {
-    const r2 = await uploadBundle(bundleEntry, results, client);
+  for (const entry of bundleEntries) {
+    const members = new Set(entry.bundle.members.map((m) => m.name));
+    const r2 = await uploadBundle(entry, results.filter((m) => members.has(m.plugin.name)), client);
     if (r2.status === "failed") failures++;
     const line = `${r2.bundle.name}@${r2.bundle.version} (bundle): ${r2.status}${r2.detail ? ` (${r2.detail})` : ""}`;
     if (interactive) {
@@ -11212,14 +11327,14 @@ async function runWorkspaceDeploy(opts) {
 import { resolve as resolve17 } from "node:path";
 
 // src/version/version.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join21 } from "node:path";
 
 // src/version/changesets.ts
 var import_semver = __toESM(require_semver2(), 1);
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { pathToFileURL } from "node:url";
 var SUPPORTED = {
   "@changesets/assemble-release-plan": ">=6.0.0 <7.0.0",
@@ -11239,7 +11354,7 @@ function named(mod, key) {
   return outer?.[key];
 }
 async function loadChangesets(workspaceRoot) {
-  const require3 = createRequire2(join17(workspaceRoot, "package.json"));
+  const require3 = createRequire2(join18(workspaceRoot, "package.json"));
   const missing = [];
   const wrongVersion = [];
   const resolved = /* @__PURE__ */ new Map();
@@ -11254,7 +11369,7 @@ async function loadChangesets(workspaceRoot) {
       missing.push(name);
       continue;
     }
-    const version = String(JSON.parse(readFileSync16(manifest, "utf8")).version ?? "");
+    const version = String(JSON.parse(readFileSync17(manifest, "utf8")).version ?? "");
     if (!(0, import_semver.satisfies)(version, range2, { includePrerelease: true })) {
       wrongVersion.push(`${name}@${version} (supported: ${range2})`);
       continue;
@@ -11354,8 +11469,8 @@ function mirrorPackages(ws) {
 
 // src/version/ranges.ts
 var import_semver2 = __toESM(require_semver2(), 1);
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join18 } from "node:path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join19 } from "node:path";
 var BUMP_LEVEL = { none: 0, patch: 1, minor: 2, major: 3 };
 function rangePrefix(range2) {
   if (range2.startsWith(">=")) return ">=";
@@ -11374,7 +11489,7 @@ function shouldUpdate(release, range2, config) {
   return BUMP_LEVEL[release.type] >= minLevel;
 }
 function readJsonFile(path2) {
-  const raw = readFileSync17(path2, "utf8");
+  const raw = readFileSync18(path2, "utf8");
   const match2 = /^[ \t]*[{[]\s*\n([ \t]+)/.exec(raw);
   return {
     json: JSON.parse(raw),
@@ -11415,7 +11530,7 @@ function rewriteSiblingRanges(ws, releases, config) {
   for (const [consumerName, ifaceRanges] of edits) {
     const plugin = ws.plugins.find((p) => p.name === consumerName);
     if (plugin === void 0) continue;
-    const path2 = join18(plugin.dir, "package.json");
+    const path2 = join19(plugin.dir, "package.json");
     const { json, indent, eol } = readJsonFile(path2);
     const s2 = json.s2script;
     if (s2?.pluginDependencies === void 0) continue;
@@ -11429,42 +11544,46 @@ function rewriteSiblingRanges(ws, releases, config) {
 // src/version/bundle-bump.ts
 var import_semver3 = __toESM(require_semver2(), 1);
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 var LEVEL = { none: 0, patch: 1, minor: 2, major: 3 };
-function plannedBundleBump(ws, releases) {
-  const bundle = readBundle(ws);
-  if (!bundle) return null;
+function plannedBundleBump(bundle, releases) {
   const members = new Set(bundle.members.map((m) => m.name));
   const memberReleases = releases.filter((r2) => members.has(r2.name) && r2.type !== "none");
   if (memberReleases.length === 0) return null;
   const type = memberReleases.reduce((t2, r2) => LEVEL[r2.type] > LEVEL[t2] ? r2.type : t2, "none");
   const to = (0, import_semver3.inc)(bundle.version, type);
   if (to === null) {
-    throw new Error(`s2s version: the bundle's version ${JSON.stringify(bundle.version)} is not valid semver`);
+    throw new Error(
+      `s2s version: the bundle ${bundle.name}'s version ${JSON.stringify(bundle.version)} is not valid semver`
+    );
   }
   return {
     name: bundle.name,
     from: bundle.version,
     to,
     type,
-    because: memberReleases.map((r2) => `${r2.name}@${r2.newVersion}`)
+    because: memberReleases.map((r2) => `${r2.name}@${r2.newVersion}`),
+    path: join20(bundle.dir, "package.json")
   };
 }
-function bumpBundle(ws, releases) {
-  const bump = plannedBundleBump(ws, releases);
-  if (!bump) return { bump: null, touchedFiles: [] };
-  const path2 = join19(ws.root, "package.json");
-  const { json, indent, eol } = readJsonFile(path2);
-  json.version = bump.to;
-  writeFileSync7(path2, JSON.stringify(json, null, indent) + eol);
-  return { bump, touchedFiles: [path2] };
+function plannedBundleBumps(ws, releases) {
+  return readBundles(ws).map((b) => plannedBundleBump(b, releases)).filter((b) => b !== null);
+}
+function bumpBundles(ws, releases) {
+  const bumps = plannedBundleBumps(ws, releases);
+  for (const bump of bumps) {
+    const { json, indent, eol } = readJsonFile(bump.path);
+    json.version = bump.to;
+    writeFileSync7(bump.path, JSON.stringify(json, null, indent) + eol);
+  }
+  return { bumps, touchedFiles: bumps.map((b) => b.path) };
 }
 
 // src/version/version.ts
 async function versionWorkspace(root, opts = {}) {
   const ws = loadWorkspace(root);
-  const configPath = join20(ws.root, ".changeset", "config.json");
-  if (!existsSync12(configPath)) {
+  const configPath = join21(ws.root, ".changeset", "config.json");
+  if (!existsSync13(configPath)) {
     throw new Error(
       `s2s version: ${configPath} does not exist \u2014 this workspace is not set up for changesets. Run \`npx changeset init\` at ${ws.root}.`
     );
@@ -11478,15 +11597,15 @@ async function versionWorkspace(root, opts = {}) {
   const plan = cs.assembleReleasePlan(changesets, mirror, config, preState);
   const touchedFiles = await cs.applyReleasePlan(plan, real, config);
   const ranges = rewriteSiblingRanges(ws, plan.releases, config);
-  const bundle = bumpBundle(ws, plan.releases);
+  const bundles = bumpBundles(ws, plan.releases);
   return {
     root: ws.root,
     changesetCount: changesets.length,
     releases: plan.releases,
     rewrites: ranges.rewrites,
     skips: ranges.skips,
-    bundleBump: bundle.bump,
-    touchedFiles: [...touchedFiles, ...ranges.touchedFiles, ...bundle.touchedFiles],
+    bundleBumps: bundles.bumps,
+    touchedFiles: [...touchedFiles, ...ranges.touchedFiles, ...bundles.touchedFiles],
     changesetsVersions: cs.versions
   };
 }
@@ -11522,8 +11641,7 @@ async function run3(argv2) {
     for (const r2 of result.releases) {
       lines.push(`${r2.name} ${r2.oldVersion} -> ${r2.newVersion} (${r2.type})`);
     }
-    if (result.bundleBump) {
-      const b = result.bundleBump;
+    for (const b of result.bundleBumps) {
       lines.push(`${b.name} ${b.from} -> ${b.to} (${b.type}, bundle \u2014 follows ${b.because.join(", ")})`);
     }
     for (const rw of result.rewrites) {
@@ -11551,15 +11669,15 @@ import { resolve as resolve19 } from "node:path";
 import {
   mkdirSync as mkdirSync6,
   writeFileSync as writeFileSync10,
-  readFileSync as readFileSync19,
-  existsSync as existsSync14
+  readFileSync as readFileSync20,
+  existsSync as existsSync15
 } from "node:fs";
-import { join as join23, resolve as resolve18 } from "node:path";
+import { join as join24, resolve as resolve18 } from "node:path";
 import { gunzipSync } from "node:zlib";
 
 // src/registry/npmrc.ts
-import { existsSync as existsSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join22 } from "node:path";
 function npmCompatRegistryUrl(registryUrl) {
   return `${registryUrl.replace(/\/$/, "")}/npm/`;
 }
@@ -11575,8 +11693,8 @@ function ensureScopeNpmrc(projectDir, packageName, registryUrl) {
   const compat = npmCompatRegistryUrl(registryUrl);
   const key = `@${scope}:registry`;
   const line = `${key}=${compat}`;
-  const npmrcPath = join21(projectDir, ".npmrc");
-  let existing = existsSync13(npmrcPath) ? readFileSync18(npmrcPath, "utf8") : "";
+  const npmrcPath = join22(projectDir, ".npmrc");
+  let existing = existsSync14(npmrcPath) ? readFileSync19(npmrcPath, "utf8") : "";
   const lines = existing.split(/\r?\n/);
   const idx = lines.findIndex((l2) => l2.trimStart().startsWith(`${key}=`) || l2.trimStart().startsWith(`${key} =`));
   if (idx >= 0) {
@@ -11592,7 +11710,7 @@ function ensureScopeNpmrc(projectDir, packageName, registryUrl) {
 
 // src/registry/lib-extract.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 var WANTED = /* @__PURE__ */ new Set(["index.js", "index.d.ts"]);
 function extractLibArchive(s2lib, outDir, meta) {
   const entries = unzipSync(new Uint8Array(s2lib));
@@ -11601,7 +11719,7 @@ function extractLibArchive(s2lib, outDir, meta) {
   mkdirSync5(outDir, { recursive: true });
   for (const [name, bytes] of Object.entries(entries)) {
     if (!WANTED.has(name)) continue;
-    writeFileSync9(join22(outDir, name), Buffer.from(bytes));
+    writeFileSync9(join23(outDir, name), Buffer.from(bytes));
   }
   let apiVersion = "1.x";
   try {
@@ -11610,7 +11728,7 @@ function extractLibArchive(s2lib, outDir, meta) {
   } catch {
   }
   writeFileSync9(
-    join22(outDir, "package.json"),
+    join23(outDir, "package.json"),
     JSON.stringify(
       { name: meta.name, version: meta.version, main: "index.js", types: "index.d.ts", s2script: { kind: "library", apiVersion } },
       null,
@@ -11647,13 +11765,13 @@ function extractTypesTarball(tgz, outDir) {
     if (!name || name.endsWith("/")) continue;
     const base = name.replace(/^package\//, "");
     if (base === "package.json") {
-      writeFileSync10(join23(outDir, "package.json"), content);
+      writeFileSync10(join24(outDir, "package.json"), content);
     } else if (base === "api.d.ts" || base === "index.d.ts") {
-      writeFileSync10(join23(outDir, "index.d.ts"), content);
+      writeFileSync10(join24(outDir, "index.d.ts"), content);
       wroteContract = true;
     }
   }
-  if (!wroteContract && !existsSync14(join23(outDir, "index.d.ts"))) {
+  if (!wroteContract && !existsSync15(join24(outDir, "index.d.ts"))) {
     throw new Error("types tarball missing package/api.d.ts (or index.d.ts)");
   }
 }
@@ -11678,10 +11796,10 @@ async function addPackage(opts) {
   }
   if (resolved.kind === "library") {
     const s2lib = await client.downloadLib(name, resolved.version);
-    const libDir = join23(absDir, ".s2script", "libs", ...name.split("/"));
+    const libDir = join24(absDir, ".s2script", "libs", ...name.split("/"));
     extractLibArchive(s2lib, libDir, { name, version: resolved.version });
-    const pkgPath2 = join23(absDir, "package.json");
-    const pkg2 = JSON.parse(readFileSync19(pkgPath2, "utf8"));
+    const pkgPath2 = join24(absDir, "package.json");
+    const pkg2 = JSON.parse(readFileSync20(pkgPath2, "utf8"));
     pkg2.s2script = pkg2.s2script ?? {};
     pkg2.s2script.libraries = pkg2.s2script.libraries ?? {};
     pkg2.s2script.libraries[name] = rangeForResolved(range2, resolved.version);
@@ -11702,10 +11820,10 @@ async function addPackage(opts) {
     throw new Error(`${name}@${resolved.version} has no types artifact (runtime-only package?)`);
   }
   const tgz = await client.downloadTypes(name, resolved.version);
-  const typesDir = join23(absDir, ".s2script", "types", ...name.split("/"));
+  const typesDir = join24(absDir, ".s2script", "types", ...name.split("/"));
   extractTypesTarball(tgz, typesDir);
-  const pkgPath = join23(absDir, "package.json");
-  const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
+  const pkgPath = join24(absDir, "package.json");
+  const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
   pkg.s2script = pkg.s2script ?? {};
   pkg.s2script.pluginDependencies = pkg.s2script.pluginDependencies ?? {};
   pkg.s2script.pluginDependencies[name] = rangeForResolved(range2, resolved.version);
@@ -11786,37 +11904,37 @@ async function run4(argv2) {
 }
 
 // src/commands/install.ts
-import { existsSync as existsSync19, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync20, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join28 } from "node:path";
 
 // src/server/manifest.ts
 var import_semver4 = __toESM(require_semver2(), 1);
-import { existsSync as existsSync15, readFileSync as readFileSync20, renameSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename2, join as join24, resolve as resolve20 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync21, renameSync, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename2, join as join25, resolve as resolve20 } from "node:path";
 var SERVER_MANIFEST = "plugins.json";
 var SERVER_LOCK = "plugins-lock.json";
 var PLUGINS_SUBDIR = "plugins";
 var DISABLED_SUBDIR = "disabled";
 function readJson(path2) {
-  const j = JSON.parse(readFileSync20(path2, "utf8"));
+  const j = JSON.parse(readFileSync21(path2, "utf8"));
   if (!j || typeof j !== "object" || Array.isArray(j)) throw new Error(`${path2}: must be a JSON object`);
   return j;
 }
 function findServerRoot(start) {
   for (const dir of [resolve20(start), resolve20(start, "addons", "s2script")]) {
-    if (existsSync15(join24(dir, SERVER_MANIFEST))) return dir;
+    if (existsSync16(join25(dir, SERVER_MANIFEST))) return dir;
   }
   return null;
 }
 function findAddonRoot(start) {
   const found = findServerRoot(start);
   if (found) return found;
-  if (existsSync15(resolve20(start, PLUGINS_SUBDIR))) return resolve20(start);
+  if (existsSync16(resolve20(start, PLUGINS_SUBDIR))) return resolve20(start);
   const nested = resolve20(start, "addons", "s2script");
-  return existsSync15(nested) ? nested : null;
+  return existsSync16(nested) ? nested : null;
 }
 function parseServerManifest(root, raw) {
-  const label = join24(root, SERVER_MANIFEST);
+  const label = join25(root, SERVER_MANIFEST);
   const depsRaw = raw.dependencies ?? {};
   if (typeof depsRaw !== "object" || Array.isArray(depsRaw)) {
     throw new Error(`${label}: "dependencies" must be an object (plugin name \u2192 version range)`);
@@ -11865,8 +11983,8 @@ function parseServerManifest(root, raw) {
   };
 }
 function readServerManifest(root) {
-  const path2 = join24(root, SERVER_MANIFEST);
-  if (!existsSync15(path2)) throw new Error(`no ${SERVER_MANIFEST} in ${root} \u2014 run \`s2s server init\` first`);
+  const path2 = join25(root, SERVER_MANIFEST);
+  if (!existsSync16(path2)) throw new Error(`no ${SERVER_MANIFEST} in ${root} \u2014 run \`s2s server init\` first`);
   return parseServerManifest(root, readJson(path2));
 }
 function newServerManifestJson(name, dependencies) {
@@ -11880,15 +11998,15 @@ function writeServerManifest(m) {
   else delete out.with;
   if (m.disabled.length > 0) out.disabled = [...m.disabled].sort();
   else delete out.disabled;
-  const path2 = join24(m.root, SERVER_MANIFEST);
+  const path2 = join25(m.root, SERVER_MANIFEST);
   const tmp = `${path2}.${process.pid}.tmp`;
   writeFileSync11(tmp, JSON.stringify(out, null, 2) + "\n");
   renameSync(tmp, path2);
 }
 
 // src/server/commands.ts
-import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join26, resolve as resolve22 } from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync7, readFileSync as readFileSync24, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join27, resolve as resolve22 } from "node:path";
 var import_semver5 = __toESM(require_semver2(), 1);
 
 // src/registry/install.ts
@@ -11941,7 +12059,7 @@ async function resolveMerged(client, specs, withMembers = {}) {
 
 // src/server/lock.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync21, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync22, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
 var LOCKFILE_VERSION = 3;
 function integrityFromSha256Hex(hex) {
   return `sha256-${Buffer.from(hex, "hex").toString("base64")}`;
@@ -12015,8 +12133,8 @@ function parseLock(text3, label = "plugins-lock.json") {
   };
 }
 function readLock(path2) {
-  if (!existsSync16(path2)) return null;
-  return parseLock(readFileSync21(path2, "utf8"), path2);
+  if (!existsSync17(path2)) return null;
+  return parseLock(readFileSync22(path2, "utf8"), path2);
 }
 function writeLock(path2, lock) {
   const tmp = `${path2}.${process.pid}.tmp`;
@@ -12025,8 +12143,8 @@ function writeLock(path2, lock) {
 }
 
 // src/server/sync.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync22, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname7, join as join25, resolve as resolve21, sep as sep5 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync23, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname7, join as join26, resolve as resolve21, sep as sep5 } from "node:path";
 function relPath(t2) {
   return t2.disabled ? `${DISABLED_SUBDIR}/${t2.filename}` : t2.filename;
 }
@@ -12107,18 +12225,18 @@ async function syncPlugins(opts) {
   try {
     for (const t2 of opts.targets) {
       const key = lockKey(relPath(t2));
-      const dest = join25(dir, relPath(t2));
+      const dest = join26(dir, relPath(t2));
       result.plugins[key] = {
         name: t2.name,
         version: t2.version,
         resolved: t2.url,
         integrity: integrityFromSha256Hex(t2.sha256)
       };
-      if (existsSync17(dest) && sha256Hex(readFileSync22(dest)) === t2.sha256) {
+      if (existsSync18(dest) && sha256Hex(readFileSync23(dest)) === t2.sha256) {
         result.kept.push(t2.filename);
         continue;
       }
-      const movedFrom = Object.entries(opts.oldLock?.plugins ?? {}).filter(([k, p]) => k !== key && p.name === t2.name).map(([k]) => join25(opts.root, k)).find((f) => existsSync17(f) && sha256Hex(readFileSync22(f)) === t2.sha256);
+      const movedFrom = Object.entries(opts.oldLock?.plugins ?? {}).filter(([k, p]) => k !== key && p.name === t2.name).map(([k]) => join26(opts.root, k)).find((f) => existsSync18(f) && sha256Hex(readFileSync23(f)) === t2.sha256);
       if (movedFrom) {
         result.moved.push(t2.filename);
         if (opts.dryRun) log3(`would ${t2.disabled ? "disable" : "enable"} ${t2.name}@${t2.version}`);
@@ -12155,10 +12273,10 @@ async function syncPlugins(opts) {
   }
   for (const [key, old] of Object.entries(opts.oldLock?.plugins ?? {})) {
     if (key in result.plugins) continue;
-    const file = join25(opts.root, key);
-    if (!existsSync17(file)) continue;
+    const file = join26(opts.root, key);
+    if (!existsSync18(file)) continue;
     const want = sha256HexFromIntegrity(old.integrity);
-    if (want && sha256Hex(readFileSync22(file)) === want) {
+    if (want && sha256Hex(readFileSync23(file)) === want) {
       if (opts.dryRun) log3(`would remove ${old.name}@${old.version} (${key})`);
       else {
         rmSync3(file);
@@ -12210,7 +12328,7 @@ async function serverInstall(opts) {
     }
     manifest = { ...manifest, with: { ...manifest.with, [parseSpec2(opts.specs[0]).name]: opts.with } };
   }
-  const lockPath = join26(opts.root, SERVER_LOCK);
+  const lockPath = join27(opts.root, SERVER_LOCK);
   const lock = readLock(lockPath);
   if (opts.disabled) {
     if (!opts.specs?.length) throw new Error("--disabled needs the plugins to install: s2s install <name> --disabled");
@@ -12261,7 +12379,7 @@ async function serverUpdate(opts) {
   const log3 = opts.log ?? (() => {
   });
   const manifest = readServerManifest(opts.root);
-  const lockPath = join26(opts.root, SERVER_LOCK);
+  const lockPath = join27(opts.root, SERVER_LOCK);
   const lock = readLock(lockPath);
   const names = opts.names && opts.names.length > 0 ? opts.names : Object.keys(manifest.dependencies);
   for (const n3 of names) {
@@ -12279,12 +12397,12 @@ async function serverUpdate(opts) {
 }
 function scanLocalPlugins(root, onUnreadable = () => {
 }) {
-  const dir = join26(root, PLUGINS_SUBDIR);
-  if (!existsSync18(dir)) return [];
+  const dir = join27(root, PLUGINS_SUBDIR);
+  if (!existsSync19(dir)) return [];
   const out = [];
   for (const entry of readdirSync7(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".s2sp")) continue;
-    const bytes = readFileSync23(join26(dir, entry.name));
+    const bytes = readFileSync24(join27(dir, entry.name));
     try {
       const files = unzipSync(new Uint8Array(bytes), { filter: (f) => f.name === "manifest.json" });
       const m = JSON.parse(Buffer.from(files["manifest.json"]).toString("utf8"));
@@ -12298,8 +12416,8 @@ function scanLocalPlugins(root, onUnreadable = () => {
 }
 async function serverInit(opts) {
   const root = resolve22(opts.root);
-  const pkgPath = join26(root, SERVER_MANIFEST);
-  if (existsSync18(pkgPath) && !opts.force) {
+  const pkgPath = join27(root, SERVER_MANIFEST);
+  if (existsSync19(pkgPath) && !opts.force) {
     throw new Error(`${pkgPath} already exists \u2014 pass --force to replace it`);
   }
   const report = { managed: [], unmanaged: [] };
@@ -12340,7 +12458,7 @@ async function serverInit(opts) {
   const raw = newServerManifestJson(opts.name ?? "s2script-server", dependencies);
   writeFileSync14(pkgPath, JSON.stringify(raw, null, 2) + "\n");
   const manifest = parseServerManifest(root, raw);
-  writeLock(join26(root, SERVER_LOCK), lockFor(manifest, plugins));
+  writeLock(join27(root, SERVER_LOCK), lockFor(manifest, plugins));
   return report;
 }
 async function serverSetEnabled(opts) {
@@ -12358,7 +12476,7 @@ async function serverSetEnabled(opts) {
     else set.add(n3);
   }
   manifest = { ...manifest, disabled: [...set].sort() };
-  const lockPath = join26(opts.root, SERVER_LOCK);
+  const lockPath = join27(opts.root, SERVER_LOCK);
   const lock = readLock(lockPath);
   const specs = pinnedSpecs(manifest, lock, sat);
   const { targets } = await resolveTargets(opts.client, specs, manifest.with, {
@@ -12430,11 +12548,11 @@ async function run5(argv2) {
   }
   await runServer(async () => {
     const withMembers = collectWith(argv2);
-    if (!existsSync19(join27(root, SERVER_MANIFEST))) {
+    if (!existsSync20(join28(root, SERVER_MANIFEST))) {
       if (dryRun) throw new Error(`no ${SERVER_MANIFEST} in ${root} yet \u2014 run without --dry-run to create one`);
       const fresh = newServerManifestJson("s2script-server", {});
-      writeFileSync15(join27(root, SERVER_MANIFEST), JSON.stringify(fresh, null, 2) + "\n");
-      console.log(`created ${join27(root, SERVER_MANIFEST)}`);
+      writeFileSync15(join28(root, SERVER_MANIFEST), JSON.stringify(fresh, null, 2) + "\n");
+      console.log(`created ${join28(root, SERVER_MANIFEST)}`);
     }
     return serverInstall({
       root,
@@ -12455,26 +12573,26 @@ import { resolve as resolve25 } from "node:path";
 import {
   mkdirSync as mkdirSync8,
   writeFileSync as writeFileSync16,
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync25,
   symlinkSync
 } from "node:fs";
-import { dirname as dirname8, isAbsolute, join as join28, relative as relative4, resolve as resolve23, basename as basename4 } from "node:path";
+import { dirname as dirname8, isAbsolute, join as join29, relative as relative4, resolve as resolve23, basename as basename4 } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function readCliVersion() {
   const here = dirname8(fileURLToPath2(import.meta.url));
   const candidates = [
-    join28(here, "..", "package.json"),
+    join29(here, "..", "package.json"),
     // dist/cli.js → packages/sdk/package.json
-    join28(here, "..", "..", "package.json")
+    join29(here, "..", "..", "package.json")
     // src/create → packages/sdk/package.json
   ];
   for (const p of candidates) {
-    if (!existsSync20(p)) continue;
+    if (!existsSync21(p)) continue;
     try {
-      const pkg = JSON.parse(readFileSync24(p, "utf8"));
+      const pkg = JSON.parse(readFileSync25(p, "utf8"));
       if (pkg.name === "@s2script/sdk" && pkg.version) return pkg.version;
     } catch {
     }
@@ -12484,9 +12602,9 @@ function readCliVersion() {
 function findLocalPackagesDir() {
   const here = dirname8(fileURLToPath2(import.meta.url));
   const candidates = [
-    join28(here, "..", ".."),
+    join29(here, "..", ".."),
     // dist/cli.js → packages
-    join28(here, "..", "..", "..")
+    join29(here, "..", "..", "..")
     // src/create → packages
   ];
   for (const c2 of candidates) {
@@ -12502,7 +12620,7 @@ function defaultNameFromPath(dir, kind = "plugin") {
   return `@${kind}/${slugifyBasename(dir)}`;
 }
 function assertEmptyTarget(targetPath) {
-  if (!existsSync20(targetPath)) return;
+  if (!existsSync21(targetPath)) return;
   const kids = readdirSync8(targetPath);
   const meaningful = kids.filter((k) => k !== ".git");
   if (meaningful.length) {
@@ -12551,8 +12669,8 @@ function registryDevDeps(game, sdkVersion, resolve29 = resolvePublishedVersion)
 function fileDevDeps(packagesDir, game) {
   const deps = {};
   for (const n3 of createPackageNames(game)) {
-    const abs = join28(packagesDir, n3);
-    if (!existsSync20(join28(abs, "package.json"))) return void 0;
+    const abs = join29(packagesDir, n3);
+    if (!existsSync21(join29(abs, "package.json"))) return void 0;
     deps[`@s2script/${n3}`] = `file:${abs}`;
   }
   return deps;
@@ -12617,7 +12735,7 @@ function tsconfigJson() {
   ) + "\n";
 }
 function workspaceTsconfigJson(targetPath, workspaceRoot) {
-  const rel = relative4(targetPath, join28(workspaceRoot, "tsconfig.base.json")).replace(/\\/g, "/");
+  const rel = relative4(targetPath, join29(workspaceRoot, "tsconfig.base.json")).replace(/\\/g, "/");
   return JSON.stringify(
     {
       extends: rel.startsWith(".") ? rel : `./${rel}`,
@@ -12693,10 +12811,10 @@ dist/
 `;
 }
 function linkLocalPackagesForNoInstall(targetPath, localPackagesDir) {
-  const nm = join28(targetPath, "node_modules");
+  const nm = join29(targetPath, "node_modules");
   mkdirSync8(nm, { recursive: true });
-  const dest = join28(nm, "@s2script");
-  if (!existsSync20(dest)) symlinkSync(localPackagesDir, dest);
+  const dest = join29(nm, "@s2script");
+  if (!existsSync21(dest)) symlinkSync(localPackagesDir, dest);
 }
 function runInstall(dir, pm) {
   if (pm === "none") return;
@@ -12725,7 +12843,7 @@ async function createPlugin(opts = {}) {
     );
   }
   let slug = workspaceRoot !== void 0 && opts.path !== void 0 ? assertBareSlug(opts.path) : opts.path;
-  let targetPath = workspaceRoot === void 0 ? resolve23(opts.path ?? ".") : slug === void 0 ? void 0 : join28(workspaceRoot, "plugins", slug);
+  let targetPath = workspaceRoot === void 0 ? resolve23(opts.path ?? ".") : slug === void 0 ? void 0 : join29(workspaceRoot, "plugins", slug);
   if (targetPath !== void 0) assertEmptyTarget(targetPath);
   if (interactive) {
     intro2("Create an s2script plugin");
@@ -12735,7 +12853,7 @@ async function createPlugin(opts = {}) {
         slug = assertBareSlug(
           await text2({ message: "Plugin name (directory under plugins/)", placeholder: "myplugin" })
         );
-        targetPath = join28(workspaceRoot, "plugins", slug);
+        targetPath = join29(workspaceRoot, "plugins", slug);
         assertEmptyTarget(targetPath);
       }
     }
@@ -12798,37 +12916,37 @@ async function createPlugin(opts = {}) {
   install = workspaceRoot !== void 0 ? "none" : install ?? (opts.noInstall ? "none" : "npm");
   const finalTargetPath = targetPath;
   const localPackagesDir = workspaceRoot === void 0 ? findLocalPackagesDir() : void 0;
-  mkdirSync8(join28(finalTargetPath, "src"), { recursive: true });
+  mkdirSync8(join29(finalTargetPath, "src"), { recursive: true });
   if (workspaceRoot !== void 0) {
-    writeFileSync16(join28(finalTargetPath, "package.json"), minimalPackageJsonContent(name));
+    writeFileSync16(join29(finalTargetPath, "package.json"), minimalPackageJsonContent(name));
     writeFileSync16(
-      join28(finalTargetPath, "tsconfig.json"),
+      join29(finalTargetPath, "tsconfig.json"),
       workspaceTsconfigJson(finalTargetPath, workspaceRoot)
     );
   } else if (kind === "library") {
     const version = readCliVersion();
     writeFileSync16(
-      join28(finalTargetPath, "package.json"),
+      join29(finalTargetPath, "package.json"),
       libraryPackageJsonContent(name, game, version, localPackagesDir)
     );
-    writeFileSync16(join28(finalTargetPath, "tsconfig.json"), tsconfigJson());
-    writeFileSync16(join28(finalTargetPath, "eslint.config.mjs"), eslintConfig());
+    writeFileSync16(join29(finalTargetPath, "tsconfig.json"), tsconfigJson());
+    writeFileSync16(join29(finalTargetPath, "eslint.config.mjs"), eslintConfig());
   } else {
     const version = readCliVersion();
     writeFileSync16(
-      join28(finalTargetPath, "package.json"),
+      join29(finalTargetPath, "package.json"),
       packageJsonContent(name, game, version, localPackagesDir)
     );
-    writeFileSync16(join28(finalTargetPath, "tsconfig.json"), tsconfigJson());
-    writeFileSync16(join28(finalTargetPath, "eslint.config.mjs"), eslintConfig());
+    writeFileSync16(join29(finalTargetPath, "tsconfig.json"), tsconfigJson());
+    writeFileSync16(join29(finalTargetPath, "eslint.config.mjs"), eslintConfig());
   }
   if (kind === "library") {
-    writeFileSync16(join28(finalTargetPath, "src", "index.ts"), LIBRARY_ENTRY);
-    writeFileSync16(join28(finalTargetPath, "src", "index.d.ts"), LIBRARY_TYPES);
+    writeFileSync16(join29(finalTargetPath, "src", "index.ts"), LIBRARY_ENTRY);
+    writeFileSync16(join29(finalTargetPath, "src", "index.d.ts"), LIBRARY_TYPES);
   } else {
-    writeFileSync16(join28(finalTargetPath, "src", "plugin.ts"), pluginSource(game));
+    writeFileSync16(join29(finalTargetPath, "src", "plugin.ts"), pluginSource(game));
   }
-  writeFileSync16(join28(finalTargetPath, ".gitignore"), gitignore());
+  writeFileSync16(join29(finalTargetPath, ".gitignore"), gitignore());
   let installed = false;
   if (workspaceRoot === void 0) {
     if (install !== "none") {
@@ -12856,7 +12974,7 @@ async function createPlugin(opts = {}) {
 
 // src/create/workspace.ts
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join29, resolve as resolve24 } from "node:path";
+import { join as join30, resolve as resolve24 } from "node:path";
 var ROOT_DEFAULT_GAME = "cs2";
 var CHANGESETS_CLI_RANGE = "^2.29.5";
 function defaultWorkspaceName(dir) {
@@ -12940,14 +13058,14 @@ async function createWorkspace(opts = {}) {
   name = name ?? defaultWorkspaceName(targetPath);
   const version = readCliVersion();
   const localPackagesDir = findLocalPackagesDir();
-  mkdirSync9(join29(targetPath, "plugins"), { recursive: true });
-  mkdirSync9(join29(targetPath, "packages"), { recursive: true });
-  mkdirSync9(join29(targetPath, ".changeset"), { recursive: true });
-  writeFileSync17(join29(targetPath, "package.json"), rootPackageJsonContent(name, version, localPackagesDir));
-  writeFileSync17(join29(targetPath, "tsconfig.base.json"), tsconfigBaseJson());
-  writeFileSync17(join29(targetPath, "eslint.config.mjs"), eslintConfig());
-  writeFileSync17(join29(targetPath, ".changeset", "config.json"), changesetConfigJson());
-  writeFileSync17(join29(targetPath, ".gitignore"), gitignore());
+  mkdirSync9(join30(targetPath, "plugins"), { recursive: true });
+  mkdirSync9(join30(targetPath, "packages"), { recursive: true });
+  mkdirSync9(join30(targetPath, ".changeset"), { recursive: true });
+  writeFileSync17(join30(targetPath, "package.json"), rootPackageJsonContent(name, version, localPackagesDir));
+  writeFileSync17(join30(targetPath, "tsconfig.base.json"), tsconfigBaseJson());
+  writeFileSync17(join30(targetPath, "eslint.config.mjs"), eslintConfig());
+  writeFileSync17(join30(targetPath, ".changeset", "config.json"), changesetConfigJson());
+  writeFileSync17(join30(targetPath, ".gitignore"), gitignore());
   return { dir: targetPath, name };
 }
 
@@ -13183,8 +13301,8 @@ async function run7(argv2) {
 }
 
 // src/config/gen.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync18, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join30 } from "node:path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync18, mkdirSync as mkdirSync10 } from "node:fs";
+import { join as join31 } from "node:path";
 
 // src/config/config-path.ts
 function configFileName(id) {
@@ -13231,12 +13349,12 @@ function genConfigFromManifest(manifest, outDir) {
   const id = typeof manifest.id === "string" ? manifest.id : "";
   if (!id) throw new Error("config gen: manifest declares config but has no id");
   mkdirSync10(outDir, { recursive: true });
-  const path2 = join30(outDir, configFileName(id));
+  const path2 = join31(outDir, configFileName(id));
   writeFileSync18(path2, generateDefaultJsonc(config));
   return path2;
 }
 function genConfigForS2sp(s2spPath, outDir) {
-  const entry = unzipSync(readFileSync25(s2spPath))["manifest.json"];
+  const entry = unzipSync(readFileSync26(s2spPath))["manifest.json"];
   if (!entry) throw new Error(`config gen: ${s2spPath} has no manifest.json`);
   const manifest = JSON.parse(Buffer.from(entry).toString("utf8"));
   return genConfigFromManifest(manifest, outDir);
@@ -13283,12 +13401,12 @@ async function run8(argv2) {
 }
 
 // src/commands/codegen.ts
-import { dirname as dirname9, join as join35 } from "node:path";
+import { dirname as dirname9, join as join36 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/schemagen/gen.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join31 } from "node:path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join32 } from "node:path";
 
 // src/schemagen/model.ts
 function enumMemberNames(enumName, members) {
@@ -13837,16 +13955,16 @@ var EMBED_PATH = "games/cs2/codegen-embedded.json";
 var JS_OUT = "games/cs2/js/schema.generated.js";
 var DTS_OUT = "packages/cs2/schema.generated.d.ts";
 function runGenSchema(repoRoot2, opts) {
-  const catalog = JSON.parse(readFileSync26(join31(repoRoot2, CATALOG_PATH), "utf8"));
-  const list = JSON.parse(readFileSync26(join31(repoRoot2, LIST_PATH), "utf8"));
+  const catalog = JSON.parse(readFileSync27(join32(repoRoot2, CATALOG_PATH), "utf8"));
+  const list = JSON.parse(readFileSync27(join32(repoRoot2, LIST_PATH), "utf8"));
   let embed = [];
   try {
-    embed = JSON.parse(readFileSync26(join31(repoRoot2, EMBED_PATH), "utf8"));
+    embed = JSON.parse(readFileSync27(join32(repoRoot2, EMBED_PATH), "utf8"));
   } catch {
   }
   let enumCatalog = {};
   try {
-    enumCatalog = JSON.parse(readFileSync26(join31(repoRoot2, ENUMS_PATH), "utf8"));
+    enumCatalog = JSON.parse(readFileSync27(join32(repoRoot2, ENUMS_PATH), "utf8"));
   } catch {
   }
   const model = buildModel(catalog, list, embed, enumCatalog);
@@ -13857,11 +13975,11 @@ function runGenSchema(repoRoot2, opts) {
   const drift = [];
   const files = [[JS_OUT, js], [DTS_OUT, dts]];
   for (const [rel, content] of files) {
-    const abs = join31(repoRoot2, rel);
+    const abs = join32(repoRoot2, rel);
     if (opts.check) {
       let cur = "";
       try {
-        cur = readFileSync26(abs, "utf8");
+        cur = readFileSync27(abs, "utf8");
       } catch {
       }
       if (cur !== content) drift.push(rel);
@@ -13876,8 +13994,8 @@ function runGenSchema(repoRoot2, opts) {
 }
 
 // src/eventgen/gen.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join33 } from "node:path";
 
 // src/eventgen/model.ts
 var TYPE_TO_GETTER = {
@@ -13962,15 +14080,15 @@ function emitEventDts(model) {
 var CATALOG_PATH2 = "games/cs2/gamedata/event-catalog.json";
 var DTS_OUT2 = "packages/cs2/events.generated.d.ts";
 function runGenEvents(repoRoot2, opts) {
-  const catalog = JSON.parse(readFileSync27(join32(repoRoot2, CATALOG_PATH2), "utf8"));
+  const catalog = JSON.parse(readFileSync28(join33(repoRoot2, CATALOG_PATH2), "utf8"));
   const model = buildEventModel(catalog);
   const dts = emitEventDts(model);
   const drift = [];
-  const abs = join32(repoRoot2, DTS_OUT2);
+  const abs = join33(repoRoot2, DTS_OUT2);
   if (opts.check) {
     let cur = "";
     try {
-      cur = readFileSync27(abs, "utf8");
+      cur = readFileSync28(abs, "utf8");
     } catch {
     }
     if (cur !== dts) drift.push(DTS_OUT2);
@@ -13981,8 +14099,8 @@ function runGenEvents(repoRoot2, opts) {
 }
 
 // src/navgen/gen.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join33 } from "node:path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync21 } from "node:fs";
+import { join as join34 } from "node:path";
 
 // src/navgen/model.ts
 var SUPPORTED_NAV_KINDS = /* @__PURE__ */ new Set([
@@ -14196,8 +14314,8 @@ var CATALOG_PATH3 = "games/cs2/gamedata/schema-catalog.json";
 var JS_OUT2 = "games/cs2/js/nav.generated.js";
 var DTS_OUT3 = "packages/cs2/nav.generated.d.ts";
 function runGenNav(repoRoot2, opts) {
-  const config = JSON.parse(readFileSync28(join33(repoRoot2, TARGETS_PATH), "utf8"));
-  const catalog = JSON.parse(readFileSync28(join33(repoRoot2, CATALOG_PATH3), "utf8"));
+  const config = JSON.parse(readFileSync29(join34(repoRoot2, TARGETS_PATH), "utf8"));
+  const catalog = JSON.parse(readFileSync29(join34(repoRoot2, CATALOG_PATH3), "utf8"));
   const model = buildNavModel(config, catalog);
   const js = emitNavJs(model);
   const dts = emitNavDts(model);
@@ -14205,11 +14323,11 @@ function runGenNav(repoRoot2, opts) {
   const drift = [];
   const files = [[JS_OUT2, js], [DTS_OUT3, dts]];
   for (const [rel, content] of files) {
-    const abs = join33(repoRoot2, rel);
+    const abs = join34(repoRoot2, rel);
     if (opts.check) {
       let cur = "";
       try {
-        cur = readFileSync28(abs, "utf8");
+        cur = readFileSync29(abs, "utf8");
       } catch {
       }
       if (cur !== content) drift.push(rel);
@@ -14221,22 +14339,22 @@ function runGenNav(repoRoot2, opts) {
 }
 
 // src/hookgen/gen.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join34 } from "node:path";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync22 } from "node:fs";
+import { join as join35 } from "node:path";
 var GAMEDATA_PATH = "games/cs2/gamedata/game.cs2.jsonc";
 var DTS_OUT4 = "packages/cs2/hooks.generated.d.ts";
 function runGenHooks(repoRoot2, opts) {
-  const raw = readFileSync29(join34(repoRoot2, GAMEDATA_PATH), "utf8");
+  const raw = readFileSync30(join35(repoRoot2, GAMEDATA_PATH), "utf8");
   const gd = JSON.parse(stripJsonComments(raw));
   const hooks = gd.hooks ?? {};
   const model = buildHookModel(hooks);
   const dts = emitHookDts(model);
   const drift = [];
-  const abs = join34(repoRoot2, DTS_OUT4);
+  const abs = join35(repoRoot2, DTS_OUT4);
   if (opts.check) {
     let cur = "";
     try {
-      cur = readFileSync29(abs, "utf8");
+      cur = readFileSync30(abs, "utf8");
     } catch {
     }
     if (cur !== dts) drift.push(DTS_OUT4);
@@ -14249,7 +14367,7 @@ function runGenHooks(repoRoot2, opts) {
 
 // src/commands/codegen.ts
 function repoRoot() {
-  return join35(dirname9(fileURLToPath3(import.meta.url)), "..", "..", "..");
+  return join36(dirname9(fileURLToPath3(import.meta.url)), "..", "..", "..");
 }
 async function run9(kind, argv2) {
   const root = repoRoot();
@@ -14306,9 +14424,9 @@ async function run9(kind, argv2) {
 }
 
 // src/commands/inspect.ts
-import { readFileSync as readFileSync30 } from "node:fs";
+import { readFileSync as readFileSync31 } from "node:fs";
 function inspectArchive(path2) {
-  const files = unzipSync(readFileSync30(path2));
+  const files = unzipSync(readFileSync31(path2));
   if (!files["manifest.json"]) throw new Error(`${path2}: missing manifest.json`);
   const manifest = JSON.parse(Buffer.from(files["manifest.json"]).toString("utf8"));
   const lines = [`plugin: ${manifest.id ?? "(unknown)"}`];
@@ -14337,8 +14455,8 @@ async function run10(argv2) {
 }
 
 // src/engine-functions/migrate-v1.ts
-import { closeSync, existsSync as existsSync21, linkSync, lstatSync as lstatSync2, mkdirSync as mkdirSync11, openSync, readFileSync as readFileSync31, readdirSync as readdirSync9, renameSync as renameSync4, unlinkSync, writeFileSync as writeFileSync23 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join36, relative as relative5, resolve as resolve26, sep as sep6 } from "node:path";
+import { closeSync, existsSync as existsSync22, linkSync, lstatSync as lstatSync2, mkdirSync as mkdirSync11, openSync, readFileSync as readFileSync32, readdirSync as readdirSync9, renameSync as renameSync4, unlinkSync, writeFileSync as writeFileSync23 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join37, relative as relative5, resolve as resolve26, sep as sep6 } from "node:path";
 import { createHash as createHash6, randomUUID } from "node:crypto";
 import ts6 from "typescript";
 var PLATFORM3 = "linuxsteamrt64";
@@ -14465,11 +14583,11 @@ function hookOf(name, value, signatures, errors) {
 }
 function sourceFiles(dir, pkg, errors) {
   const result = /* @__PURE__ */ new Set();
-  const src = join36(dir, "src");
+  const src = join37(dir, "src");
   function walk(at) {
-    if (!existsSync21(at)) return;
+    if (!existsSync22(at)) return;
     for (const item of readdirSync9(at, { withFileTypes: true })) {
-      const p = join36(at, item.name);
+      const p = join37(at, item.name);
       if (item.isDirectory()) walk(p);
       else if (item.isFile() && /\.[cm]?[jt]sx?$/.test(item.name)) result.add(p);
     }
@@ -14477,12 +14595,12 @@ function sourceFiles(dir, pkg, errors) {
   walk(src);
   if (valid2(pkg.main)) {
     const p = resolve26(dir, pkg.main);
-    if (contained(dir, p) && existsSync21(p) && lstatSync2(p).isFile()) result.add(p);
+    if (contained(dir, p) && existsSync22(p) && lstatSync2(p).isFile()) result.add(p);
   }
   const queue = [...result];
   for (let i2 = 0; i2 < queue.length; i2++) {
     const file = queue[i2];
-    const ast = ts6.createSourceFile(file, readFileSync31(file, "utf8"), ts6.ScriptTarget.Latest, true);
+    const ast = ts6.createSourceFile(file, readFileSync32(file, "utf8"), ts6.ScriptTarget.Latest, true);
     const follow = (spec, node) => {
       if (!spec.startsWith(".")) return;
       const at = `${relative5(dir, file)}:${ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1}`;
@@ -14492,8 +14610,8 @@ function sourceFiles(dir, pkg, errors) {
         return;
       }
       const stem = base.replace(/\.[cm]?[jt]sx?$/, "");
-      const candidates = [base, ...[".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"].map((x) => stem + x), ...["index.ts", "index.tsx", "index.js", "index.jsx"].map((x) => join36(base, x))];
-      const found = candidates.find((p) => contained(dir, p) && existsSync21(p) && lstatSync2(p).isFile());
+      const candidates = [base, ...[".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"].map((x) => stem + x), ...["index.ts", "index.tsx", "index.js", "index.jsx"].map((x) => join37(base, x))];
+      const found = candidates.find((p) => contained(dir, p) && existsSync22(p) && lstatSync2(p).isFile());
       if (!found) {
         errors.push(`${at}: unresolved local module ${JSON.stringify(spec)}`);
         return;
@@ -14523,7 +14641,7 @@ function sourceFiles(dir, pkg, errors) {
 function scanSource(files, calls, hooks, report) {
   const namespaces = new Set(hooks.values());
   for (const file of files) {
-    const source = ts6.createSourceFile(file, readFileSync31(file, "utf8"), ts6.ScriptTarget.Latest, true);
+    const source = ts6.createSourceFile(file, readFileSync32(file, "utf8"), ts6.ScriptTarget.Latest, true);
     if (source.parseDiagnostics?.length) report.ambiguities.push(`${relative5(report.package, file)}: source syntax errors prevent reliable reference analysis`);
     const ambiguity = (node, message) => {
       report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: ${message}`);
@@ -14663,12 +14781,12 @@ function scanSource(files, calls, hooks, report) {
 }
 function analyzeV1Migration(pluginDir, options = {}) {
   const dir = resolve26(pluginDir);
-  const destination = join36(dir, "gamedata", "functions.jsonc");
+  const destination = join37(dir, "gamedata", "functions.jsonc");
   const report = { scope: SCOPE, package: dir, destination, entries: [], permissions: [], sourceReferences: [], generatedDeclarations: [], generatedDeclarationHashes: {}, recommendedEdits: [], ambiguities: [], filesChanged: [] };
   if (pathExists(destination) && !options.force) report.ambiguities.push(`${destination}: destination already exists; use --force to replace it`);
   let pkg;
   try {
-    pkg = parseFunctionFile(join36(dir, "package.json"), readFileSync31(join36(dir, "package.json"), "utf8"));
+    pkg = parseFunctionFile(join37(dir, "package.json"), readFileSync32(join37(dir, "package.json"), "utf8"));
   } catch (e) {
     report.ambiguities.push(`package.json: ${e.message}`);
     return report;
@@ -14690,7 +14808,7 @@ function analyzeV1Migration(pluginDir, options = {}) {
   }
   let gd;
   try {
-    gd = parseFunctionFile(input, readFileSync31(input, "utf8"));
+    gd = parseFunctionFile(input, readFileSync32(input, "utf8"));
   } catch (e) {
     report.ambiguities.push(`gamedata: ${e.message}`);
     return report;
@@ -14790,10 +14908,10 @@ function analyzeV1Migration(pluginDir, options = {}) {
     }
   }
   report.output = author;
-  report.generatedDeclarations = ["gamedata.d.ts", "hooks.d.ts"].map((n3) => join36(dir, ".s2script", n3)).filter(existsSync21);
+  report.generatedDeclarations = ["gamedata.d.ts", "hooks.d.ts"].map((n3) => join37(dir, ".s2script", n3)).filter(existsSync22);
   for (const file of report.generatedDeclarations) {
     try {
-      report.generatedDeclarationHashes[file] = createHash6("sha256").update(readFileSync31(file)).digest("hex");
+      report.generatedDeclarationHashes[file] = createHash6("sha256").update(readFileSync32(file)).digest("hex");
     } catch (e) {
       report.ambiguities.push(`${file}: generated declaration could not be read: ${e.message}`);
     }
@@ -14812,7 +14930,7 @@ function migrateV1Package(pluginDir, options = {}) {
   const report = analyzeV1Migration(pluginDir, options);
   if (report.ambiguities.length || !report.output) return report;
   const dest = report.destination;
-  const temp = join36(dirname10(dest), `.functions.jsonc.${process.pid}.${randomUUID()}.tmp`);
+  const temp = join37(dirname10(dest), `.functions.jsonc.${process.pid}.${randomUUID()}.tmp`);
   try {
     mkdirSync11(dirname10(dest), { recursive: true });
     const fd2 = openSync(temp, "wx", 384);
@@ -14834,7 +14952,7 @@ function migrateV1Package(pluginDir, options = {}) {
     report.publication = void 0;
     report.ambiguities.push(`${dest}: publication failed: ${e.message}`);
   } finally {
-    if (existsSync21(temp)) unlinkSync(temp);
+    if (existsSync22(temp)) unlinkSync(temp);
   }
   return report;
 }
@@ -14854,8 +14972,8 @@ async function run11(argv2) {
 
 // src/commands/pack.ts
 import { createHash as createHash7 } from "node:crypto";
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync24 } from "node:fs";
-import { join as join37, resolve as resolve27 } from "node:path";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync24 } from "node:fs";
+import { join as join38, resolve as resolve27 } from "node:path";
 function formatBytes(n3) {
   if (n3 < 1e3) return `${n3}B`;
   if (n3 < 1e3 * 1e3) return `${(n3 / 1e3).toFixed(1)}kB`;
@@ -14863,9 +14981,9 @@ function formatBytes(n3) {
 }
 function packPackage(dir) {
   const absDir = resolve27(dir);
-  const pkg = JSON.parse(readFileSync32(join37(absDir, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync33(join38(absDir, "package.json"), "utf8"));
   if (typeof pkg.name !== "string" || typeof pkg.version !== "string") {
-    throw new Error(`${join37(absDir, "package.json")}: "name" and "version" are required to pack`);
+    throw new Error(`${join38(absDir, "package.json")}: "name" and "version" are required to pack`);
   }
   const pack = packSourceTarball(absDir, pkg);
   return {
@@ -14923,8 +15041,8 @@ async function run12(argv2) {
 }
 
 // src/commands/server.ts
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join38, resolve as resolve28 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join39, resolve as resolve28 } from "node:path";
 async function run13(argv2) {
   const [sub, dir] = positionals(argv2, ["--registry", "--name"]);
   if (sub !== "init") {
@@ -14933,7 +15051,7 @@ async function run13(argv2) {
   }
   const root = dir ? resolve28(dir) : findAddonRoot(".") ?? resolve28("addons", "s2script");
   try {
-    if (!existsSync22(join38(root, "plugins"))) {
+    if (!existsSync23(join39(root, "plugins"))) {
       throw new Error(`${root} has no plugins/ directory \u2014 pass your addons/s2script directory`);
     }
     const report = await serverInit({
@@ -14945,7 +15063,7 @@ async function run13(argv2) {
     for (const m of report.managed) console.log(`managed   ${m.name}@${m.version} (${m.filename})`);
     for (const u4 of report.unmanaged) console.log(`unmanaged ${u4.filename}: ${u4.reason}`);
     console.log(
-      `wrote ${join38(root, "plugins.json")} and plugins-lock.json \u2014 ${report.managed.length} managed, ${report.unmanaged.length} left as they are`
+      `wrote ${join39(root, "plugins.json")} and plugins-lock.json \u2014 ${report.managed.length} managed, ${report.unmanaged.length} left as they are`
     );
   } catch (e) {
     console.error(String(e instanceof Error ? e.message : e));