@s2script/sdk 0.30.3 → 0.32.0

package/dist/cli.js

@@ -3455,11 +3455,11 @@ function unzipSync(data, opts) {
 }
 
 // src/build.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, rmSync as rmSync2 } from "node:fs";
-import { resolve as resolve12, join as join12 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, rmSync as rmSync2 } from "node:fs";
+import { resolve as resolve12, join as join13 } from "node:path";
 
 // src/typecheck/typecheck.ts
-import ts4 from "typescript";
+import ts5 from "typescript";
 
 // src/gamedata/load.ts
 import { readFileSync } from "node:fs";
@@ -3516,9 +3516,9 @@ function stripJsonComments(src) {
 
 // src/gamedata/types.ts
 var PLATFORM = "linuxsteamrt64";
-var ARG_KINDS = ["bool", "int", "float", "string", "utlstring", "vector", "entity"];
-var RET_KINDS = ["void", "bool", "int", "float", "entity"];
-var INT_CLASS_ARGS = /* @__PURE__ */ new Set(["bool", "int", "string", "utlstring", "vector", "entity"]);
+var ARG_KINDS = ["bool", "int", "float", "string", "utlstring", "vector", "entity", "ptr"];
+var RET_KINDS = ["void", "bool", "int", "float", "entity", "ptr"];
+var INT_CLASS_ARGS = /* @__PURE__ */ new Set(["bool", "int", "string", "utlstring", "vector", "entity", "ptr"]);
 var MAX_INT_ARGS = 9;
 var MAX_FLOAT_ARGS = 8;
 var HOOK_SHAPES = ["this_void", "this_f32_i32_i32_i32", "this_f32_i32_i64_i64"];
@@ -3950,14 +3950,16 @@ var ARG_TS = {
   string: "string",
   utlstring: "string",
   vector: VECTOR_TS,
-  entity: "EntityRef | null"
+  entity: "EntityRef | null",
+  ptr: "Ptr | null"
 };
 var RET_TS = {
   void: "void",
   bool: "boolean | null",
   int: "number | null",
   float: "number | null",
-  entity: "EntityRef | null"
+  entity: "EntityRef | null",
+  ptr: "Ptr | null"
 };
 function generateGamedataTypes(gd) {
   const calls = gd.calls ?? {};
@@ -3979,6 +3981,7 @@ ${lines.join("\n")}
     "// The EntityRef import is REQUIRED: a `declare module` augmentation resolves type names in its",
     "// own file scope, so an un-imported EntityRef degrades to an error skipLibCheck can swallow.",
     'import type { EntityRef } from "@s2script/sdk/entity";',
+    'import type { Ptr } from "@s2script/sdk/unsafe";',
     "",
     'declare module "@s2script/sdk/unsafe" {',
     `  interface EngineCalls {${body}}`,
@@ -3991,8 +3994,8 @@ function generateHookTypes(gd) {
 }
 
 // src/engine-functions/archive.ts
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
 
 // src/engine-functions/parse.ts
 import ts from "typescript";
@@ -4029,6 +4032,139 @@ function parseFunctionFile(path2, text3) {
   return parsed;
 }
 
+// src/engine-functions/inline.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import ts2 from "typescript";
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".s2script", ".git"]);
+var SOURCE = /\.(?:ts|tsx|mts|cts)$/;
+var FACTORIES = /* @__PURE__ */ new Set(["fromSignature", "fromVirtual"]);
+function sources(dir, out = []) {
+  for (const name of readdirSync(dir).sort()) {
+    if (SKIP.has(name)) continue;
+    const path2 = join(dir, name);
+    const stat = statSync(path2);
+    if (stat.isDirectory()) sources(path2, out);
+    else if (SOURCE.test(name) && !name.endsWith(".d.ts")) out.push(path2);
+  }
+  return out;
+}
+function unwrap(node) {
+  while (ts2.isParenthesizedExpression(node) || ts2.isAsExpression(node) || ts2.isSatisfiesExpression(node) || ts2.isTypeAssertionExpression(node)) node = node.expression;
+  return node;
+}
+function literal(node, at) {
+  node = unwrap(node);
+  if (ts2.isStringLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts2.isNumericLiteral(node)) return Number(node.text);
+  if (ts2.isPrefixUnaryExpression(node) && node.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(node.operand))
+    return -Number(node.operand.text);
+  if (node.kind === ts2.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts2.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts2.SyntaxKind.NullKeyword) return null;
+  if (ts2.isArrayLiteralExpression(node)) {
+    return node.elements.map((e) => {
+      if (ts2.isSpreadElement(e) || ts2.isOmittedExpression(e)) throw new Error(`${at(e)}: inline engine function declarations must be literals (no spreads or holes)`);
+      return literal(e, at);
+    });
+  }
+  if (ts2.isObjectLiteralExpression(node)) {
+    const out = {};
+    for (const prop of node.properties) {
+      if (!ts2.isPropertyAssignment(prop)) throw new Error(`${at(prop)}: inline engine function declarations must be literals (no spreads, shorthand or methods)`);
+      const name = prop.name;
+      const key = ts2.isIdentifier(name) || ts2.isStringLiteral(name) || ts2.isNumericLiteral(name) ? name.text : void 0;
+      if (key === void 0) throw new Error(`${at(prop)}: inline engine function declarations must use plain property names`);
+      if (Object.hasOwn(out, key)) throw new Error(`${at(prop)}: duplicate key ${JSON.stringify(key)}`);
+      out[key] = literal(prop.initializer, at);
+    }
+    return out;
+  }
+  throw new Error(`${at(node)}: inline engine function declarations must be literals, because the build copies them into the manifest; move a computed declaration to gamedata/functions.jsonc`);
+}
+function bindings(file) {
+  const engine = /* @__PURE__ */ new Set(), namespaces = /* @__PURE__ */ new Set();
+  for (const statement of file.statements) {
+    if (!ts2.isImportDeclaration(statement) || !ts2.isStringLiteral(statement.moduleSpecifier)) continue;
+    if (statement.moduleSpecifier.text !== "@s2script/sdk/unsafe") continue;
+    const bound = statement.importClause?.namedBindings;
+    if (!bound) continue;
+    if (ts2.isNamespaceImport(bound)) namespaces.add(bound.name.text);
+    else for (const element of bound.elements) {
+      if ((element.propertyName ?? element.name).text === "Engine") engine.add(element.name.text);
+    }
+  }
+  return { engine, namespaces };
+}
+function extractInlineFunctions(pluginDir) {
+  const result = { functions: {}, sites: {} };
+  if (!existsSync(pluginDir)) return result;
+  for (const path2 of sources(pluginDir)) {
+    const text3 = readFileSync2(path2, "utf8");
+    if (!text3.includes("fromSignature") && !text3.includes("fromVirtual")) continue;
+    const file = ts2.createSourceFile(path2, text3, ts2.ScriptTarget.Latest, true);
+    const { engine, namespaces } = bindings(file);
+    if (engine.size === 0 && namespaces.size === 0) continue;
+    const at = (node) => {
+      const { line } = file.getLineAndCharacterOfPosition(node.getStart(file));
+      return `${relative(pluginDir, path2)}:${line + 1}`;
+    };
+    const isEngine = (node) => ts2.isIdentifier(node) && engine.has(node.text) || ts2.isPropertyAccessExpression(node) && node.name.text === "Engine" && ts2.isIdentifier(node.expression) && namespaces.has(node.expression.text);
+    const visit = (node) => {
+      if (ts2.isPropertyAccessExpression(node) && FACTORIES.has(node.name.text) && isEngine(node.expression)) {
+        const factory = node.name.text;
+        const call = node.parent;
+        if (!ts2.isCallExpression(call) || call.expression !== node)
+          throw new Error(`${at(node)}: Engine.${factory} must be called directly, so the build can read its declaration`);
+        const [nameArg, declArg] = call.arguments;
+        if (call.arguments.length !== 2 || !nameArg || !declArg)
+          throw new Error(`${at(call)}: Engine.${factory}(name, declaration) takes exactly two arguments`);
+        const name = literal(nameArg, at);
+        if (typeof name !== "string") throw new Error(`${at(nameArg)}: Engine.${factory} needs a string-literal name`);
+        const decl = literal(declArg, at);
+        if (decl === null || typeof decl !== "object" || Array.isArray(decl))
+          throw new Error(`${at(declArg)}: Engine.${factory} needs an object-literal declaration`);
+        const target2 = decl.target;
+        if (target2 === null || typeof target2 !== "object" || Array.isArray(target2))
+          throw new Error(`${at(declArg)}: Engine.${factory}: declaration.target must be an object`);
+        const kind = target2.kind;
+        if ("ref" in target2) {
+        } else if (factory === "fromVirtual") {
+          if (kind !== void 0 && kind !== "virtual") throw new Error(`${at(declArg)}: Engine.fromVirtual needs a virtual target`);
+          target2.kind = "virtual";
+        } else if (kind !== void 0 && kind !== "signature") {
+          throw new Error(`${at(declArg)}: Engine.fromSignature needs a signature target; use Engine.fromVirtual for a vtable slot`);
+        }
+        if (Object.hasOwn(result.functions, name))
+          throw new Error(`${at(call)}: engine function ${JSON.stringify(name)} is already declared inline at ${result.sites[name]}`);
+        result.functions[name] = decl;
+        result.sites[name] = at(call);
+      }
+      ts2.forEachChild(node, visit);
+    };
+    visit(file);
+  }
+  return result;
+}
+function mergeInlineFunctions(file, inline) {
+  const names = Object.keys(inline.functions);
+  if (names.length === 0) return file;
+  const merged = file ? { ...file, functions: { ...file.functions ?? {} } } : { schemaVersion: 2, functions: {} };
+  for (const name of names) {
+    if (Object.hasOwn(merged.functions, name))
+      throw new Error(`${inline.sites[name]}: engine function ${JSON.stringify(name)} is declared both inline and in gamedata/functions.jsonc`);
+    merged.functions[name] = inline.functions[name];
+  }
+  return merged;
+}
+function locateInlineError(error, inline) {
+  const err2 = error instanceof Error ? error : new Error(String(error));
+  for (const [name, site] of Object.entries(inline.sites)) {
+    if (err2.message.startsWith(`function ${JSON.stringify(name)}`)) return new Error(`${site}: ${err2.message} (declared inline)`);
+  }
+  return err2;
+}
+
 // src/engine-functions/abi.generated.ts
 var PLATFORM2 = "linux-x86_64-sysv";
 var RECEIVERS = ["none", "entity"];
@@ -4062,7 +4198,7 @@ var IDENTIFIER2 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var FORBIDDEN_NAMES = /* @__PURE__ */ new Set(["self", "returnValue", "constructor", "prototype", "__proto__"]);
 var SURFACES = ["call", "pre", "post"];
 var RESOLVERS = ["direct", "ctor-body-xref", "lea-disp", "validated-call"];
-var TYPES = ["bool", "i32", "u32", "i64", "u64", "f32", "f64", "entity", "entity?", "string", "vector"];
+var TYPES = ["bool", "i32", "u32", "i64", "u64", "f32", "f64", "entity", "entity?", "string", "vector", "ptr"];
 var PARAMETER_OWNERSHIP = ["callee-borrowed", "callee-retained", "native-observed"];
 var RETURN_OWNERSHIP = ["caller-borrowed", "native-observed"];
 var copied = (type) => type === "string" || type === "vector";
@@ -4137,7 +4273,7 @@ function projection(type, where2) {
   if (type === "void") return { native: "void", projection: { id: "void", version: 1 } };
   if (!TYPES.includes(type)) throw new Error(`${where2}: unsupported author type ${JSON.stringify(type)}`);
   if (type === "bool") return { native: "u8", projection: { id: "bool", version: 1 } };
-  if (type === "entity" || type === "entity?" || type === "string" || type === "vector") {
+  if (type === "entity" || type === "entity?" || type === "string" || type === "vector" || type === "ptr") {
     return { native: "ptr", projection: { id: type, version: 1 } };
   }
   return { native: type, projection: { id: type, version: 1 } };
@@ -4273,9 +4409,15 @@ function summarizeFunctions(bundle) {
 
 // src/engine-functions/archive.ts
 function loadEngineFunctions(pluginDir, ownerId) {
-  const path2 = join(pluginDir, "gamedata", "functions.jsonc");
-  if (!existsSync(path2)) return void 0;
-  return normalizeFunctions(ownerId, parseFunctionFile(path2, readFileSync2(path2, "utf8")));
+  const path2 = join2(pluginDir, "gamedata", "functions.jsonc");
+  const file = existsSync2(path2) ? parseFunctionFile(path2, readFileSync3(path2, "utf8")) : void 0;
+  const inline = extractInlineFunctions(pluginDir);
+  const merged = mergeInlineFunctions(file, inline);
+  try {
+    return normalizeFunctions(ownerId, merged);
+  } catch (error) {
+    throw locateInlineError(error, inline);
+  }
 }
 function engineFunctionsArchive(bundle) {
   return canonicalJson(bundle) + "\n";
@@ -4308,6 +4450,9 @@ function typeOf(projection2) {
       return "string";
     case "vector":
       return "{ readonly x: number; readonly y: number; readonly z: number }";
+    // A raw address: a `Ptr` from this module (in scope inside the augmentation), null for 0.
+    case "ptr":
+      return "Ptr | null";
     default:
       throw new Error(`no public TypeScript projection for ${projection2.id}`);
   }
@@ -4382,27 +4527,27 @@ function emitEngineFunctionTypes(bundle) {
 }
 
 // src/interop.ts
-import ts3 from "typescript";
+import ts4 from "typescript";
 import { createHash as createHash2 } from "node:crypto";
 
 // src/publish-scan.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 function pluginApiName(checker, call) {
   const declaration = checker.getResolvedSignature(call)?.getDeclaration();
   if (!declaration || !declaration.getSourceFile().fileName.replace(/\\/g, "/").endsWith("/sdk/plugin.d.ts"))
     return void 0;
   const name = declaration.name;
-  return name && (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) ? name.text : void 0;
+  return name && (ts3.isIdentifier(name) || ts3.isStringLiteral(name)) ? name.text : void 0;
 }
 function recordPublishOrUse(out, method, arg0, sf, node) {
   if (method === "publish") {
-    if (arg0 !== void 0 && ts2.isStringLiteralLike(arg0)) {
+    if (arg0 !== void 0 && ts3.isStringLiteralLike(arg0)) {
       out.publishNames.push(arg0.text);
     } else {
       const { line } = sf.getLineAndCharacterOfPosition(node.getStart());
       out.dynamicPublishSites.push(`${sf.fileName}:${line + 1}`);
     }
-  } else if (arg0 !== void 0 && ts2.isStringLiteralLike(arg0)) {
+  } else if (arg0 !== void 0 && ts3.isStringLiteralLike(arg0)) {
     out.useNames.push(arg0.text);
   }
 }
@@ -4423,10 +4568,10 @@ function scanPluginProgram(program, pluginDir) {
     if (sf.isDeclarationFile) continue;
     if (!sf.fileName.replace(/\\/g, "/").startsWith(dirPrefix)) continue;
     const visit = (node) => {
-      if ((ts2.isImportDeclaration(node) || ts2.isExportDeclaration(node)) && node.moduleSpecifier !== void 0 && ts2.isStringLiteralLike(node.moduleSpecifier)) {
+      if ((ts3.isImportDeclaration(node) || ts3.isExportDeclaration(node)) && node.moduleSpecifier !== void 0 && ts3.isStringLiteralLike(node.moduleSpecifier)) {
         recordImportSpecifier(out, node.moduleSpecifier.text);
       }
-      if (ts2.isCallExpression(node)) {
+      if (ts3.isCallExpression(node)) {
         const name = pluginApiName(checker, node);
         if (name && [
           "publish",
@@ -4437,7 +4582,7 @@ function scanPluginProgram(program, pluginDir) {
         ].includes(name))
           recordPublishOrUse(out, name, node.arguments[0], sf, node);
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   }
@@ -4499,8 +4644,8 @@ function canonical(value) {
   throw new Error("canonical metadata requires JSON values");
 }
 function extractContract(path2, packagesDir) {
-  const program = ts3.createProgram([path2], {
-    ...sharedProgramOptions(ts3),
+  const program = ts4.createProgram([path2], {
+    ...sharedProgramOptions(ts4),
     skipLibCheck: false,
     baseUrl: packagesDir,
     paths: { "@s2script/sdk": ["sdk/index.d.ts"], "@s2script/sdk/*": ["sdk/*.d.ts"] }
@@ -4514,11 +4659,11 @@ function extractContract(path2, packagesDir) {
     );
   };
   const visitImports = (node) => {
-    if (ts3.isImportDeclaration(node)) {
-      const module2 = ts3.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : "";
-      const bindings = node.importClause?.namedBindings;
+    if (ts4.isImportDeclaration(node)) {
+      const module2 = ts4.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : "";
+      const bindings2 = node.importClause?.namedBindings;
       const allowed = module2 === "@s2script/sdk/interfaces" ? ["Notification", "Hook", "Transform"] : module2 === "@s2script/sdk/events" || module2 === "@s2script/sdk" ? ["HookResultValue"] : module2 === "@s2script/sdk/entity" ? ["EntityRef"] : [];
-      if (!bindings || !ts3.isNamedImports(bindings) || node.importClause?.name || !bindings.elements.every(
+      if (!bindings2 || !ts4.isNamedImports(bindings2) || node.importClause?.name || !bindings2.elements.every(
         (e) => allowed.includes((e.propertyName ?? e.name).text)
       ))
         fail(
@@ -4526,12 +4671,12 @@ function extractContract(path2, packagesDir) {
           "contracts must be self-contained; only SDK Notification, Hook, Transform, HookResultValue and EntityRef imports are supported"
         );
     }
-    if (ts3.isExportDeclaration(node) && node.moduleSpecifier || ts3.isImportTypeNode(node) || ts3.isImportEqualsDeclaration(node) || ts3.isModuleDeclaration(node))
+    if (ts4.isExportDeclaration(node) && node.moduleSpecifier || ts4.isImportTypeNode(node) || ts4.isImportEqualsDeclaration(node) || ts4.isModuleDeclaration(node))
       fail(
         node,
         "external declarations and module augmentations are not supported in a contract"
       );
-    ts3.forEachChild(node, visitImports);
+    ts4.forEachChild(node, visitImports);
   };
   visitImports(sf);
   if (sf.referencedFiles.length || sf.typeReferenceDirectives.length)
@@ -4541,7 +4686,7 @@ function extractContract(path2, packagesDir) {
     ...program.getSemanticDiagnostics(sf)
   ];
   if (diags.length)
-    fail(sf, ts3.flattenDiagnosticMessageText(diags[0].messageText, "\n"));
+    fail(sf, ts4.flattenDiagnosticMessageText(diags[0].messageText, "\n"));
   const module = checker.getSymbolAtLocation(sf);
   const symbol2 = module && checker.getExportsOfModule(module).find((s) => s.name === "Contract");
   if (!symbol2) fail(sf, "protocol 2 requires an exported Contract");
@@ -4553,26 +4698,26 @@ function extractContract(path2, packagesDir) {
   };
   for (const name of ["methods", "forwards"]) {
     const member = prop(contract, name, sf);
-    if (!(member.flags & ts3.TypeFlags.Object) || member.getCallSignatures().length || checker.getIndexInfosOfType(member).length) {
+    if (!(member.flags & ts4.TypeFlags.Object) || member.getCallSignatures().length || checker.getIndexInfosOfType(member).length) {
       fail(sf, `${name} must be a finite object record`);
     }
   }
   const stack = /* @__PURE__ */ new Set();
   const schema = (type, node, voidAllowed = false) => {
     const f = type.flags;
-    if (f & ts3.TypeFlags.Any || f & ts3.TypeFlags.Unknown || f & ts3.TypeFlags.Never)
+    if (f & ts4.TypeFlags.Any || f & ts4.TypeFlags.Unknown || f & ts4.TypeFlags.Never)
       fail(node, `unsupported wire type ${checker.typeToString(type)}`);
-    if (f & ts3.TypeFlags.Void && voidAllowed) return { kind: "void" };
-    if (f & ts3.TypeFlags.Null) return { kind: "null" };
-    if (f & ts3.TypeFlags.StringLiteral)
+    if (f & ts4.TypeFlags.Void && voidAllowed) return { kind: "void" };
+    if (f & ts4.TypeFlags.Null) return { kind: "null" };
+    if (f & ts4.TypeFlags.StringLiteral)
       return { kind: "literal", value: type.value };
-    if (f & ts3.TypeFlags.NumberLiteral)
+    if (f & ts4.TypeFlags.NumberLiteral)
       return { kind: "literal", value: type.value };
-    if (f & ts3.TypeFlags.BooleanLiteral)
+    if (f & ts4.TypeFlags.BooleanLiteral)
       return { kind: "literal", value: checker.typeToString(type) === "true" };
-    if (f & ts3.TypeFlags.String) return { kind: "string" };
-    if (f & ts3.TypeFlags.Number) return { kind: "number" };
-    if (f & ts3.TypeFlags.Boolean) return { kind: "boolean" };
+    if (f & ts4.TypeFlags.String) return { kind: "string" };
+    if (f & ts4.TypeFlags.Number) return { kind: "number" };
+    if (f & ts4.TypeFlags.Boolean) return { kind: "boolean" };
     if (stack.has(type)) fail(node, "recursive wire types are unsupported");
     stack.add(type);
     try {
@@ -4595,7 +4740,7 @@ function extractContract(path2, packagesDir) {
             node
           )
         };
-      if (!(f & ts3.TypeFlags.Object) || checker.isTupleType(type) || type.getCallSignatures().length || checker.getIndexInfosOfType(type).length)
+      if (!(f & ts4.TypeFlags.Object) || checker.isTupleType(type) || type.getCallSignatures().length || checker.getIndexInfosOfType(type).length)
         fail(node, `unsupported wire type ${checker.typeToString(type)}`);
       const sym = type.getSymbol();
       if (sym?.name === "EntityRef" && sym.declarations?.some(
@@ -4603,7 +4748,7 @@ function extractContract(path2, packagesDir) {
       ))
         return { kind: "entityRef" };
       if (sym?.declarations?.some(
-        (d) => ts3.isClassDeclaration(d) || d.getSourceFile() !== sf
+        (d) => ts4.isClassDeclaration(d) || d.getSourceFile() !== sf
       ))
         fail(
           node,
@@ -4614,11 +4759,11 @@ function extractContract(path2, packagesDir) {
         const decl = p.valueDeclaration ?? node;
         if (p.name === "__s2ref")
           fail(decl, "__s2ref is reserved for the EntityRef wire encoding");
-        const optional = !!(p.flags & ts3.SymbolFlags.Optional);
+        const optional = !!(p.flags & ts4.SymbolFlags.Optional);
         let t2 = checker.getTypeOfSymbolAtLocation(p, decl);
         if (optional && t2.isUnion()) {
           const parts = t2.types.filter(
-            (t3) => !(t3.flags & ts3.TypeFlags.Undefined)
+            (t3) => !(t3.flags & ts4.TypeFlags.Undefined)
           );
           if (parts.length === 1) t2 = parts[0];
           else {
@@ -4642,13 +4787,13 @@ function extractContract(path2, packagesDir) {
   const methods = /* @__PURE__ */ Object.create(null);
   for (const p of prop(contract, "methods", sf).getProperties()) {
     const node = p.valueDeclaration ?? sf, type = checker.getTypeOfSymbolAtLocation(p, node), sigs = type.getCallSignatures();
-    const scanner = ts3.createScanner(
-      ts3.ScriptTarget.ESNext,
+    const scanner = ts4.createScanner(
+      ts4.ScriptTarget.ESNext,
       false,
-      ts3.LanguageVariant.Standard,
+      ts4.LanguageVariant.Standard,
       p.name
     );
-    const identifier = scanner.scan() === ts3.SyntaxKind.Identifier && scanner.scan() === ts3.SyntaxKind.EndOfFileToken;
+    const identifier = scanner.scan() === ts4.SyntaxKind.Identifier && scanner.scan() === ts4.SyntaxKind.EndOfFileToken;
     if (!identifier || ["on", "off", "then"].includes(p.name))
       fail(node, `unsupported or reserved method name ${p.name}`);
     const exported = checker.getExportsOfModule(module).find((s) => s.name === p.name);
@@ -4666,7 +4811,7 @@ function extractContract(path2, packagesDir) {
       )
     )))
       fail(node, `export ${p.name} must agree with Contract.methods`);
-    if (sigs.length !== 1 || sigs[0].typeParameters?.length || p.flags & ts3.SymbolFlags.Optional)
+    if (sigs.length !== 1 || sigs[0].typeParameters?.length || p.flags & ts4.SymbolFlags.Optional)
       fail(node, "methods require one non-generic synchronous signature");
     const sig = sigs[0];
     methods[p.name] = {
@@ -4676,7 +4821,7 @@ function extractContract(path2, packagesDir) {
         let t2 = checker.getTypeOfSymbolAtLocation(p2, d);
         if (d.questionToken && t2.isUnion()) {
           const parts = t2.types.filter(
-            (t3) => !(t3.flags & ts3.TypeFlags.Undefined)
+            (t3) => !(t3.flags & ts4.TypeFlags.Undefined)
           );
           if (parts.length === 1) t2 = parts[0];
           else fail(d, "optional union arguments are unsupported");
@@ -4714,9 +4859,9 @@ function extractContract(path2, packagesDir) {
       if (payload.kind !== "object")
         fail(node, "Transform requires a finite object payload");
       const writableType = prop(type, "__transformWritable", node);
-      const keys2 = writableType.flags & ts3.TypeFlags.Never ? [] : writableType.isUnion() ? writableType.types : [writableType];
+      const keys2 = writableType.flags & ts4.TypeFlags.Never ? [] : writableType.isUnion() ? writableType.types : [writableType];
       const writable = keys2.map((t2) => {
-        if (!(t2.flags & ts3.TypeFlags.StringLiteral))
+        if (!(t2.flags & ts4.TypeFlags.StringLiteral))
           fail(node, "Transform writable keys must be string field names");
         const key2 = t2.value;
         if (!Object.hasOwn(payload.fields, key2))
@@ -4728,10 +4873,10 @@ function extractContract(path2, packagesDir) {
   }
   for (const exported of checker.getExportsOfModule(module)) {
     const typeOnly = exported.declarations?.every(
-      (d) => ts3.isExportSpecifier(d) && (d.isTypeOnly || ts3.isExportDeclaration(d.parent.parent) && d.parent.parent.isTypeOnly)
+      (d) => ts4.isExportSpecifier(d) && (d.isTypeOnly || ts4.isExportDeclaration(d.parent.parent) && d.parent.parent.isTypeOnly)
     );
-    const target2 = exported.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
-    if (!typeOnly && target2.flags & ts3.SymbolFlags.Value && !Object.hasOwn(methods, exported.name))
+    const target2 = exported.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+    if (!typeOnly && target2.flags & ts4.SymbolFlags.Value && !Object.hasOwn(methods, exported.name))
       fail(exported.declarations?.[0] ?? sf, `unsupported value export ${exported.name}; only Contract.methods may export runtime values`);
   }
   const metadata = { version: 1, methods, forwards };
@@ -4751,40 +4896,40 @@ function implementationExpression(checker, expression, seen = /* @__PURE__ */ ne
   const declarationValue = (declaration) => {
     if (seen.has(declaration)) return void 0;
     seen.add(declaration);
-    if ((ts3.isVariableDeclaration(declaration) || ts3.isPropertyAssignment(declaration)) && declaration.initializer)
+    if ((ts4.isVariableDeclaration(declaration) || ts4.isPropertyAssignment(declaration)) && declaration.initializer)
       return implementationExpression(checker, declaration.initializer, seen);
-    if (ts3.isShorthandPropertyAssignment(declaration)) {
+    if (ts4.isShorthandPropertyAssignment(declaration)) {
       const value = checker.getShorthandAssignmentValueSymbol(
         declaration
       )?.valueDeclaration;
       return value && declarationValue(value);
     }
-    if (ts3.isBindingElement(declaration) && ts3.isObjectBindingPattern(declaration.parent)) {
+    if (ts4.isBindingElement(declaration) && ts4.isObjectBindingPattern(declaration.parent)) {
       const object2 = declarationValue(declaration.parent.parent);
       const name = declaration.propertyName ?? declaration.name;
-      if (object2 && (ts3.isIdentifier(name) || ts3.isStringLiteral(name)))
+      if (object2 && (ts4.isIdentifier(name) || ts4.isStringLiteral(name)))
         return propertyValue(object2, name.text);
     }
     return void 0;
   };
-  if (ts3.isParenthesizedExpression(expression))
+  if (ts4.isParenthesizedExpression(expression))
     return implementationExpression(checker, expression.expression, seen);
-  if (ts3.isPropertyAccessExpression(expression))
+  if (ts4.isPropertyAccessExpression(expression))
     return propertyValue(expression.expression, expression.name.text) ?? expression;
-  if (ts3.isElementAccessExpression(expression) && ts3.isStringLiteralLike(expression.argumentExpression))
+  if (ts4.isElementAccessExpression(expression) && ts4.isStringLiteralLike(expression.argumentExpression))
     return propertyValue(
       expression.expression,
       expression.argumentExpression.text
     ) ?? expression;
   let symbol2 = checker.getSymbolAtLocation(expression);
-  if (symbol2 && symbol2.flags & ts3.SymbolFlags.Alias)
+  if (symbol2 && symbol2.flags & ts4.SymbolFlags.Alias)
     symbol2 = checker.getAliasedSymbol(symbol2);
   return (symbol2?.valueDeclaration && declarationValue(symbol2.valueDeclaration)) ?? expression;
 }
 function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir, dependencies, optionalDependencies) {
   const checker = program.getTypeChecker(), out = [];
   const report = (node, message) => out.push({
-    category: ts3.DiagnosticCategory.Error,
+    category: ts4.DiagnosticCategory.Error,
     code: 92002,
     file: node.getSourceFile(),
     start: node.getStart(),
@@ -4804,12 +4949,12 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
   );
   for (const sf of program.getSourceFiles()) {
     const visit = (node) => {
-      if (ts3.isInterfaceDeclaration(node) && node.name.text === "InterfaceContracts" && sf.fileName !== generatedPath && sf.fileName !== sdkInterfaces)
+      if (ts4.isInterfaceDeclaration(node) && node.name.text === "InterfaceContracts" && sf.fileName !== generatedPath && sf.fileName !== sdkInterfaces)
         report(
           node,
           "InterfaceContracts associations are generated; local augmentation is not authority"
         );
-      if (ts3.isCallExpression(node) && sf.fileName.startsWith(pluginDir + "/")) {
+      if (ts4.isCallExpression(node) && sf.fileName.startsWith(pluginDir + "/")) {
         const method = pluginApiName(checker, node);
         if ([
           "publish",
@@ -4819,7 +4964,7 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
           "bindForwards"
         ].includes(method ?? "")) {
           const arg = node.arguments[0];
-          const name = arg && ts3.isStringLiteralLike(arg) ? arg.text : null;
+          const name = arg && ts4.isStringLiteralLike(arg) ? arg.text : null;
           if (!name || !contracts.has(name))
             report(
               node,
@@ -4838,8 +4983,8 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
             if (method === "watchOptional" && node.arguments[1]) {
               const callback = node.arguments[1];
               const type = checker.getTypeAtLocation(implementationExpression(checker, callback));
-              const asynchronous = (type2) => type2.isUnion() ? type2.types.some(asynchronous) : !!(type2.flags & ts3.TypeFlags.Any) || !!type2.getProperty("then");
-              if (type.flags & ts3.TypeFlags.Any || type.getCallSignatures().some((signature) => asynchronous(checker.getReturnTypeOfSignature(signature))))
+              const asynchronous = (type2) => type2.isUnion() ? type2.types.some(asynchronous) : !!(type2.flags & ts4.TypeFlags.Any) || !!type2.getProperty("then");
+              if (type.flags & ts4.TypeFlags.Any || type.getCallSignatures().some((signature) => asynchronous(checker.getReturnTypeOfSignature(signature))))
                 report(callback, "watchOptional requires a synchronous attachment callback; thenables are forbidden");
             }
             if (method === "publish") {
@@ -4855,7 +5000,7 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
               const implementationType = impl && checker.getTypeAtLocation(
                 implementationExpression(checker, impl)
               );
-              if (!actual || actual.flags & ts3.TypeFlags.Any || !checker.isTypeAssignableTo(actual, expected))
+              if (!actual || actual.flags & ts4.TypeFlags.Any || !checker.isTypeAssignableTo(actual, expected))
                 report(
                   impl ?? node,
                   `producer implementation must agree with ${name} Contract.methods (${checker.typeToString(
@@ -4880,7 +5025,7 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
                   if (!implementation) continue;
                   const required = checker.getTypeOfSymbolAtLocation(expectedMethod, impl).getCallSignatures()[0];
                   const declaration = implementation.valueDeclaration;
-                  const value = declaration && ts3.isPropertyAssignment(declaration) ? declaration.initializer : declaration && ts3.isShorthandPropertyAssignment(declaration) ? declaration.name : void 0;
+                  const value = declaration && ts4.isPropertyAssignment(declaration) ? declaration.initializer : declaration && ts4.isShorthandPropertyAssignment(declaration) ? declaration.name : void 0;
                   const methodType = value ? checker.getTypeAtLocation(
                     implementationExpression(checker, value)
                   ) : checker.getTypeOfSymbolAtLocation(implementation, impl);
@@ -4895,15 +5040,15 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
                   const provided = signatures[0];
                   const result = checker.getReturnTypeOfSignature(provided);
                   const expectedResult = checker.getReturnTypeOfSignature(required);
-                  const resultMatches = expectedResult.flags & ts3.TypeFlags.Void ? !!(result.flags & (ts3.TypeFlags.Void | ts3.TypeFlags.Undefined | ts3.TypeFlags.Never)) : checker.isTypeAssignableTo(result, expectedResult);
-                  if (result.flags & ts3.TypeFlags.Any || !resultMatches)
+                  const resultMatches = expectedResult.flags & ts4.TypeFlags.Void ? !!(result.flags & (ts4.TypeFlags.Void | ts4.TypeFlags.Undefined | ts4.TypeFlags.Never)) : checker.isTypeAssignableTo(result, expectedResult);
+                  if (result.flags & ts4.TypeFlags.Any || !resultMatches)
                     report(
                       impl,
                       `producer method ${expectedMethod.name} result must agree with its synchronous Contract signature`
                     );
                   for (const [i2, parameter] of provided.parameters.entries()) {
                     const declaration2 = parameter.valueDeclaration;
-                    if (declaration2 && ts3.isParameter(declaration2) && declaration2.dotDotDotToken) {
+                    if (declaration2 && ts4.isParameter(declaration2) && declaration2.dotDotDotToken) {
                       report(
                         impl,
                         `producer method ${expectedMethod.name} signature cannot use rest parameters`
@@ -4916,7 +5061,7 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
                     );
                     const contractParameter = required.parameters[i2];
                     if (!contractParameter) {
-                      if (!(parameter.flags & ts3.SymbolFlags.Optional) && !(declaration2 && ts3.isParameter(declaration2) && (declaration2.questionToken || declaration2.initializer)))
+                      if (!(parameter.flags & ts4.SymbolFlags.Optional) && !(declaration2 && ts4.isParameter(declaration2) && (declaration2.questionToken || declaration2.initializer)))
                         report(
                           impl,
                           `producer method ${expectedMethod.name} requires an undeclared input`
@@ -4927,9 +5072,9 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
                         impl
                       );
                       const variants = requiredInput.isUnion() ? requiredInput.types : [requiredInput];
-                      const hasDefault = declaration2 && ts3.isParameter(declaration2) && declaration2.initializer;
+                      const hasDefault = declaration2 && ts4.isParameter(declaration2) && declaration2.initializer;
                       if (!variants.every(
-                        (type) => hasDefault && !!(type.flags & ts3.TypeFlags.Undefined) || checker.isTypeAssignableTo(type, input)
+                        (type) => hasDefault && !!(type.flags & ts4.TypeFlags.Undefined) || checker.isTypeAssignableTo(type, input)
                       ))
                         report(
                           impl,
@@ -4944,7 +5089,7 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
           }
         }
       }
-      ts3.forEachChild(node, visit);
+      ts4.forEachChild(node, visit);
     };
     visit(sf);
   }
@@ -4953,7 +5098,7 @@ function checkInteropCalls(program, paths, publishes, generatedPath, pluginDir,
 
 // src/publishes.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 function expandPublishes(authored, pkgName, pkgVersion) {
   if (authored === void 0 || authored === null) return {};
   if (typeof authored === "string") {
@@ -4977,7 +5122,7 @@ function expandPublishes(authored, pkgName, pkgVersion) {
   return out;
 }
 function hashContract(typesPath) {
-  return createHash3("sha256").update(readFileSync3(typesPath)).digest("hex");
+  return createHash3("sha256").update(readFileSync4(typesPath)).digest("hex");
 }
 var CONCRETE_SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
 function isConcreteVersion(v) {
@@ -5015,28 +5160,28 @@ function derivePublishes(authored, pkgName, pkgVersion, typesPath) {
 // src/typecheck/typecheck.ts
 import {
   mkdirSync,
-  existsSync as existsSync7,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync8,
+  existsSync as existsSync8,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync9,
   writeFileSync,
   rmSync,
   mkdtempSync
 } from "node:fs";
-import { join as join8, resolve as resolve8, dirname as dirname3 } from "node:path";
+import { join as join9, resolve as resolve8, dirname as dirname3 } from "node:path";
 import { tmpdir } from "node:os";
 
 // src/packages-resolve.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname, join as join2, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname, join as join3, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 function isPackagesDir(dir) {
   const abs = resolve3(dir);
-  return existsSync2(join2(abs, "sdk", "globals.d.ts")) || existsSync2(join2(abs, "sdk", "entity.d.ts"));
+  return existsSync3(join3(abs, "sdk", "globals.d.ts")) || existsSync3(join3(abs, "sdk", "entity.d.ts"));
 }
 function findPackagesDirNearCli(fromCliUrl = import.meta.url) {
   const start = dirname(fileURLToPath(fromCliUrl));
   for (const rel of ["../..", "../../.."]) {
-    const candidate = join2(start, rel);
+    const candidate = join3(start, rel);
     if (isPackagesDir(candidate)) return resolve3(candidate);
   }
   return void 0;
@@ -5060,7 +5205,7 @@ function resolvePackagesDir(opts) {
   const nearCli = findPackagesDirNearCli(opts?.fromCliUrl);
   if (nearCli) return nearCli;
   if (opts?.pluginDir) {
-    const nm = join2(resolve3(opts.pluginDir), "node_modules", "@s2script");
+    const nm = join3(resolve3(opts.pluginDir), "node_modules", "@s2script");
     if (isPackagesDir(nm)) return nm;
   }
   throw new Error(
@@ -5069,18 +5214,18 @@ function resolvePackagesDir(opts) {
 }
 
 // src/contracts.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
 function localContractPath(pluginDir, dep) {
   const segs = dep.split("/");
   if (segs.some((s) => s === "" || s === "." || s === "..")) return null;
-  const p = join3(pluginDir, ".s2script", "types", ...segs, "index.d.ts");
-  return existsSync3(p) ? p : null;
+  const p = join4(pluginDir, ".s2script", "types", ...segs, "index.d.ts");
+  return existsSync4(p) ? p : null;
 }
 
 // src/workspace/siblings.ts
-import { readFileSync as readFileSync6 } from "node:fs";
-import { join as join6, relative, resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { join as join7, relative as relative2, resolve as resolve6 } from "node:path";
 
 // src/workspace/glob.ts
 function toPosix(p) {
@@ -5113,11 +5258,11 @@ function matchGlob(pattern, path2) {
 }
 
 // src/workspace/workspace.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync } from "node:fs";
-import { dirname as dirname2, join as join4, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { dirname as dirname2, join as join5, resolve as resolve4 } from "node:path";
 function readPackageJson(path2) {
   try {
-    return JSON.parse(readFileSync4(path2, "utf8"));
+    return JSON.parse(readFileSync5(path2, "utf8"));
   } catch (e) {
     throw new Error(`cannot read ${path2}: ${e.message}`);
   }
@@ -5126,7 +5271,7 @@ var MARKER_TEXT = /"s2script"[\s\S]*"workspace"\s*:/;
 function carriesWorkspaceMarker(pkgPath) {
   let text3;
   try {
-    text3 = readFileSync4(pkgPath, "utf8");
+    text3 = readFileSync5(pkgPath, "utf8");
   } catch {
     return false;
   }
@@ -5140,7 +5285,7 @@ function carriesWorkspaceMarker(pkgPath) {
 function findWorkspaceRoot(from) {
   let dir = resolve4(from);
   for (; ; ) {
-    if (carriesWorkspaceMarker(join4(dir, "package.json"))) return dir;
+    if (carriesWorkspaceMarker(join5(dir, "package.json"))) return dir;
     const parent = dirname2(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -5148,7 +5293,7 @@ function findWorkspaceRoot(from) {
 }
 function isDir(path2) {
   try {
-    return statSync(path2).isDirectory();
+    return statSync2(path2).isDirectory();
   } catch {
     return false;
   }
@@ -5156,11 +5301,11 @@ function isDir(path2) {
 function subdirs(dir) {
   let entries;
   try {
-    entries = readdirSync(dir, { withFileTypes: true });
+    entries = readdirSync2(dir, { withFileTypes: true });
   } catch {
     return [];
   }
-  return entries.filter((e) => e.name !== "node_modules" && !e.name.startsWith(".")).filter((e) => e.isDirectory() || e.isSymbolicLink() && isDir(join4(dir, e.name))).map((e) => e.name);
+  return entries.filter((e) => e.name !== "node_modules" && !e.name.startsWith(".")).filter((e) => e.isDirectory() || e.isSymbolicLink() && isDir(join5(dir, e.name))).map((e) => e.name);
 }
 function joinRel(rel, name) {
   return rel === "" ? name : `${rel}/${name}`;
@@ -5174,7 +5319,7 @@ function expandDirGlob(root, pattern) {
       return;
     }
     const head = segments[index];
-    const here = rel === "" ? root : join4(root, rel);
+    const here = rel === "" ? root : join5(root, rel);
     if (head === "**") {
       walk(index + 1, rel);
       for (const name of subdirs(here)) walk(index, joinRel(rel, name));
@@ -5182,7 +5327,7 @@ function expandDirGlob(root, pattern) {
     }
     if (!head.includes("*")) {
       const next = joinRel(rel, head);
-      if (isDir(join4(root, next))) walk(index + 1, next);
+      if (isDir(join5(root, next))) walk(index + 1, next);
       return;
     }
     for (const name of subdirs(here)) {
@@ -5193,11 +5338,11 @@ function expandDirGlob(root, pattern) {
   return [...out].sort();
 }
 function pnpmWorkspaceGlobs(root) {
-  const path2 = join4(root, "pnpm-workspace.yaml");
-  if (!existsSync4(path2)) return [];
+  const path2 = join5(root, "pnpm-workspace.yaml");
+  if (!existsSync5(path2)) return [];
   let body;
   try {
-    body = readFileSync4(path2, "utf8");
+    body = readFileSync5(path2, "utf8");
   } catch {
     return [];
   }
@@ -5239,7 +5384,7 @@ function loadWorkspace(root) {
 }
 function readWorkspace(root) {
   const absRoot = resolve4(root);
-  const pkg = readPackageJson(join4(absRoot, "package.json"));
+  const pkg = readPackageJson(join5(absRoot, "package.json"));
   const marker = pkg.s2script?.workspace;
   if (marker === void 0) {
     throw new Error(
@@ -5264,9 +5409,9 @@ function readWorkspace(root) {
     for (const rel of expandDirGlob(absRoot, glob)) candidates.add(rel);
   }
   for (const rel of [...candidates].sort()) {
-    const dir = join4(absRoot, rel);
-    const pkgPath = join4(dir, "package.json");
-    if (!existsSync4(pkgPath)) continue;
+    const dir = join5(absRoot, rel);
+    const pkgPath = join5(dir, "package.json");
+    if (!existsSync5(pkgPath)) continue;
     pluginDirs.add(rel);
     let pluginPkg;
     try {
@@ -5315,9 +5460,9 @@ function readWorkspace(root) {
   const libs = [];
   for (const rel of [...memberDirs].sort()) {
     if (pluginDirs.has(rel)) continue;
-    const dir = join4(absRoot, rel);
-    const pkgPath = join4(dir, "package.json");
-    if (!existsSync4(pkgPath)) continue;
+    const dir = join5(absRoot, rel);
+    const pkgPath = join5(dir, "package.json");
+    if (!existsSync5(pkgPath)) continue;
     let libPkg;
     try {
       libPkg = readPackageJson(pkgPath);
@@ -5383,8 +5528,8 @@ function ambiguityProblem(iface, publishers) {
 }
 
 // src/publish-gate.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
-import { join as join5, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
+import { join as join6, resolve as resolve5 } from "node:path";
 function hasPublishes(publishes) {
   if (publishes == null) return false;
   if (typeof publishes === "string") return publishes.trim().length > 0;
@@ -5410,14 +5555,14 @@ function assertPublishesTypes(pkg, pluginDir) {
     };
   }
   const typesPath = resolve5(pluginDir, typesRel);
-  if (!existsSync5(typesPath)) {
+  if (!existsSync6(typesPath)) {
     return { ok: false, error: `types file not found: ${typesRel}` };
   }
-  const st = statSync2(typesPath);
+  const st = statSync3(typesPath);
   if (!st.isFile() || st.size === 0) {
     return { ok: false, error: `types file is empty or not a file: ${typesRel}` };
   }
-  const body = readFileSync5(typesPath, "utf8").trim();
+  const body = readFileSync6(typesPath, "utf8").trim();
   if (!body) {
     return { ok: false, error: `types file is empty: ${typesRel}` };
   }
@@ -5426,14 +5571,14 @@ function assertPublishesTypes(pkg, pluginDir) {
 
 // src/workspace/siblings.ts
 function isWorkspaceMemberDir(root, rootPkg, dir) {
-  const rel = toPosix(relative(root, dir));
+  const rel = toPosix(relative2(root, dir));
   if (rel === "" || rel.startsWith("..")) return false;
   const globs = [...workspaceGlobs(rootPkg.workspaces), ...pnpmWorkspaceGlobs(root)];
   return globs.some((g) => matchGlob(g, rel));
 }
 function shadowedCopyWarning(pluginDir, dep) {
   const copy = localContractPath(pluginDir, dep);
-  const where2 = copy === null ? join6(".s2script", "types", dep, "index.d.ts") : relative(pluginDir, copy);
+  const where2 = copy === null ? join7(".s2script", "types", dep, "index.d.ts") : relative2(pluginDir, copy);
   return `WARN: ${dep} resolves to a workspace sibling, so the verified copy at ${toPosix(where2)} is IGNORED and can be deleted \u2014 the sibling's own contract is what this build typechecks and hashes`;
 }
 function resolveSiblingContracts(pluginDir, deps) {
@@ -5443,13 +5588,13 @@ function resolveSiblingContracts(pluginDir, deps) {
   const absDir = resolve6(pluginDir);
   const root = findWorkspaceRoot(absDir);
   if (root === null) return { siblings, shadowedCopies };
-  const rootPkg = JSON.parse(readFileSync6(join6(root, "package.json"), "utf8"));
+  const rootPkg = JSON.parse(readFileSync7(join7(root, "package.json"), "utf8"));
   if (!isWorkspaceMemberDir(root, rootPkg, absDir)) return { siblings, shadowedCopies };
   const scan = scanWorkspace(root);
   const ws = scan.workspace;
   const { producers, ambiguous, byPlugin } = indexInterfaces(ws.plugins);
   const self = ws.plugins.find((p) => resolve6(p.dir) === absDir);
-  const label = self?.name ?? toPosix(relative(root, absDir));
+  const label = self?.name ?? toPosix(relative2(root, absDir));
   const unread = scan.problems ?? [];
   const problems = [];
   for (const dep of deps) {
@@ -5497,8 +5642,8 @@ function resolveSiblingContracts(pluginDir, deps) {
 }
 
 // src/libraries.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
-import { join as join7, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
+import { join as join8, resolve as resolve7 } from "node:path";
 function packageKind(pkg) {
   const k = pkg.s2script?.kind ?? "plugin";
   if (k !== "plugin" && k !== "library") {
@@ -5507,13 +5652,13 @@ function packageKind(pkg) {
   return k;
 }
 function librariesRoot(pluginDir) {
-  return join7(pluginDir, ".s2script", "libs");
+  return join8(pluginDir, ".s2script", "libs");
 }
 function localLibraryDir(pluginDir, name) {
   const segs = name.split("/");
   if (segs.some((s) => s === "" || s === "." || s === "..")) return null;
-  const p = join7(librariesRoot(pluginDir), ...segs);
-  return existsSync6(join7(p, "index.d.ts")) ? p : null;
+  const p = join8(librariesRoot(pluginDir), ...segs);
+  return existsSync7(join8(p, "index.d.ts")) ? p : null;
 }
 function resolveLibrarySibling(pluginDir, name) {
   const absDir = resolve7(pluginDir);
@@ -5552,7 +5697,7 @@ function resolveLibrarySibling(pluginDir, name) {
     );
   }
   const typesPath = resolve7(lib.dir, typesRel);
-  if (!existsSync6(typesPath)) {
+  if (!existsSync7(typesPath)) {
     throw new Error(
       `library ${name} (workspace sibling at ${lib.relDir}) types file not found: ${typesRel}`
     );
@@ -5567,11 +5712,11 @@ function resolveLibraries(pluginDir, declared) {
   for (const name of Object.keys(declared)) {
     const dir = localLibraryDir(pluginDir, name);
     if (dir !== null) {
-      paths[name] = [join7(dir, "index.d.ts")];
+      paths[name] = [join8(dir, "index.d.ts")];
       let version = "0.0.0";
       let apiVersion = "1.x";
       try {
-        const m = JSON.parse(readFileSync7(join7(dir, "package.json"), "utf8"));
+        const m = JSON.parse(readFileSync8(join8(dir, "package.json"), "utf8"));
         if (typeof m.version === "string") version = m.version;
         if (typeof m.s2script?.apiVersion === "string") apiVersion = m.s2script.apiVersion;
       } catch {
@@ -5622,27 +5767,27 @@ function assertLibrariesResolved(pluginDir, declared, sdkApiVersion) {
 
 // src/typecheck/typecheck.ts
 function localDeclarationFiles(pluginDir) {
-  const srcDir = join8(pluginDir, "src");
-  if (!existsSync7(srcDir)) return [];
-  return readdirSync2(srcDir).filter((f) => f.endsWith(".d.ts")).map((f) => join8(srcDir, f));
+  const srcDir = join9(pluginDir, "src");
+  if (!existsSync8(srcDir)) return [];
+  return readdirSync3(srcDir).filter((f) => f.endsWith(".d.ts")).map((f) => join9(srcDir, f));
 }
 function gamedataDeclarations(pluginDir, pkg) {
   const data = loadPluginGamedata(pluginDir, pkg) ?? {};
   return /* @__PURE__ */ new Map([
-    [join8(pluginDir, ".s2script", "gamedata.d.ts"), generateGamedataTypes(data)],
-    [join8(pluginDir, ".s2script", "hooks.d.ts"), generateHookTypes(data)]
+    [join9(pluginDir, ".s2script", "gamedata.d.ts"), generateGamedataTypes(data)],
+    [join9(pluginDir, ".s2script", "hooks.d.ts"), generateHookTypes(data)]
   ]);
 }
 function gamePackageDeclarationFiles(pkg, packagesDir) {
   const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   if (!("@s2script/cs2" in deps)) return [];
-  const hooks = join8(packagesDir, "cs2", "hooks.generated.d.ts");
-  return existsSync7(hooks) ? [hooks] : [];
+  const hooks = join9(packagesDir, "cs2", "hooks.generated.d.ts");
+  return existsSync8(hooks) ? [hooks] : [];
 }
 function declaredModules(dtsFiles) {
   const out = /* @__PURE__ */ new Set();
   for (const f of dtsFiles) {
-    const body = readFileSync8(f, "utf8");
+    const body = readFileSync9(f, "utf8");
     for (const m of body.matchAll(/declare\s+module\s+["']([^"']+)["']/g))
       out.add(m[1]);
   }
@@ -5651,12 +5796,12 @@ function declaredModules(dtsFiles) {
 function typecheckPlugin(pluginDir, opts) {
   const absDir = resolve8(pluginDir);
   const packagesDir = opts?.packagesDir ? resolve8(opts.packagesDir) : resolvePackagesDir({ pluginDir: absDir });
-  const pkg = JSON.parse(readFileSync8(join8(absDir, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync9(join9(absDir, "package.json"), "utf8"));
   const s2 = pkg.s2script ?? {};
   const entryRel = s2.main ?? pkg.main;
   if (!entryRel)
     throw new Error(
-      `typecheckPlugin: no entry point in ${join8(absDir, "package.json")}`
+      `typecheckPlugin: no entry point in ${join9(absDir, "package.json")}`
     );
   const entry = resolve8(absDir, entryRel);
   const isAlwaysResolved = (d) => d === "@s2script/sdk" || d.startsWith("@s2script/sdk/") || d === "@s2script/cs2" || d.startsWith("@s2script/cs2/");
@@ -5677,6 +5822,11 @@ function typecheckPlugin(pluginDir, opts) {
     const p = localContractPath(absDir, d);
     if (p !== null) contractPaths[d] = [p];
   }
+  const extensionPaths = /* @__PURE__ */ Object.create(null);
+  for (const name of Object.keys(s2.extensions ?? {})) {
+    const local = join9(absDir, ".s2script", "extensions", name, "index.d.ts");
+    if (existsSync8(local)) extensionPaths[name] = [local];
+  }
   const protocol2 = s2.interfaceProtocol === 2;
   const authoritativePaths = Object.fromEntries(
     Object.entries(contractPaths).map(([name, paths]) => [name, paths[0]])
@@ -5699,9 +5849,9 @@ function typecheckPlugin(pluginDir, opts) {
       for (const [name, path2] of Object.entries(authoritativePaths)) {
         interfaceContracts[name] = extractContract(path2, packagesDir);
         if (!siblings.has(name) && !ownNames.has(name)) {
-          const receipt = join8(dirname3(path2), "package.json");
-          if (existsSync7(receipt)) {
-            const published = JSON.parse(readFileSync8(receipt, "utf8")).s2script?.publishes?.[name];
+          const receipt = join9(dirname3(path2), "package.json");
+          if (existsSync8(receipt)) {
+            const published = JSON.parse(readFileSync9(receipt, "utf8")).s2script?.publishes?.[name];
             if (!published || published.typesSha256 !== hashContract(path2) || published.contract?.sha256 !== interfaceContracts[name].sha256)
               throw new Error(
                 `InterfaceContractError: ${name} verified copy hash drift; run s2s add`
@@ -5737,7 +5887,7 @@ function typecheckPlugin(pluginDir, opts) {
   const options = {
     // Accept explicit `.ts` import extensions (node type-stripping requires them for source-to-source
     // imports; esbuild strips them at bundle time). Backward-compatible — extensionless imports still resolve.
-    ...sharedProgramOptions(ts4),
+    ...sharedProgramOptions(ts5),
     baseUrl: packagesDir,
     paths: {
       // Builtins: the root barrel `@s2script/sdk` → packages/sdk/index.d.ts; subpaths
@@ -5753,28 +5903,29 @@ function typecheckPlugin(pluginDir, opts) {
       "@s2script/cs2/*": ["cs2/*.d.ts"],
       "@s2script/*": ["*/index.d.ts"],
       ...contractPaths,
-      ...libraryPaths
+      ...libraryPaths,
+      ...extensionPaths
     }
   };
   const virtualDeclarations = gamedataDeclarations(absDir, pkg);
   const engineFunctions = loadEngineFunctions(absDir, pkg.name);
-  virtualDeclarations.set(join8(absDir, ".s2script", "engine-functions.d.ts"), emitEngineFunctionTypes(engineFunctions));
+  virtualDeclarations.set(join9(absDir, ".s2script", "engine-functions.d.ts"), emitEngineFunctionTypes(engineFunctions));
   const rootNames = [
     entry,
-    join8(packagesDir, "sdk", "globals.d.ts"),
+    join9(packagesDir, "sdk", "globals.d.ts"),
     ...localDts,
     ...virtualDeclarations.keys(),
     ...gamePackageDeclarationFiles(pkg, packagesDir)
   ];
-  const tmp = mkdtempSync(join8(tmpdir(), "s2tc-"));
+  const tmp = mkdtempSync(join9(tmpdir(), "s2tc-"));
   try {
-    const generatedPath = join8(absDir, ".s2script", "interfaces.d.ts");
+    const generatedPath = join9(absDir, ".s2script", "interfaces.d.ts");
     rmSync(generatedPath, { force: true });
     if (protocol2) {
-      mkdirSync(join8(absDir, ".s2script"), { recursive: true });
+      mkdirSync(join9(absDir, ".s2script"), { recursive: true });
       let moduleId = 0;
       for (const name of allDeclaredDeps) {
-        const path2 = authoritativePaths[name], wrapper = join8(tmp, `contract-${moduleId++}.d.ts`);
+        const path2 = authoritativePaths[name], wrapper = join9(tmp, `contract-${moduleId++}.d.ts`);
         writeFileSync(
           wrapper,
           `import type {Contract} from ${JSON.stringify(
@@ -5801,14 +5952,14 @@ export declare const on: import("@s2script/sdk/interfaces").TypedInterfaceHandle
       rootNames.push(generatedPath);
     }
     if (deps.length && !protocol2) {
-      const stub = join8(tmp, "ambient.d.ts");
+      const stub = join9(tmp, "ambient.d.ts");
       writeFileSync(
         stub,
         deps.map((d) => `declare module ${JSON.stringify(d)};`).join("\n") + "\n"
       );
       rootNames.push(stub);
     }
-    const host = ts4.createCompilerHost(options);
+    const host = ts5.createCompilerHost(options);
     const originalReadFile = host.readFile.bind(host);
     const originalFileExists = host.fileExists.bind(host);
     host.readFile = (file) => virtualDeclarations.get(resolve8(file)) ?? originalReadFile(file);
@@ -5816,9 +5967,9 @@ export declare const on: import("@s2script/sdk/interfaces").TypedInterfaceHandle
     const originalGetSourceFile = host.getSourceFile.bind(host);
     host.getSourceFile = (file, languageVersion, onError, shouldCreateNewSourceFile) => {
       const text3 = virtualDeclarations.get(resolve8(file));
-      return text3 === void 0 ? originalGetSourceFile(file, languageVersion, onError, shouldCreateNewSourceFile) : ts4.createSourceFile(file, text3, languageVersion);
+      return text3 === void 0 ? originalGetSourceFile(file, languageVersion, onError, shouldCreateNewSourceFile) : ts5.createSourceFile(file, text3, languageVersion);
     };
-    const program = ts4.createProgram(rootNames, options, host);
+    const program = ts5.createProgram(rootNames, options, host);
     const diags = [
       ...program.getSyntacticDiagnostics(),
       ...program.getSemanticDiagnostics(),
@@ -5846,7 +5997,7 @@ export declare const on: import("@s2script/sdk/interfaces").TypedInterfaceHandle
         line,
         col,
         code: d.code,
-        message: ts4.flattenDiagnosticMessageText(d.messageText, "\n")
+        message: ts5.flattenDiagnosticMessageText(d.messageText, "\n")
       };
     });
     return {
@@ -5967,12 +6118,12 @@ var STAMPED_API_VERSION = `${HOST_API_VERSION_MAJOR}.x`;
 
 // src/npm-deps-gate.ts
 import { lstatSync, realpathSync } from "node:fs";
-import { dirname as dirname4, join as join9, resolve as resolve9, sep as sep2 } from "node:path";
+import { dirname as dirname4, join as join10, resolve as resolve9, sep as sep2 } from "node:path";
 function findInNodeModules(startDir, dep) {
   const segs = dep.split("/");
   let dir = resolve9(startDir);
   for (; ; ) {
-    const candidate = join9(dir, "node_modules", ...segs);
+    const candidate = join10(dir, "node_modules", ...segs);
     try {
       lstatSync(candidate);
       return candidate;
@@ -6013,20 +6164,20 @@ function assertNoNpmRuntimeDeps(pkg, pluginDir) {
 
 // src/build-library.ts
 import * as esbuild from "esbuild";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync9, statSync as statSync3 } from "node:fs";
-import { resolve as resolve11, join as join11 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync10, statSync as statSync4 } from "node:fs";
+import { resolve as resolve11, join as join12 } from "node:path";
 
 // src/lint/lint.ts
 import { ESLint } from "eslint";
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname5, join as join10, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
+import { dirname as dirname5, join as join11, resolve as resolve10 } from "node:path";
 import s2lint from "@s2script/eslint-plugin";
 var CONFIG_FILES = ["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts"];
 function ownConfigDir(pluginDir) {
   const stopAt = findWorkspaceRoot(pluginDir);
   let dir = pluginDir;
   for (; ; ) {
-    if (CONFIG_FILES.some((f) => existsSync8(join10(dir, f)))) return dir;
+    if (CONFIG_FILES.some((f) => existsSync9(join11(dir, f)))) return dir;
     if (stopAt === null || dir === stopAt) return null;
     const parent = dirname5(dir);
     if (parent === dir) return null;
@@ -6036,14 +6187,14 @@ function ownConfigDir(pluginDir) {
 function collectTsFiles(dir) {
   let entries;
   try {
-    entries = readdirSync3(dir, { withFileTypes: true });
+    entries = readdirSync4(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const e of entries) {
     if (e.name === "node_modules" || e.name.startsWith(".")) continue;
-    const full = join10(dir, e.name);
+    const full = join11(dir, e.name);
     if (e.isDirectory()) out.push(...collectTsFiles(full));
     else if (e.isFile() && e.name.endsWith(".ts") && !e.name.endsWith(".d.ts")) out.push(full);
   }
@@ -6072,8 +6223,8 @@ async function lintPlugin(pluginDir, program) {
 // src/build-library.ts
 async function buildLibrary(dir, packagesDir) {
   const absDir = resolve11(dir);
-  const pkgPath = join11(absDir, "package.json");
-  const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+  const pkgPath = join12(absDir, "package.json");
+  const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
   const s2 = pkg.s2script ?? {};
   if (s2.pluginDependencies || s2.optionalPluginDependencies) {
     throw new Error(
@@ -6088,7 +6239,7 @@ async function buildLibrary(dir, packagesDir) {
     throw new Error('a library must set "types" to a .d.ts \u2014 consumers vendor it to typecheck against');
   }
   const typesPath = resolve11(absDir, typesRel);
-  if (!existsSync9(typesPath) || !statSync3(typesPath).isFile() || statSync3(typesPath).size === 0) {
+  if (!existsSync10(typesPath) || !statSync4(typesPath).isFile() || statSync4(typesPath).size === 0) {
     throw new Error(`types file is missing or empty: ${typesRel}`);
   }
   assertNoNpmRuntimeDeps(pkg, absDir);
@@ -6107,7 +6258,7 @@ ${lint.output}`);
   const entryRelative = s2.main ?? pkg.main;
   if (!entryRelative) throw new Error(`buildLibrary: no entry point in ${pkgPath} (set s2script.main or main)`);
   const result = await esbuild.build({
-    entryPoints: [join11(absDir, entryRelative)],
+    entryPoints: [join12(absDir, entryRelative)],
     bundle: true,
     platform: "neutral",
     format: "cjs",
@@ -6133,15 +6284,15 @@ ${lint.output}`);
     types: "index.d.ts"
   };
   const sanitized = String(pkg.name).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const outDir = join11(absDir, "dist");
+  const outDir = join12(absDir, "dist");
   mkdirSync2(outDir, { recursive: true });
-  const outPath = join11(outDir, `${sanitized}.s2lib`);
+  const outPath = join12(outDir, `${sanitized}.s2lib`);
   writeFileSync2(
     outPath,
     zipSync({
       "manifest.json": Buffer.from(JSON.stringify(manifest, null, 2)),
       "index.js": Buffer.from(result.outputFiles[0].text),
-      "index.d.ts": readFileSync9(typesPath)
+      "index.d.ts": readFileSync10(typesPath)
     })
   );
   return outPath;
@@ -6150,8 +6301,8 @@ ${lint.output}`);
 // src/build.ts
 async function buildPlugin(dir, packagesDir) {
   const absDir = resolve12(dir);
-  const pkgPath = join12(absDir, "package.json");
-  const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+  const pkgPath = join13(absDir, "package.json");
+  const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
   if (packageKind(pkg) === "library") {
     throw new Error(`${pkgPath} is s2script.kind="library" \u2014 build it with buildLibrary/buildPackage`);
   }
@@ -6175,6 +6326,17 @@ async function buildPlugin(dir, packagesDir) {
       );
     }
   }
+  const extensions = s2.extensions ?? {};
+  for (const name2 of Object.keys(extensions)) {
+    if (pluginDepNames.has(name2) || Object.hasOwn(libraries, name2)) {
+      throw new Error(
+        `${JSON.stringify(name2)} is declared in s2script.extensions and also as a library or plugin dependency \u2014 a native extension is resolved by the host from addons/s2script/extensions/, so it cannot share a name with either`
+      );
+    }
+    if (name2.startsWith("@s2script/sdk")) {
+      throw new Error(`${JSON.stringify(name2)}: s2script.extensions cannot name an @s2script/sdk module`);
+    }
+  }
   const librariesResolved = assertLibrariesResolved(absDir, libraries, STAMPED_API_VERSION);
   const permissions = Array.isArray(s2.permissions) ? s2.permissions : [];
   const gamedata = loadPluginGamedata(absDir, pkg);
@@ -6187,27 +6349,27 @@ async function buildPlugin(dir, packagesDir) {
         throw new Error(`remove authored ${permission} from s2script.permissions: gamedata/functions.jsonc derives it automatically`);
       }
     }
-    mkdirSync3(join12(absDir, ".s2script"), { recursive: true });
-    writeFileSync3(join12(absDir, ".s2script", "engine-functions.d.ts"), emitEngineFunctionTypes(engineFunctions));
+    mkdirSync3(join13(absDir, ".s2script"), { recursive: true });
+    writeFileSync3(join13(absDir, ".s2script", "engine-functions.d.ts"), emitEngineFunctionTypes(engineFunctions));
     console.log(`engine functions: derived permissions ${derivedFunctions.permissions.join(", ") || "(none)"}`);
     for (const f of derivedFunctions.summary.functions) {
       if (f.mutates || f.suppresses) console.log(`engine functions: ${f.canonicalId} risks ${[f.mutates ? "mutation" : "", f.suppresses ? "suppression" : ""].filter(Boolean).join(", ")}`);
     }
   } else {
-    rmSync2(join12(absDir, ".s2script", "engine-functions.d.ts"), { force: true });
+    rmSync2(join13(absDir, ".s2script", "engine-functions.d.ts"), { force: true });
   }
   if (gamedata) {
-    const genDir = join12(absDir, ".s2script");
+    const genDir = join13(absDir, ".s2script");
     mkdirSync3(genDir, { recursive: true });
-    writeFileSync3(join12(genDir, "gamedata.d.ts"), generateGamedataTypes(gamedata));
+    writeFileSync3(join13(genDir, "gamedata.d.ts"), generateGamedataTypes(gamedata));
     if (gamedata.hooks && Object.keys(gamedata.hooks).length) {
-      writeFileSync3(join12(genDir, "hooks.d.ts"), generateHookTypes(gamedata));
+      writeFileSync3(join13(genDir, "hooks.d.ts"), generateHookTypes(gamedata));
     } else {
-      rmSync2(join12(genDir, "hooks.d.ts"), { force: true });
+      rmSync2(join13(genDir, "hooks.d.ts"), { force: true });
     }
   } else {
-    rmSync2(join12(absDir, ".s2script", "gamedata.d.ts"), { force: true });
-    rmSync2(join12(absDir, ".s2script", "hooks.d.ts"), { force: true });
+    rmSync2(join13(absDir, ".s2script", "gamedata.d.ts"), { force: true });
+    rmSync2(join13(absDir, ".s2script", "hooks.d.ts"), { force: true });
   }
   const declaredDepNames = [
     ...Object.keys(s2.pluginDependencies ?? {}),
@@ -6282,6 +6444,13 @@ ${lint.output}`);
       );
     }
   }
+  for (const ext2 of Object.keys(extensions)) {
+    if (!scan.importNames.includes(ext2)) {
+      console.warn(
+        `WARN: extension ${JSON.stringify(ext2)} is declared but never imported \u2014 the plugin still refuses to load on a server without it`
+      );
+    }
+  }
   const { name, version } = pkg;
   if (s2.apiVersion !== void 0) {
     console.warn(
@@ -6292,7 +6461,8 @@ ${lint.output}`);
   const external = Array.from(/* @__PURE__ */ new Set([
     "@s2script/*",
     ...Object.keys(pluginDependencies),
-    ...Object.keys(optionalPluginDependencies)
+    ...Object.keys(optionalPluginDependencies),
+    ...Object.keys(extensions)
   ]));
   const entryRelative = s2.main ?? pkg.main;
   if (!entryRelative) {
@@ -6300,7 +6470,7 @@ ${lint.output}`);
       `buildPlugin: no entry point found in ${pkgPath} (set s2script.main or main)`
     );
   }
-  const entryPoint = join12(absDir, entryRelative);
+  const entryPoint = join13(absDir, entryRelative);
   const result = await esbuild2.build({
     entryPoints: [entryPoint],
     bundle: true,
@@ -6344,6 +6514,7 @@ ${lint.output}`);
     manifest.interfaceContracts = imports;
   }
   if (config !== void 0) manifest.config = config;
+  if (Object.keys(extensions).length > 0) manifest.extensions = extensions;
   const gamedataPermissions = [
     ...gamedata?.calls && Object.keys(gamedata.calls).length ? ["engine:calls"] : [],
     ...gamedata?.hooks && Object.keys(gamedata.hooks).length ? ["engine:hooks"] : []
@@ -6374,21 +6545,21 @@ ${lint.output}`);
   if (gamedata) zipFiles["gamedata.json"] = Buffer.from(JSON.stringify(gamedata, null, 2));
   if (engineFunctions) zipFiles["engine-functions.json"] = Buffer.from(engineFunctionsArchive(engineFunctions));
   if (gate.typesPath !== null && Object.keys(derivedPublishes).length > 0) {
-    const contract = readFileSync10(gate.typesPath);
+    const contract = readFileSync11(gate.typesPath);
     for (const iface of Object.keys(derivedPublishes)) {
       const safe = iface.replace(/[^a-zA-Z0-9._-]/g, "_");
       zipFiles[`types/${safe}.d.ts`] = contract;
     }
   }
   const sanitizedId = name.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const outDir = join12(absDir, "dist");
+  const outDir = join13(absDir, "dist");
   mkdirSync3(outDir, { recursive: true });
-  const outPath = join12(outDir, `${sanitizedId}.s2sp`);
+  const outPath = join13(outDir, `${sanitizedId}.s2sp`);
   writeFileSync3(outPath, zipSync(zipFiles));
   return outPath;
 }
 async function buildPackage(dir, packagesDir) {
-  const pkg = JSON.parse(readFileSync10(join12(resolve12(dir), "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync11(join13(resolve12(dir), "package.json"), "utf8"));
   return packageKind(pkg) === "library" ? buildLibrary(dir, packagesDir) : buildPlugin(dir, packagesDir);
 }
 
@@ -6420,7 +6591,7 @@ function positionals(args, flagsWithValue) {
 
 // src/workspace/build-all.ts
 import { writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // src/workspace/graph.ts
 function topoOrder(batch, warn = console.warn) {
@@ -6740,7 +6911,7 @@ function stampWorkspaceVersion(ws, version) {
         dirty = true;
       }
     }
-    if (dirty) writeFileSync4(join13(p.dir, "package.json"), `${JSON.stringify(next, null, 2)}
+    if (dirty) writeFileSync4(join14(p.dir, "package.json"), `${JSON.stringify(next, null, 2)}
 `);
   }
   return result;
@@ -7884,10 +8055,10 @@ var spinner = ({
   ...I2
 } = {}) => {
   const u4 = isCI();
-  let M, T, d = false, S3 = false, s = "", p, w = performance.now();
+  let M, T, d = false, S4 = false, s = "", p, w = performance.now();
   const x = getColumns(n3), k = I2?.styleFrame ?? W, g = (e) => {
     const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
-    S3 = e === 1, d && (a2(r2, e), S3 && typeof h2 == "function" && h2());
+    S4 = e === 1, d && (a2(r2, e), S4 && typeof h2 == "function" && h2());
   }, f = () => g(2), i2 = () => g(1), A = () => {
     process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i2), process.on("SIGTERM", i2), process.on("exit", g), m && m.addEventListener("abort", i2);
   }, H = () => {
@@ -7947,7 +8118,7 @@ var spinner = ({
     error: (e = "") => a2(e, 2),
     clear: () => a2("", 0, true),
     get isCancelled() {
-      return S3;
+      return S4;
     }
   };
 };
@@ -8221,11 +8392,11 @@ async function runWorkspace(argv2, root, interactive, filters, stampVersion) {
 import { resolve as resolve16 } from "node:path";
 
 // src/registry/deploy.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync14 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync15 } from "node:fs";
 import { resolve as resolve15 } from "node:path";
 
 // src/types-pack.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 
 // src/tar.ts
 import { gzipSync } from "node:zlib";
@@ -8281,7 +8452,7 @@ function packTar(files, opts = {}) {
 
 // src/types-pack.ts
 function packTypesTarball(input) {
-  const dts = readFileSync11(input.typesPath);
+  const dts = readFileSync12(input.typesPath);
   const pkgJson = Buffer.from(
     JSON.stringify(
       {
@@ -8306,8 +8477,8 @@ function packTypesTarball(input) {
 
 // src/source-pack.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
-import { dirname as dirname6, join as join14, relative as relative2, resolve as resolve14, sep as sep4 } from "node:path";
+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";
 
 // ../../node_modules/balanced-match/dist/esm/index.js
 var balanced = (a2, b, str) => {
@@ -10205,7 +10376,7 @@ function readIgnoreFile(dir) {
   for (const name of [".npmignore", ".gitignore"]) {
     let text3;
     try {
-      text3 = readFileSync12(join14(dir, name), "utf8");
+      text3 = readFileSync13(join15(dir, name), "utf8");
     } catch {
       continue;
     }
@@ -10216,7 +10387,7 @@ function readIgnoreFile(dir) {
 function isIgnored(abs, isDir2, rulesets) {
   let ignored = false;
   for (const { base, rules } of rulesets) {
-    const rel = toPosix2(relative2(base, abs));
+    const rel = toPosix2(relative3(base, abs));
     if (!rel || rel.startsWith("..")) continue;
     const r2 = rules.test(isDir2 ? `${rel}/` : rel);
     if (r2.ignored) ignored = true;
@@ -10262,7 +10433,7 @@ function entryPoints(pkg) {
 function npmWorkspaceRoot(absDir) {
   for (let d = dirname6(absDir); ; d = dirname6(d)) {
     try {
-      const pj = JSON.parse(readFileSync12(join14(d, "package.json"), "utf8"));
+      const pj = JSON.parse(readFileSync13(join15(d, "package.json"), "utf8"));
       if (pj && pj.workspaces) return d;
     } catch {
     }
@@ -10281,7 +10452,7 @@ function workspaceRulesets(absDir) {
 }
 function listPackageFiles(dir, pkg) {
   const absDir = resolve14(dir);
-  const pj = pkg ?? JSON.parse(readFileSync12(join14(absDir, "package.json"), "utf8"));
+  const pj = pkg ?? JSON.parse(readFileSync13(join15(absDir, "package.json"), "utf8"));
   const files = filesPatterns(pj.files);
   const never = (0, import_ignore.default)().add(NEVER_PACKED);
   const forced = new Set(entryPoints(pj));
@@ -10290,12 +10461,12 @@ function listPackageFiles(dir, pkg) {
     const isRoot = abs === absDir;
     const own = isRoot && files ? null : readIgnoreFile(abs);
     const here = own ? [...rulesets, own] : rulesets;
-    const entries = readdirSync4(abs, { withFileTypes: true }).sort(
+    const entries = readdirSync5(abs, { withFileTypes: true }).sort(
       (a2, b) => a2.name < b.name ? -1 : a2.name > b.name ? 1 : 0
     );
     for (const entry of entries) {
-      const childAbs = join14(abs, entry.name);
-      const rel = toPosix2(relative2(absDir, childAbs));
+      const childAbs = join15(abs, entry.name);
+      const rel = toPosix2(relative3(absDir, childAbs));
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         if (never.ignores(`${rel}/`)) continue;
@@ -10319,9 +10490,9 @@ function listPackageFiles(dir, pkg) {
 function packSourceTarball(dir, pkg) {
   const absDir = resolve14(dir);
   const files = listPackageFiles(absDir, pkg).map((path2) => {
-    const abs = join14(absDir, path2);
-    const content = readFileSync12(abs);
-    const mode = statSync4(abs).mode & 73 ? 493 : 420;
+    const abs = join15(absDir, path2);
+    const content = readFileSync13(abs);
+    const mode = statSync5(abs).mode & 73 ? 493 : 420;
     return { path: path2, content, mode };
   });
   const tarball = packTar(
@@ -10347,11 +10518,11 @@ function tarballFilename(name, version) {
 }
 
 // src/registry/credentials.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function credentialsPath() {
-  return join15(homedir(), ".s2script", "credentials.json");
+  return join16(homedir(), ".s2script", "credentials.json");
 }
 function normalizeRegistryUrl(url) {
   const trimmed = url.replace(/\/$/, "");
@@ -10369,9 +10540,9 @@ function loadCredentials() {
     return { registryUrl: defaultRegistryUrl(), token: fromEnv };
   }
   const p = credentialsPath();
-  if (!existsSync10(p)) return null;
+  if (!existsSync11(p)) return null;
   try {
-    const j = JSON.parse(readFileSync13(p, "utf8"));
+    const j = JSON.parse(readFileSync14(p, "utf8"));
     if (!j.token) return null;
     return {
       registryUrl: normalizeRegistryUrl(j.registryUrl || defaultRegistryUrl()),
@@ -10382,7 +10553,7 @@ function loadCredentials() {
   }
 }
 function saveCredentials(creds) {
-  const dir = join15(homedir(), ".s2script");
+  const dir = join16(homedir(), ".s2script");
   mkdirSync4(dir, { recursive: true });
   writeFileSync5(
     credentialsPath(),
@@ -10630,10 +10801,10 @@ function assertDeployable(pkg, label) {
 }
 var MAX_README_CHARS = 1e5;
 function readPackageReadme(pluginDir) {
-  const names = readdirSync5(pluginDir).filter((n3) => /^readme(\.(md|markdown))?$/i.test(n3));
+  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 = readFileSync14(resolve15(pluginDir, name), "utf8").trim();
+  const text3 = readFileSync15(resolve15(pluginDir, name), "utf8").trim();
   if (!text3) return null;
   if (text3.length > MAX_README_CHARS) {
     throw new Error(
@@ -10657,7 +10828,7 @@ function assembleDeployArchive(pluginDir, pkg, outPath, opts = {}) {
   const absDir = resolve15(pluginDir);
   const access = opts.access ?? resolveAccess(pkg);
   if (packageKind(pkg) === "library") {
-    const lib = readFileSync14(outPath);
+    const lib = readFileSync15(outPath);
     const manifestEntry2 = unzipSync(lib)["manifest.json"];
     if (!manifestEntry2) {
       throw new Error(`built archive missing manifest.json: ${outPath}`);
@@ -10674,7 +10845,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 = readFileSync14(outPath);
+  const s2sp = readFileSync15(outPath);
   const manifestEntry = unzipSync(s2sp)["manifest.json"];
   if (!manifestEntry) {
     throw new Error(`built archive missing manifest.json: ${outPath}`);
@@ -10700,7 +10871,7 @@ function assembleDeployArchive(pluginDir, pkg, outPath, opts = {}) {
 }
 async function deployPlugin(opts) {
   const absDir = resolve15(opts.dir);
-  const pkg = JSON.parse(readFileSync14(resolve15(absDir, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync15(resolve15(absDir, "package.json"), "utf8"));
   assertDeployable(pkg, absDir);
   const access = resolveAccess(pkg, opts.access);
   assertAccessAllowed(pkg.name ?? absDir, access);
@@ -11041,14 +11212,14 @@ async function runWorkspaceDeploy(opts) {
 import { resolve as resolve17 } from "node:path";
 
 // src/version/version.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join20 } from "node:path";
 
 // src/version/changesets.ts
 var import_semver = __toESM(require_semver2(), 1);
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { pathToFileURL } from "node:url";
 var SUPPORTED = {
   "@changesets/assemble-release-plan": ">=6.0.0 <7.0.0",
@@ -11068,7 +11239,7 @@ function named(mod, key) {
   return outer?.[key];
 }
 async function loadChangesets(workspaceRoot) {
-  const require3 = createRequire2(join16(workspaceRoot, "package.json"));
+  const require3 = createRequire2(join17(workspaceRoot, "package.json"));
   const missing = [];
   const wrongVersion = [];
   const resolved = /* @__PURE__ */ new Map();
@@ -11083,7 +11254,7 @@ async function loadChangesets(workspaceRoot) {
       missing.push(name);
       continue;
     }
-    const version = String(JSON.parse(readFileSync15(manifest, "utf8")).version ?? "");
+    const version = String(JSON.parse(readFileSync16(manifest, "utf8")).version ?? "");
     if (!(0, import_semver.satisfies)(version, range2, { includePrerelease: true })) {
       wrongVersion.push(`${name}@${version} (supported: ${range2})`);
       continue;
@@ -11183,8 +11354,8 @@ function mirrorPackages(ws) {
 
 // src/version/ranges.ts
 var import_semver2 = __toESM(require_semver2(), 1);
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join17 } from "node:path";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join18 } from "node:path";
 var BUMP_LEVEL = { none: 0, patch: 1, minor: 2, major: 3 };
 function rangePrefix(range2) {
   if (range2.startsWith(">=")) return ">=";
@@ -11203,7 +11374,7 @@ function shouldUpdate(release, range2, config) {
   return BUMP_LEVEL[release.type] >= minLevel;
 }
 function readJsonFile(path2) {
-  const raw = readFileSync16(path2, "utf8");
+  const raw = readFileSync17(path2, "utf8");
   const match2 = /^[ \t]*[{[]\s*\n([ \t]+)/.exec(raw);
   return {
     json: JSON.parse(raw),
@@ -11244,7 +11415,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 = join17(plugin.dir, "package.json");
+    const path2 = join18(plugin.dir, "package.json");
     const { json, indent, eol } = readJsonFile(path2);
     const s2 = json.s2script;
     if (s2?.pluginDependencies === void 0) continue;
@@ -11258,7 +11429,7 @@ 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 join18 } from "node:path";
+import { join as join19 } from "node:path";
 var LEVEL = { none: 0, patch: 1, minor: 2, major: 3 };
 function plannedBundleBump(ws, releases) {
   const bundle = readBundle(ws);
@@ -11282,7 +11453,7 @@ function plannedBundleBump(ws, releases) {
 function bumpBundle(ws, releases) {
   const bump = plannedBundleBump(ws, releases);
   if (!bump) return { bump: null, touchedFiles: [] };
-  const path2 = join18(ws.root, "package.json");
+  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);
@@ -11292,8 +11463,8 @@ function bumpBundle(ws, releases) {
 // src/version/version.ts
 async function versionWorkspace(root, opts = {}) {
   const ws = loadWorkspace(root);
-  const configPath = join19(ws.root, ".changeset", "config.json");
-  if (!existsSync11(configPath)) {
+  const configPath = join20(ws.root, ".changeset", "config.json");
+  if (!existsSync12(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}.`
     );
@@ -11380,15 +11551,15 @@ import { resolve as resolve19 } from "node:path";
 import {
   mkdirSync as mkdirSync6,
   writeFileSync as writeFileSync10,
-  readFileSync as readFileSync18,
-  existsSync as existsSync13
+  readFileSync as readFileSync19,
+  existsSync as existsSync14
 } from "node:fs";
-import { join as join22, resolve as resolve18 } from "node:path";
+import { join as join23, resolve as resolve18 } from "node:path";
 import { gunzipSync } from "node:zlib";
 
 // src/registry/npmrc.ts
-import { existsSync as existsSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join21 } from "node:path";
 function npmCompatRegistryUrl(registryUrl) {
   return `${registryUrl.replace(/\/$/, "")}/npm/`;
 }
@@ -11404,8 +11575,8 @@ function ensureScopeNpmrc(projectDir, packageName, registryUrl) {
   const compat = npmCompatRegistryUrl(registryUrl);
   const key = `@${scope}:registry`;
   const line = `${key}=${compat}`;
-  const npmrcPath = join20(projectDir, ".npmrc");
-  let existing = existsSync12(npmrcPath) ? readFileSync17(npmrcPath, "utf8") : "";
+  const npmrcPath = join21(projectDir, ".npmrc");
+  let existing = existsSync13(npmrcPath) ? readFileSync18(npmrcPath, "utf8") : "";
   const lines = existing.split(/\r?\n/);
   const idx = lines.findIndex((l2) => l2.trimStart().startsWith(`${key}=`) || l2.trimStart().startsWith(`${key} =`));
   if (idx >= 0) {
@@ -11421,7 +11592,7 @@ function ensureScopeNpmrc(projectDir, packageName, registryUrl) {
 
 // src/registry/lib-extract.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 var WANTED = /* @__PURE__ */ new Set(["index.js", "index.d.ts"]);
 function extractLibArchive(s2lib, outDir, meta) {
   const entries = unzipSync(new Uint8Array(s2lib));
@@ -11430,7 +11601,7 @@ function extractLibArchive(s2lib, outDir, meta) {
   mkdirSync5(outDir, { recursive: true });
   for (const [name, bytes] of Object.entries(entries)) {
     if (!WANTED.has(name)) continue;
-    writeFileSync9(join21(outDir, name), Buffer.from(bytes));
+    writeFileSync9(join22(outDir, name), Buffer.from(bytes));
   }
   let apiVersion = "1.x";
   try {
@@ -11439,7 +11610,7 @@ function extractLibArchive(s2lib, outDir, meta) {
   } catch {
   }
   writeFileSync9(
-    join21(outDir, "package.json"),
+    join22(outDir, "package.json"),
     JSON.stringify(
       { name: meta.name, version: meta.version, main: "index.js", types: "index.d.ts", s2script: { kind: "library", apiVersion } },
       null,
@@ -11476,13 +11647,13 @@ function extractTypesTarball(tgz, outDir) {
     if (!name || name.endsWith("/")) continue;
     const base = name.replace(/^package\//, "");
     if (base === "package.json") {
-      writeFileSync10(join22(outDir, "package.json"), content);
+      writeFileSync10(join23(outDir, "package.json"), content);
     } else if (base === "api.d.ts" || base === "index.d.ts") {
-      writeFileSync10(join22(outDir, "index.d.ts"), content);
+      writeFileSync10(join23(outDir, "index.d.ts"), content);
       wroteContract = true;
     }
   }
-  if (!wroteContract && !existsSync13(join22(outDir, "index.d.ts"))) {
+  if (!wroteContract && !existsSync14(join23(outDir, "index.d.ts"))) {
     throw new Error("types tarball missing package/api.d.ts (or index.d.ts)");
   }
 }
@@ -11507,10 +11678,10 @@ async function addPackage(opts) {
   }
   if (resolved.kind === "library") {
     const s2lib = await client.downloadLib(name, resolved.version);
-    const libDir = join22(absDir, ".s2script", "libs", ...name.split("/"));
+    const libDir = join23(absDir, ".s2script", "libs", ...name.split("/"));
     extractLibArchive(s2lib, libDir, { name, version: resolved.version });
-    const pkgPath2 = join22(absDir, "package.json");
-    const pkg2 = JSON.parse(readFileSync18(pkgPath2, "utf8"));
+    const pkgPath2 = join23(absDir, "package.json");
+    const pkg2 = JSON.parse(readFileSync19(pkgPath2, "utf8"));
     pkg2.s2script = pkg2.s2script ?? {};
     pkg2.s2script.libraries = pkg2.s2script.libraries ?? {};
     pkg2.s2script.libraries[name] = rangeForResolved(range2, resolved.version);
@@ -11531,10 +11702,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 = join22(absDir, ".s2script", "types", ...name.split("/"));
+  const typesDir = join23(absDir, ".s2script", "types", ...name.split("/"));
   extractTypesTarball(tgz, typesDir);
-  const pkgPath = join22(absDir, "package.json");
-  const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+  const pkgPath = join23(absDir, "package.json");
+  const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
   pkg.s2script = pkg.s2script ?? {};
   pkg.s2script.pluginDependencies = pkg.s2script.pluginDependencies ?? {};
   pkg.s2script.pluginDependencies[name] = rangeForResolved(range2, resolved.version);
@@ -11615,37 +11786,37 @@ async function run4(argv2) {
 }
 
 // src/commands/install.ts
-import { existsSync as existsSync18, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync19, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join27 } from "node:path";
 
 // src/server/manifest.ts
 var import_semver4 = __toESM(require_semver2(), 1);
-import { existsSync as existsSync14, readFileSync as readFileSync19, renameSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename2, join as join23, resolve as resolve20 } from "node:path";
+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";
 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(readFileSync19(path2, "utf8"));
+  const j = JSON.parse(readFileSync20(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 (existsSync14(join23(dir, SERVER_MANIFEST))) return dir;
+    if (existsSync15(join24(dir, SERVER_MANIFEST))) return dir;
   }
   return null;
 }
 function findAddonRoot(start) {
   const found = findServerRoot(start);
   if (found) return found;
-  if (existsSync14(resolve20(start, PLUGINS_SUBDIR))) return resolve20(start);
+  if (existsSync15(resolve20(start, PLUGINS_SUBDIR))) return resolve20(start);
   const nested = resolve20(start, "addons", "s2script");
-  return existsSync14(nested) ? nested : null;
+  return existsSync15(nested) ? nested : null;
 }
 function parseServerManifest(root, raw) {
-  const label = join23(root, SERVER_MANIFEST);
+  const label = join24(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)`);
@@ -11694,8 +11865,8 @@ function parseServerManifest(root, raw) {
   };
 }
 function readServerManifest(root) {
-  const path2 = join23(root, SERVER_MANIFEST);
-  if (!existsSync14(path2)) throw new Error(`no ${SERVER_MANIFEST} in ${root} \u2014 run \`s2s server init\` first`);
+  const path2 = join24(root, SERVER_MANIFEST);
+  if (!existsSync15(path2)) throw new Error(`no ${SERVER_MANIFEST} in ${root} \u2014 run \`s2s server init\` first`);
   return parseServerManifest(root, readJson(path2));
 }
 function newServerManifestJson(name, dependencies) {
@@ -11709,15 +11880,15 @@ function writeServerManifest(m) {
   else delete out.with;
   if (m.disabled.length > 0) out.disabled = [...m.disabled].sort();
   else delete out.disabled;
-  const path2 = join23(m.root, SERVER_MANIFEST);
+  const path2 = join24(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 existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join25, resolve as resolve22 } from "node:path";
+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";
 var import_semver5 = __toESM(require_semver2(), 1);
 
 // src/registry/install.ts
@@ -11770,7 +11941,7 @@ async function resolveMerged(client, specs, withMembers = {}) {
 
 // src/server/lock.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync20, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync21, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
 var LOCKFILE_VERSION = 3;
 function integrityFromSha256Hex(hex) {
   return `sha256-${Buffer.from(hex, "hex").toString("base64")}`;
@@ -11844,8 +12015,8 @@ function parseLock(text3, label = "plugins-lock.json") {
   };
 }
 function readLock(path2) {
-  if (!existsSync15(path2)) return null;
-  return parseLock(readFileSync20(path2, "utf8"), path2);
+  if (!existsSync16(path2)) return null;
+  return parseLock(readFileSync21(path2, "utf8"), path2);
 }
 function writeLock(path2, lock) {
   const tmp = `${path2}.${process.pid}.tmp`;
@@ -11854,8 +12025,8 @@ function writeLock(path2, lock) {
 }
 
 // src/server/sync.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync21, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname7, join as join24, resolve as resolve21, sep as sep5 } from "node:path";
+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";
 function relPath(t2) {
   return t2.disabled ? `${DISABLED_SUBDIR}/${t2.filename}` : t2.filename;
 }
@@ -11936,18 +12107,18 @@ async function syncPlugins(opts) {
   try {
     for (const t2 of opts.targets) {
       const key = lockKey(relPath(t2));
-      const dest = join24(dir, relPath(t2));
+      const dest = join25(dir, relPath(t2));
       result.plugins[key] = {
         name: t2.name,
         version: t2.version,
         resolved: t2.url,
         integrity: integrityFromSha256Hex(t2.sha256)
       };
-      if (existsSync16(dest) && sha256Hex(readFileSync21(dest)) === t2.sha256) {
+      if (existsSync17(dest) && sha256Hex(readFileSync22(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]) => join24(opts.root, k)).find((f) => existsSync16(f) && sha256Hex(readFileSync21(f)) === t2.sha256);
+      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);
       if (movedFrom) {
         result.moved.push(t2.filename);
         if (opts.dryRun) log3(`would ${t2.disabled ? "disable" : "enable"} ${t2.name}@${t2.version}`);
@@ -11984,10 +12155,10 @@ async function syncPlugins(opts) {
   }
   for (const [key, old] of Object.entries(opts.oldLock?.plugins ?? {})) {
     if (key in result.plugins) continue;
-    const file = join24(opts.root, key);
-    if (!existsSync16(file)) continue;
+    const file = join25(opts.root, key);
+    if (!existsSync17(file)) continue;
     const want = sha256HexFromIntegrity(old.integrity);
-    if (want && sha256Hex(readFileSync21(file)) === want) {
+    if (want && sha256Hex(readFileSync22(file)) === want) {
       if (opts.dryRun) log3(`would remove ${old.name}@${old.version} (${key})`);
       else {
         rmSync3(file);
@@ -12039,7 +12210,7 @@ async function serverInstall(opts) {
     }
     manifest = { ...manifest, with: { ...manifest.with, [parseSpec2(opts.specs[0]).name]: opts.with } };
   }
-  const lockPath = join25(opts.root, SERVER_LOCK);
+  const lockPath = join26(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");
@@ -12090,7 +12261,7 @@ async function serverUpdate(opts) {
   const log3 = opts.log ?? (() => {
   });
   const manifest = readServerManifest(opts.root);
-  const lockPath = join25(opts.root, SERVER_LOCK);
+  const lockPath = join26(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) {
@@ -12108,12 +12279,12 @@ async function serverUpdate(opts) {
 }
 function scanLocalPlugins(root, onUnreadable = () => {
 }) {
-  const dir = join25(root, PLUGINS_SUBDIR);
-  if (!existsSync17(dir)) return [];
+  const dir = join26(root, PLUGINS_SUBDIR);
+  if (!existsSync18(dir)) return [];
   const out = [];
-  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".s2sp")) continue;
-    const bytes = readFileSync22(join25(dir, entry.name));
+    const bytes = readFileSync23(join26(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"));
@@ -12127,8 +12298,8 @@ function scanLocalPlugins(root, onUnreadable = () => {
 }
 async function serverInit(opts) {
   const root = resolve22(opts.root);
-  const pkgPath = join25(root, SERVER_MANIFEST);
-  if (existsSync17(pkgPath) && !opts.force) {
+  const pkgPath = join26(root, SERVER_MANIFEST);
+  if (existsSync18(pkgPath) && !opts.force) {
     throw new Error(`${pkgPath} already exists \u2014 pass --force to replace it`);
   }
   const report = { managed: [], unmanaged: [] };
@@ -12169,7 +12340,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(join25(root, SERVER_LOCK), lockFor(manifest, plugins));
+  writeLock(join26(root, SERVER_LOCK), lockFor(manifest, plugins));
   return report;
 }
 async function serverSetEnabled(opts) {
@@ -12187,7 +12358,7 @@ async function serverSetEnabled(opts) {
     else set.add(n3);
   }
   manifest = { ...manifest, disabled: [...set].sort() };
-  const lockPath = join25(opts.root, SERVER_LOCK);
+  const lockPath = join26(opts.root, SERVER_LOCK);
   const lock = readLock(lockPath);
   const specs = pinnedSpecs(manifest, lock, sat);
   const { targets } = await resolveTargets(opts.client, specs, manifest.with, {
@@ -12259,11 +12430,11 @@ async function run5(argv2) {
   }
   await runServer(async () => {
     const withMembers = collectWith(argv2);
-    if (!existsSync18(join26(root, SERVER_MANIFEST))) {
+    if (!existsSync19(join27(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(join26(root, SERVER_MANIFEST), JSON.stringify(fresh, null, 2) + "\n");
-      console.log(`created ${join26(root, SERVER_MANIFEST)}`);
+      writeFileSync15(join27(root, SERVER_MANIFEST), JSON.stringify(fresh, null, 2) + "\n");
+      console.log(`created ${join27(root, SERVER_MANIFEST)}`);
     }
     return serverInstall({
       root,
@@ -12284,26 +12455,26 @@ import { resolve as resolve25 } from "node:path";
 import {
   mkdirSync as mkdirSync8,
   writeFileSync as writeFileSync16,
-  existsSync as existsSync19,
-  readdirSync as readdirSync7,
-  readFileSync as readFileSync23,
+  existsSync as existsSync20,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync24,
   symlinkSync
 } from "node:fs";
-import { dirname as dirname8, isAbsolute, join as join27, relative as relative3, resolve as resolve23, basename as basename4 } from "node:path";
+import { dirname as dirname8, isAbsolute, join as join28, 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 = [
-    join27(here, "..", "package.json"),
+    join28(here, "..", "package.json"),
     // dist/cli.js → packages/sdk/package.json
-    join27(here, "..", "..", "package.json")
+    join28(here, "..", "..", "package.json")
     // src/create → packages/sdk/package.json
   ];
   for (const p of candidates) {
-    if (!existsSync19(p)) continue;
+    if (!existsSync20(p)) continue;
     try {
-      const pkg = JSON.parse(readFileSync23(p, "utf8"));
+      const pkg = JSON.parse(readFileSync24(p, "utf8"));
       if (pkg.name === "@s2script/sdk" && pkg.version) return pkg.version;
     } catch {
     }
@@ -12313,9 +12484,9 @@ function readCliVersion() {
 function findLocalPackagesDir() {
   const here = dirname8(fileURLToPath2(import.meta.url));
   const candidates = [
-    join27(here, "..", ".."),
+    join28(here, "..", ".."),
     // dist/cli.js → packages
-    join27(here, "..", "..", "..")
+    join28(here, "..", "..", "..")
     // src/create → packages
   ];
   for (const c2 of candidates) {
@@ -12331,8 +12502,8 @@ function defaultNameFromPath(dir, kind = "plugin") {
   return `@${kind}/${slugifyBasename(dir)}`;
 }
 function assertEmptyTarget(targetPath) {
-  if (!existsSync19(targetPath)) return;
-  const kids = readdirSync7(targetPath);
+  if (!existsSync20(targetPath)) return;
+  const kids = readdirSync8(targetPath);
   const meaningful = kids.filter((k) => k !== ".git");
   if (meaningful.length) {
     throw new Error(`target directory is not empty: ${targetPath}`);
@@ -12380,8 +12551,8 @@ function registryDevDeps(game, sdkVersion, resolve29 = resolvePublishedVersion)
 function fileDevDeps(packagesDir, game) {
   const deps = {};
   for (const n3 of createPackageNames(game)) {
-    const abs = join27(packagesDir, n3);
-    if (!existsSync19(join27(abs, "package.json"))) return void 0;
+    const abs = join28(packagesDir, n3);
+    if (!existsSync20(join28(abs, "package.json"))) return void 0;
     deps[`@s2script/${n3}`] = `file:${abs}`;
   }
   return deps;
@@ -12446,7 +12617,7 @@ function tsconfigJson() {
   ) + "\n";
 }
 function workspaceTsconfigJson(targetPath, workspaceRoot) {
-  const rel = relative3(targetPath, join27(workspaceRoot, "tsconfig.base.json")).replace(/\\/g, "/");
+  const rel = relative4(targetPath, join28(workspaceRoot, "tsconfig.base.json")).replace(/\\/g, "/");
   return JSON.stringify(
     {
       extends: rel.startsWith(".") ? rel : `./${rel}`,
@@ -12522,10 +12693,10 @@ dist/
 `;
 }
 function linkLocalPackagesForNoInstall(targetPath, localPackagesDir) {
-  const nm = join27(targetPath, "node_modules");
+  const nm = join28(targetPath, "node_modules");
   mkdirSync8(nm, { recursive: true });
-  const dest = join27(nm, "@s2script");
-  if (!existsSync19(dest)) symlinkSync(localPackagesDir, dest);
+  const dest = join28(nm, "@s2script");
+  if (!existsSync20(dest)) symlinkSync(localPackagesDir, dest);
 }
 function runInstall(dir, pm) {
   if (pm === "none") return;
@@ -12554,7 +12725,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 : join27(workspaceRoot, "plugins", slug);
+  let targetPath = workspaceRoot === void 0 ? resolve23(opts.path ?? ".") : slug === void 0 ? void 0 : join28(workspaceRoot, "plugins", slug);
   if (targetPath !== void 0) assertEmptyTarget(targetPath);
   if (interactive) {
     intro2("Create an s2script plugin");
@@ -12564,7 +12735,7 @@ async function createPlugin(opts = {}) {
         slug = assertBareSlug(
           await text2({ message: "Plugin name (directory under plugins/)", placeholder: "myplugin" })
         );
-        targetPath = join27(workspaceRoot, "plugins", slug);
+        targetPath = join28(workspaceRoot, "plugins", slug);
         assertEmptyTarget(targetPath);
       }
     }
@@ -12627,37 +12798,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(join27(finalTargetPath, "src"), { recursive: true });
+  mkdirSync8(join28(finalTargetPath, "src"), { recursive: true });
   if (workspaceRoot !== void 0) {
-    writeFileSync16(join27(finalTargetPath, "package.json"), minimalPackageJsonContent(name));
+    writeFileSync16(join28(finalTargetPath, "package.json"), minimalPackageJsonContent(name));
     writeFileSync16(
-      join27(finalTargetPath, "tsconfig.json"),
+      join28(finalTargetPath, "tsconfig.json"),
       workspaceTsconfigJson(finalTargetPath, workspaceRoot)
     );
   } else if (kind === "library") {
     const version = readCliVersion();
     writeFileSync16(
-      join27(finalTargetPath, "package.json"),
+      join28(finalTargetPath, "package.json"),
       libraryPackageJsonContent(name, game, version, localPackagesDir)
     );
-    writeFileSync16(join27(finalTargetPath, "tsconfig.json"), tsconfigJson());
-    writeFileSync16(join27(finalTargetPath, "eslint.config.mjs"), eslintConfig());
+    writeFileSync16(join28(finalTargetPath, "tsconfig.json"), tsconfigJson());
+    writeFileSync16(join28(finalTargetPath, "eslint.config.mjs"), eslintConfig());
   } else {
     const version = readCliVersion();
     writeFileSync16(
-      join27(finalTargetPath, "package.json"),
+      join28(finalTargetPath, "package.json"),
       packageJsonContent(name, game, version, localPackagesDir)
     );
-    writeFileSync16(join27(finalTargetPath, "tsconfig.json"), tsconfigJson());
-    writeFileSync16(join27(finalTargetPath, "eslint.config.mjs"), eslintConfig());
+    writeFileSync16(join28(finalTargetPath, "tsconfig.json"), tsconfigJson());
+    writeFileSync16(join28(finalTargetPath, "eslint.config.mjs"), eslintConfig());
   }
   if (kind === "library") {
-    writeFileSync16(join27(finalTargetPath, "src", "index.ts"), LIBRARY_ENTRY);
-    writeFileSync16(join27(finalTargetPath, "src", "index.d.ts"), LIBRARY_TYPES);
+    writeFileSync16(join28(finalTargetPath, "src", "index.ts"), LIBRARY_ENTRY);
+    writeFileSync16(join28(finalTargetPath, "src", "index.d.ts"), LIBRARY_TYPES);
   } else {
-    writeFileSync16(join27(finalTargetPath, "src", "plugin.ts"), pluginSource(game));
+    writeFileSync16(join28(finalTargetPath, "src", "plugin.ts"), pluginSource(game));
   }
-  writeFileSync16(join27(finalTargetPath, ".gitignore"), gitignore());
+  writeFileSync16(join28(finalTargetPath, ".gitignore"), gitignore());
   let installed = false;
   if (workspaceRoot === void 0) {
     if (install !== "none") {
@@ -12685,7 +12856,7 @@ async function createPlugin(opts = {}) {
 
 // src/create/workspace.ts
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join28, resolve as resolve24 } from "node:path";
+import { join as join29, resolve as resolve24 } from "node:path";
 var ROOT_DEFAULT_GAME = "cs2";
 var CHANGESETS_CLI_RANGE = "^2.29.5";
 function defaultWorkspaceName(dir) {
@@ -12769,14 +12940,14 @@ async function createWorkspace(opts = {}) {
   name = name ?? defaultWorkspaceName(targetPath);
   const version = readCliVersion();
   const localPackagesDir = findLocalPackagesDir();
-  mkdirSync9(join28(targetPath, "plugins"), { recursive: true });
-  mkdirSync9(join28(targetPath, "packages"), { recursive: true });
-  mkdirSync9(join28(targetPath, ".changeset"), { recursive: true });
-  writeFileSync17(join28(targetPath, "package.json"), rootPackageJsonContent(name, version, localPackagesDir));
-  writeFileSync17(join28(targetPath, "tsconfig.base.json"), tsconfigBaseJson());
-  writeFileSync17(join28(targetPath, "eslint.config.mjs"), eslintConfig());
-  writeFileSync17(join28(targetPath, ".changeset", "config.json"), changesetConfigJson());
-  writeFileSync17(join28(targetPath, ".gitignore"), gitignore());
+  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());
   return { dir: targetPath, name };
 }
 
@@ -13012,8 +13183,8 @@ async function run7(argv2) {
 }
 
 // src/config/gen.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync18, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join29 } from "node:path";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync18, mkdirSync as mkdirSync10 } from "node:fs";
+import { join as join30 } from "node:path";
 
 // src/config/config-path.ts
 function configFileName(id) {
@@ -13060,12 +13231,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 = join29(outDir, configFileName(id));
+  const path2 = join30(outDir, configFileName(id));
   writeFileSync18(path2, generateDefaultJsonc(config));
   return path2;
 }
 function genConfigForS2sp(s2spPath, outDir) {
-  const entry = unzipSync(readFileSync24(s2spPath))["manifest.json"];
+  const entry = unzipSync(readFileSync25(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);
@@ -13112,12 +13283,12 @@ async function run8(argv2) {
 }
 
 // src/commands/codegen.ts
-import { dirname as dirname9, join as join34 } from "node:path";
+import { dirname as dirname9, join as join35 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/schemagen/gen.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join30 } from "node:path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join31 } from "node:path";
 
 // src/schemagen/model.ts
 function enumMemberNames(enumName, members) {
@@ -13422,7 +13593,7 @@ function emitDts(model) {
     return id ? `${id} | null` : TSTYPE[f.accessorKind];
   };
   const names = new Set(model.classes.map((c2) => c2.className));
-  const out = [HEADER2, 'import type { EntityRef } from "@s2script/sdk/entity";'];
+  const out = [HEADER2, 'import type { EntityRef } from "@s2script/sdk/entity";', 'import type { Ptr } from "@s2script/sdk/unsafe";'];
   const vecClasses = /* @__PURE__ */ new Set();
   for (const c2 of model.classes) for (const f of c2.ownFields) {
     const vi = VEC_INFO[f.accessorKind];
@@ -13484,16 +13655,67 @@ function emitDts(model) {
     " * fields.glow.glowing = true;",
     " */",
     "export declare function wrapEntity<K extends keyof SchemaClasses>(className: K, ref: EntityRef): SchemaClasses[K];",
+    "",
+    "/**",
+    " * A view factory for a raw address: the same field accessors as {@link wrapEntity}, over a `Ptr`",
+    " * from `@s2script/sdk/unsafe` instead of a checked entity reference.",
+    " *",
+    " * UNSAFE. Nothing checks that the address still holds this class; a stale one reads garbage or",
+    " * crashes. Use it for memory an engine call handed you, not for entities you can reference safely.",
+    " *",
+    " * @example",
+    ' * import { Ptr } from "@s2script/sdk/unsafe";',
+    ' * const fields = Ptr.from(pawn)?.as(structView("CCSPlayerPawn"));',
+    " */",
+    "export declare function structView<K extends keyof SchemaClasses>(className: K): (ptr: Ptr) => SchemaClasses[K];",
     ""
   );
   return out.join("\n");
 }
 
+// src/schemagen/offset-slots.ts
+var S = JSON.stringify;
+var OffsetSlots = class {
+  constructor() {
+    this.index = /* @__PURE__ */ new Map();
+  }
+  /** The JS expression yielding the offset of `cls::field` (or -1 while it does not resolve). */
+  expr(cls, field) {
+    const key = `${cls}\0${field}`;
+    let i2 = this.index.get(key);
+    if (i2 === void 0) {
+      i2 = this.index.size;
+      this.index.set(key, i2);
+    }
+    return `(O[${i2}] >= 0 ? O[${i2}] : (O[${i2}] = off(${S(cls)},${S(field)})))`;
+  }
+  /** The declaration of the slot table; emit it once, before any accessor can run. */
+  declaration() {
+    return `  var O = new Int32Array(${Math.max(this.index.size, 1)}).fill(-1);`;
+  }
+};
+
+// src/schemagen/shared-module.ts
+import { createHash as createHash5 } from "node:crypto";
+function sharedModule(header, name, body, bind) {
+  const hash = createHash5("sha256").update(body.join("\n")).digest("hex").slice(0, 16);
+  return [
+    header,
+    "(function () {",
+    '  var shared = typeof __s2_shared_module === "function" ? __s2_shared_module : function (key, factory) { return factory(); };',
+    `  var M = shared(${JSON.stringify(`${name}:${hash}`)}, function () {`,
+    ...body.map((line) => line === "" ? line : `  ${line}`),
+    "  });",
+    ...bind.map((line) => `  ${line}`),
+    "})();"
+  ].join("\n");
+}
+
 // src/schemagen/emit-js.ts
 var HEADER3 = "// GENERATED by `s2script gen-schema` from schema-catalog.json \u2014 DO NOT EDIT.";
-var S = JSON.stringify;
-function resolveExpr(f) {
-  const base = `off(${S(f.declaringClass)},${S(f.rawName)})`;
+var S2 = JSON.stringify;
+function resolveExpr(slots, f) {
+  const base = slots.expr(f.declaringClass, f.rawName);
   return f.addOffset ? `${base} + ${f.addOffset}` : base;
 }
 function accessorEntry(f, resolve29, guard2) {
@@ -13506,7 +13728,7 @@ function accessorEntry(f, resolve29, guard2) {
     entry = `get: function () { ${g}var v = this.ref.${READ[f.accessorKind]}(${resolve29}); return v === null ? null : v.toString(); }`;
   } else if (VEC_INFO[f.accessorKind]) {
     const vi = VEC_INFO[f.accessorKind];
-    entry = `get: function () { ${g}var a = this.ref.readFloats(${resolve29}, ${vi.count}); return a === null ? null : new ${vi.cls}(a[0], a[1], a[2]); }`;
+    entry = `get: function () { ${g}return this.ref.read${vi.cls}(${resolve29}); }`;
   } else {
     entry = `get: function () { ${g}return this.ref.${READ[f.accessorKind]}(${resolve29}); }`;
   }
@@ -13517,48 +13739,42 @@ function accessorEntry(f, resolve29, guard2) {
   return entry;
 }
 function emitJs(model) {
-  const out = [HEADER3, "(function () {", "  var off = __s2_schema_offset;", "  var A = {};", "  var E = {};"];
-  const vecClasses = /* @__PURE__ */ new Set();
-  for (const c2 of model.classes) for (const f of c2.ownFields) {
-    const vi = VEC_INFO[f.accessorKind];
-    if (vi) vecClasses.add(vi.cls);
-  }
-  for (const cls of [...vecClasses].sort()) {
-    out.push(`  var ${cls} = __s2require("@s2script/sdk/math").${cls};`);
-  }
+  const slots = new OffsetSlots();
+  const out = ["  var off = __s2_schema_offset;", "  var A = {};", "  var E = {};"];
   for (const c2 of model.classes) {
-    out.push(`  A[${S(c2.className)}] = {`);
+    out.push(`  A[${S2(c2.className)}] = {`);
     for (const f of c2.ownFields) {
-      const entry = accessorEntry(f, resolveExpr(f), "");
-      out.push(`    ${S(f.propName)}: { ${entry} },`);
+      const entry = accessorEntry(f, resolveExpr(slots, f), "");
+      out.push(`    ${S2(f.propName)}: { ${entry} },`);
     }
     for (const f of c2.embeddedFields) {
-      out.push(`    ${S(f.propName)}: { get: function () { return embed(${S(f.embeddedClass)}, this.ref, off(${S(f.declaringClass)},${S(f.rawName)})); } },`);
+      out.push(`    ${S2(f.propName)}: { get: function () { return embed(${S2(f.embeddedClass)}, this.ref, ${slots.expr(f.declaringClass, f.rawName)}); } },`);
     }
     out.push("  };");
   }
   for (const e of model.embedded) {
-    out.push(`  E[${S(e.className)}] = {`);
+    out.push(`  E[${S2(e.className)}] = {`);
     for (const f of e.fields) {
-      const sub = `off(${S(f.declaringClass)},${S(f.rawName)})`;
+      const sub = slots.expr(f.declaringClass, f.rawName);
       const resolve29 = f.addOffset ? `this.base + ${sub} + ${f.addOffset}` : `this.base + ${sub}`;
       const guard2 = `if (this.base < 0 || ${sub} < 0) return null;`;
-      out.push(`    ${S(f.propName)}: { ${accessorEntry(f, resolve29, guard2)} },`);
+      out.push(`    ${S2(f.propName)}: { ${accessorEntry(f, resolve29, guard2)} },`);
     }
     for (const f of e.embeddedFields) {
-      const sub = `off(${S(f.declaringClass)},${S(f.rawName)})`;
-      out.push(`    ${S(f.propName)}: { get: function () { var s = ${sub}; return embed(${S(f.embeddedClass)}, this.ref, (this.base < 0 || s < 0) ? -1 : this.base + s); } },`);
+      const sub = slots.expr(f.declaringClass, f.rawName);
+      out.push(`    ${S2(f.propName)}: { get: function () { var s = ${sub}; return embed(${S2(f.embeddedClass)}, this.ref, (this.base < 0 || s < 0) ? -1 : this.base + s); } },`);
     }
     out.push("  };");
   }
+  out.push(slots.declaration());
   out.push("  var P = {");
-  for (const c2 of model.classes) if (c2.parent) out.push(`    ${S(c2.className)}: ${S(c2.parent)},`);
+  for (const c2 of model.classes) if (c2.parent) out.push(`    ${S2(c2.className)}: ${S2(c2.parent)},`);
   out.push("  };");
   if (model.enums.length > 0) {
     out.push("  var E_CONST = {};");
     for (const e of model.enums) {
-      const body = e.members.map((m) => `${S(m.name)}: ${m.value}`).join(", ");
-      out.push(`  E_CONST[${S(e.tsName)}] = Object.freeze({ ${body} });`);
+      const body = e.members.map((m) => `${S2(m.name)}: ${m.value}`).join(", ");
+      out.push(`  E_CONST[${S2(e.tsName)}] = Object.freeze({ ${body} });`);
     }
   }
   out.push(
@@ -13575,21 +13791,42 @@ function emitJs(model) {
     "        Object.defineProperty(proto, name, { get: defs[name].get, set: defs[name].set, enumerable: true, configurable: true });",
     "      }",
     "    }",
+    "    return proto;",
     "  }",
-    "  function wrap(className, ref) { var o = { ref: ref }; applyAccessors(o, className); return o; }",
+    "  // One prototype per class, built on first use. A view is then one small object holding its",
+    "  // ref (and, embedded, its base offset): the accessors live on the shared prototype, where V8",
+    "  // keeps them on the fast path, instead of being redefined on every wrap and every embedded read.",
+    "  var PROTO = {}, EPROTO = {}, VIEW = {};",
+    "  function protoOf(className) {",
+    "    var p = PROTO[className];",
+    "    if (p === undefined) { p = Object.freeze(applyAccessors({}, className)); PROTO[className] = p; }",
+    "    return p;",
+    "  }",
+    "  function wrap(className, ref) { var o = Object.create(protoOf(className)); o.ref = ref; return o; }",
     "  function embed(className, ref, base) {",
-    "    var o = { ref: ref, base: base }, defs = E[className];",
-    "    if (defs) for (var name in defs) {",
-    "      Object.defineProperty(o, name, { get: defs[name].get, set: defs[name].set, enumerable: true, configurable: true });",
+    "    var p = EPROTO[className];",
+    "    if (p === undefined) {",
+    "      p = {}; var defs = E[className];",
+    "      if (defs) for (var name in defs) {",
+    "        Object.defineProperty(p, name, { get: defs[name].get, set: defs[name].set, enumerable: true, configurable: true });",
+    "      }",
+    "      EPROTO[className] = p = Object.freeze(p);",
     "    }",
-    "    return o;",
+    "    var o = Object.create(p); o.ref = ref; o.base = base; return o;",
     "  }",
-    "  globalThis.__s2pkg_cs2_schema = { applyAccessors: applyAccessors, wrap: wrap };",
-    "  // Merge (not overwrite): this prelude runs FIRST, and pawn.js merges onto whatever it finds.",
-    "  globalThis.__s2pkg_cs2 = Object.assign({}, globalThis.__s2pkg_cs2, { wrapEntity: wrap }" + (model.enums.length > 0 ? ", E_CONST);" : ");"),
-    "})();"
+    "  // A view factory for `Ptr.as`: the same accessors over a raw address, unchecked.",
+    "  function structView(className) {",
+    "    var v = VIEW[className];",
+    "    if (v === undefined) { v = Object.freeze(function (ptr) { return wrap(className, ptr); }); VIEW[className] = v; }",
+    "    return v;",
+    "  }",
+    "  return { applyAccessors: applyAccessors, wrap: wrap, structView: structView, enums: " + (model.enums.length > 0 ? "E_CONST" : "{}") + " };"
   );
-  return out.join("\n");
+  return sharedModule(HEADER3, "@s2script/cs2/schema", out, [
+    "globalThis.__s2pkg_cs2_schema = { applyAccessors: M.applyAccessors, wrap: M.wrap };",
+    "// Merge (not overwrite): this prelude runs FIRST, and pawn.js merges onto whatever it finds.",
+    "globalThis.__s2pkg_cs2 = Object.assign({}, globalThis.__s2pkg_cs2, { wrapEntity: M.wrap, structView: M.structView }, M.enums);"
+  ]);
 }
 
 // src/schemagen/gen.ts
@@ -13600,16 +13837,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(readFileSync25(join30(repoRoot2, CATALOG_PATH), "utf8"));
-  const list = JSON.parse(readFileSync25(join30(repoRoot2, LIST_PATH), "utf8"));
+  const catalog = JSON.parse(readFileSync26(join31(repoRoot2, CATALOG_PATH), "utf8"));
+  const list = JSON.parse(readFileSync26(join31(repoRoot2, LIST_PATH), "utf8"));
   let embed = [];
   try {
-    embed = JSON.parse(readFileSync25(join30(repoRoot2, EMBED_PATH), "utf8"));
+    embed = JSON.parse(readFileSync26(join31(repoRoot2, EMBED_PATH), "utf8"));
   } catch {
   }
   let enumCatalog = {};
   try {
-    enumCatalog = JSON.parse(readFileSync25(join30(repoRoot2, ENUMS_PATH), "utf8"));
+    enumCatalog = JSON.parse(readFileSync26(join31(repoRoot2, ENUMS_PATH), "utf8"));
   } catch {
   }
   const model = buildModel(catalog, list, embed, enumCatalog);
@@ -13620,11 +13857,11 @@ function runGenSchema(repoRoot2, opts) {
   const drift = [];
   const files = [[JS_OUT, js], [DTS_OUT, dts]];
   for (const [rel, content] of files) {
-    const abs = join30(repoRoot2, rel);
+    const abs = join31(repoRoot2, rel);
     if (opts.check) {
       let cur = "";
       try {
-        cur = readFileSync25(abs, "utf8");
+        cur = readFileSync26(abs, "utf8");
       } catch {
       }
       if (cur !== content) drift.push(rel);
@@ -13639,8 +13876,8 @@ function runGenSchema(repoRoot2, opts) {
 }
 
 // src/eventgen/gen.ts
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join31 } from "node:path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join32 } from "node:path";
 
 // src/eventgen/model.ts
 var TYPE_TO_GETTER = {
@@ -13725,15 +13962,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(readFileSync26(join31(repoRoot2, CATALOG_PATH2), "utf8"));
+  const catalog = JSON.parse(readFileSync27(join32(repoRoot2, CATALOG_PATH2), "utf8"));
   const model = buildEventModel(catalog);
   const dts = emitEventDts(model);
   const drift = [];
-  const abs = join31(repoRoot2, DTS_OUT2);
+  const abs = join32(repoRoot2, DTS_OUT2);
   if (opts.check) {
     let cur = "";
     try {
-      cur = readFileSync26(abs, "utf8");
+      cur = readFileSync27(abs, "utf8");
     } catch {
     }
     if (cur !== dts) drift.push(DTS_OUT2);
@@ -13744,8 +13981,8 @@ function runGenEvents(repoRoot2, opts) {
 }
 
 // src/navgen/gen.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "node:fs";
+import { join as join33 } from "node:path";
 
 // src/navgen/model.ts
 var SUPPORTED_NAV_KINDS = /* @__PURE__ */ new Set([
@@ -13810,7 +14047,7 @@ function buildNavModel(config, catalog) {
 
 // src/navgen/emit-js.ts
 var HEADER5 = "// GENERATED by `s2script gen-nav` from nav-targets.json \u2014 DO NOT EDIT.";
-var S2 = JSON.stringify;
+var S3 = JSON.stringify;
 var READ_VIA = {
   f32: "readFloat32Via",
   bool: "readBoolVia",
@@ -13827,17 +14064,8 @@ var WRITE_VIA = {
   i32: "writeInt32Via"
 };
 function emitNavJs(model) {
-  const out = [HEADER5, "(function () {", "  var off = __s2_schema_offset;"];
-  const vecClasses = /* @__PURE__ */ new Set();
-  for (const w of model.wrappers) {
-    for (const f of w.fields) {
-      const vi = VEC_INFO[f.accessorKind];
-      if (vi) vecClasses.add(vi.cls);
-    }
-  }
-  for (const cls of [...vecClasses].sort()) {
-    out.push(`  var ${cls} = __s2require("@s2script/sdk/math").${cls};`);
-  }
+  const slots = new OffsetSlots();
+  const out = ["  var off = __s2_schema_offset;"];
   for (const w of model.wrappers) {
     out.push(`  function ${w.wrapper}(root, path, base) { this.root = root; this.path = path; this.base = base; }`);
     out.push(`  ${w.wrapper}.prototype.notifyChanged = function () {`);
@@ -13845,7 +14073,7 @@ function emitNavJs(model) {
     out.push(`  };`);
     out.push(`  Object.defineProperties(${w.wrapper}.prototype, {`);
     for (const f of w.fields) {
-      const own = `off(${S2(f.declaringClass)},${S2(f.rawName)})`;
+      const own = slots.expr(f.declaringClass, f.rawName);
       const withDelta = f.addOffset ? `${own} + ${f.addOffset}` : own;
       const resolve29 = `${withDelta} + this.base`;
       let getter;
@@ -13856,7 +14084,7 @@ function emitNavJs(model) {
         getter = `get: function () { var v = this.root.readInt64Via(this.path, ${resolve29}); return v === null ? null : v.toString(); }`;
       } else if (VEC_INFO[kind]) {
         const vi = VEC_INFO[kind];
-        getter = `get: function () { var a = this.root.readFloatsChain(this.path, ${resolve29}, ${vi.count}); return a === null ? null : new ${vi.cls}(a[0], a[1], a[2]); }`;
+        getter = `get: function () { return this.root.read${vi.cls}Chain(this.path, ${resolve29}); }`;
       } else if (kind === "handle") {
         getter = `get: function () { return this.root.readHandleVia(this.path, ${resolve29}); }`;
       } else {
@@ -13866,9 +14094,10 @@ function emitNavJs(model) {
       }
       const wmethod = f.navWritable ? WRITE_VIA[kind] : void 0;
       const setter = wmethod ? `, set: function (v) { this.root.${wmethod}(this.path, ${resolve29}, v); }` : "";
-      out.push(`    ${S2(f.propName)}: { ${getter}${setter} },`);
+      out.push(`    ${S3(f.propName)}: { ${getter}${setter} },`);
     }
     out.push("  });");
+    out.push(`  Object.freeze(${w.wrapper}.prototype); Object.freeze(${w.wrapper});`);
   }
   const bySource = /* @__PURE__ */ new Map();
   for (const w of model.wrappers) {
@@ -13877,20 +14106,20 @@ function emitNavJs(model) {
   }
   out.push("  function applyNav(proto, className) {");
   for (const [src, wrappers] of [...bySource.entries()].sort((a2, b) => a2[0] < b[0] ? -1 : a2[0] > b[0] ? 1 : 0)) {
-    out.push(`    if (className === ${S2(src)}) {`);
+    out.push(`    if (className === ${S3(src)}) {`);
     for (const w of wrappers) {
-      out.push(`      Object.defineProperty(proto, ${S2(w.prop)}, {`);
+      out.push(`      Object.defineProperty(proto, ${S3(w.prop)}, {`);
       out.push(`        get: function () {`);
       out.push(`          var _p = [];`);
       for (let i2 = 0; i2 < w.path.length; i2++) {
         const h2 = w.path[i2];
-        out.push(`          var o${i2} = off(${S2(h2.cls)},${S2(h2.field)}); if (o${i2} < 0) return null; _p.push(o${i2});`);
+        out.push(`          var o${i2} = ${slots.expr(h2.cls, h2.field)}; if (o${i2} < 0) return null; _p.push(o${i2});`);
       }
       if (w.base.length > 0) {
         out.push(`          var _b = 0;`);
         for (let i2 = 0; i2 < w.base.length; i2++) {
           const h2 = w.base[i2];
-          out.push(`          var b${i2} = off(${S2(h2.cls)},${S2(h2.field)}); if (b${i2} < 0) return null; _b += b${i2};`);
+          out.push(`          var b${i2} = ${slots.expr(h2.cls, h2.field)}; if (b${i2} < 0) return null; _b += b${i2};`);
         }
         out.push(`          return new ${w.wrapper}(this.ref, _p, _b);`);
       } else {
@@ -13902,10 +14131,11 @@ function emitNavJs(model) {
     out.push("    }");
   }
   out.push("  }");
-  out.push("  globalThis.__s2pkg_cs2_nav = { applyNav: applyNav };");
-  out.push("})();");
-  out.push("");
-  return out.join("\n");
+  out.push(slots.declaration());
+  out.push("  return { applyNav: applyNav };");
+  return sharedModule(HEADER5, "@s2script/cs2/nav", out, [
+    "globalThis.__s2pkg_cs2_nav = { applyNav: M.applyNav };"
+  ]) + "\n";
 }
 
 // src/navgen/emit-dts.ts
@@ -13966,8 +14196,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(readFileSync27(join32(repoRoot2, TARGETS_PATH), "utf8"));
-  const catalog = JSON.parse(readFileSync27(join32(repoRoot2, CATALOG_PATH3), "utf8"));
+  const config = JSON.parse(readFileSync28(join33(repoRoot2, TARGETS_PATH), "utf8"));
+  const catalog = JSON.parse(readFileSync28(join33(repoRoot2, CATALOG_PATH3), "utf8"));
   const model = buildNavModel(config, catalog);
   const js = emitNavJs(model);
   const dts = emitNavDts(model);
@@ -13975,11 +14205,11 @@ function runGenNav(repoRoot2, opts) {
   const drift = [];
   const files = [[JS_OUT2, js], [DTS_OUT3, dts]];
   for (const [rel, content] of files) {
-    const abs = join32(repoRoot2, rel);
+    const abs = join33(repoRoot2, rel);
     if (opts.check) {
       let cur = "";
       try {
-        cur = readFileSync27(abs, "utf8");
+        cur = readFileSync28(abs, "utf8");
       } catch {
       }
       if (cur !== content) drift.push(rel);
@@ -13991,22 +14221,22 @@ function runGenNav(repoRoot2, opts) {
 }
 
 // src/hookgen/gen.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join33 } from "node:path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync22 } from "node:fs";
+import { join as join34 } 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 = readFileSync28(join33(repoRoot2, GAMEDATA_PATH), "utf8");
+  const raw = readFileSync29(join34(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 = join33(repoRoot2, DTS_OUT4);
+  const abs = join34(repoRoot2, DTS_OUT4);
   if (opts.check) {
     let cur = "";
     try {
-      cur = readFileSync28(abs, "utf8");
+      cur = readFileSync29(abs, "utf8");
     } catch {
     }
     if (cur !== dts) drift.push(DTS_OUT4);
@@ -14019,7 +14249,7 @@ function runGenHooks(repoRoot2, opts) {
 
 // src/commands/codegen.ts
 function repoRoot() {
-  return join34(dirname9(fileURLToPath3(import.meta.url)), "..", "..", "..");
+  return join35(dirname9(fileURLToPath3(import.meta.url)), "..", "..", "..");
 }
 async function run9(kind, argv2) {
   const root = repoRoot();
@@ -14076,9 +14306,9 @@ async function run9(kind, argv2) {
 }
 
 // src/commands/inspect.ts
-import { readFileSync as readFileSync29 } from "node:fs";
+import { readFileSync as readFileSync30 } from "node:fs";
 function inspectArchive(path2) {
-  const files = unzipSync(readFileSync29(path2));
+  const files = unzipSync(readFileSync30(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)"}`];
@@ -14107,10 +14337,10 @@ async function run10(argv2) {
 }
 
 // src/engine-functions/migrate-v1.ts
-import { closeSync, existsSync as existsSync20, linkSync, lstatSync as lstatSync2, mkdirSync as mkdirSync11, openSync, readFileSync as readFileSync30, readdirSync as readdirSync8, renameSync as renameSync4, unlinkSync, writeFileSync as writeFileSync23 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join35, relative as relative4, resolve as resolve26, sep as sep6 } from "node:path";
-import { createHash as createHash5, randomUUID } from "node:crypto";
-import ts5 from "typescript";
+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 { createHash as createHash6, randomUUID } from "node:crypto";
+import ts6 from "typescript";
 var PLATFORM3 = "linuxsteamrt64";
 var SCOPE = "structurally lossless conversion of declared v1 contract; native ABI completeness is not verified";
 var IDENT = /^[A-Za-z_$][\w$]*$/;
@@ -14131,7 +14361,7 @@ function fields(value, allowed, where2, errors) {
   for (const key of Object.keys(value)) if (!allowed.includes(key)) errors.push(`${where2}: unsupported field ${key}`);
 }
 function contained(dir, path2) {
-  const r2 = relative4(dir, path2);
+  const r2 = relative5(dir, path2);
   return r2 === "" || r2 !== ".." && !r2.startsWith(`..${sep6}`) && !isAbsolute2(r2);
 }
 function targetOf(ref, signatures, where2, errors) {
@@ -14235,11 +14465,11 @@ function hookOf(name, value, signatures, errors) {
 }
 function sourceFiles(dir, pkg, errors) {
   const result = /* @__PURE__ */ new Set();
-  const src = join35(dir, "src");
+  const src = join36(dir, "src");
   function walk(at) {
-    if (!existsSync20(at)) return;
-    for (const item of readdirSync8(at, { withFileTypes: true })) {
-      const p = join35(at, item.name);
+    if (!existsSync21(at)) return;
+    for (const item of readdirSync9(at, { withFileTypes: true })) {
+      const p = join36(at, item.name);
       if (item.isDirectory()) walk(p);
       else if (item.isFile() && /\.[cm]?[jt]sx?$/.test(item.name)) result.add(p);
     }
@@ -14247,23 +14477,23 @@ function sourceFiles(dir, pkg, errors) {
   walk(src);
   if (valid2(pkg.main)) {
     const p = resolve26(dir, pkg.main);
-    if (contained(dir, p) && existsSync20(p) && lstatSync2(p).isFile()) result.add(p);
+    if (contained(dir, p) && existsSync21(p) && lstatSync2(p).isFile()) result.add(p);
   }
   const queue = [...result];
   for (let i2 = 0; i2 < queue.length; i2++) {
     const file = queue[i2];
-    const ast = ts5.createSourceFile(file, readFileSync30(file, "utf8"), ts5.ScriptTarget.Latest, true);
+    const ast = ts6.createSourceFile(file, readFileSync31(file, "utf8"), ts6.ScriptTarget.Latest, true);
     const follow = (spec, node) => {
       if (!spec.startsWith(".")) return;
-      const at = `${relative4(dir, file)}:${ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1}`;
+      const at = `${relative5(dir, file)}:${ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1}`;
       const base = resolve26(dirname10(file), spec);
       if (!contained(dir, base)) {
         errors.push(`${at}: local module ${JSON.stringify(spec)} escapes plugin directory`);
         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) => join35(base, x))];
-      const found = candidates.find((p) => contained(dir, p) && existsSync20(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) => join36(base, x))];
+      const found = candidates.find((p) => contained(dir, p) && existsSync21(p) && lstatSync2(p).isFile());
       if (!found) {
         errors.push(`${at}: unresolved local module ${JSON.stringify(spec)}`);
         return;
@@ -14273,18 +14503,18 @@ function sourceFiles(dir, pkg, errors) {
       queue.push(found);
     };
     for (const statement of ast.statements) {
-      if (!ts5.isImportDeclaration(statement) && !ts5.isExportDeclaration(statement)) continue;
+      if (!ts6.isImportDeclaration(statement) && !ts6.isExportDeclaration(statement)) continue;
       const spec = statement.moduleSpecifier;
-      if (spec && ts5.isStringLiteral(spec)) follow(spec.text, spec);
+      if (spec && ts6.isStringLiteral(spec)) follow(spec.text, spec);
     }
     const visit = (node) => {
-      if (ts5.isCallExpression(node) && (ts5.isIdentifier(node.expression) && node.expression.text === "require" || node.expression.kind === ts5.SyntaxKind.ImportKeyword)) {
+      if (ts6.isCallExpression(node) && (ts6.isIdentifier(node.expression) && node.expression.text === "require" || node.expression.kind === ts6.SyntaxKind.ImportKeyword)) {
         const arg = node.arguments[0];
-        if (!arg || !ts5.isStringLiteral(arg) && !ts5.isNoSubstitutionTemplateLiteral(arg)) {
-          errors.push(`${relative4(dir, file)}:${ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1}: dynamic module edge cannot be resolved for source analysis`);
+        if (!arg || !ts6.isStringLiteral(arg) && !ts6.isNoSubstitutionTemplateLiteral(arg)) {
+          errors.push(`${relative5(dir, file)}:${ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1}: dynamic module edge cannot be resolved for source analysis`);
         } else follow(arg.text, node);
       }
-      ts5.forEachChild(node, visit);
+      ts6.forEachChild(node, visit);
     };
     visit(ast);
   }
@@ -14293,152 +14523,152 @@ function sourceFiles(dir, pkg, errors) {
 function scanSource(files, calls, hooks, report) {
   const namespaces = new Set(hooks.values());
   for (const file of files) {
-    const source = ts5.createSourceFile(file, readFileSync30(file, "utf8"), ts5.ScriptTarget.Latest, true);
-    if (source.parseDiagnostics?.length) report.ambiguities.push(`${relative4(report.package, file)}: source syntax errors prevent reliable reference analysis`);
+    const source = ts6.createSourceFile(file, readFileSync31(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(`${relative4(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: ${message}`);
+      report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: ${message}`);
     };
     const visit = (node) => {
-      if ((ts5.isImportDeclaration(node) || ts5.isExportDeclaration(node)) && node.moduleSpecifier && ts5.isStringLiteral(node.moduleSpecifier)) {
+      if ((ts6.isImportDeclaration(node) || ts6.isExportDeclaration(node)) && node.moduleSpecifier && ts6.isStringLiteral(node.moduleSpecifier)) {
         const spec = node.moduleSpecifier.text;
         if (spec === "@s2script/sdk/unsafe") {
-          if (ts5.isExportDeclaration(node)) ambiguity(node, "unsafe Engine reexport prevents proving legacy timing/null behavior");
+          if (ts6.isExportDeclaration(node)) ambiguity(node, "unsafe Engine reexport prevents proving legacy timing/null behavior");
           else {
-            const bindings = node.importClause?.namedBindings;
-            const defaultBinding = bindings && ts5.isNamedImports(bindings) && bindings.elements.some((e) => (e.propertyName?.text ?? e.name.text) === "default");
-            if (node.importClause?.name || bindings && ts5.isNamespaceImport(bindings) || defaultBinding) {
+            const bindings2 = node.importClause?.namedBindings;
+            const defaultBinding = bindings2 && ts6.isNamedImports(bindings2) && bindings2.elements.some((e) => (e.propertyName?.text ?? e.name.text) === "default");
+            if (node.importClause?.name || bindings2 && ts6.isNamespaceImport(bindings2) || defaultBinding) {
               ambiguity(node, "indirect Engine namespace import from unsafe SDK prevents proving legacy timing/null behavior");
             }
           }
         }
-        if (["node:module", "module"].includes(spec) && (ts5.isExportDeclaration(node) || node.importClause)) {
-          ambiguity(node, ts5.isExportDeclaration(node) ? "module loader reexport prevents complete local source analysis" : "indirect module loader import prevents complete local source analysis");
+        if (["node:module", "module"].includes(spec) && (ts6.isExportDeclaration(node) || node.importClause)) {
+          ambiguity(node, ts6.isExportDeclaration(node) ? "module loader reexport prevents complete local source analysis" : "indirect module loader import prevents complete local source analysis");
         }
       }
-      if (ts5.isImportEqualsDeclaration(node) && !node.isTypeOnly && ts5.isExternalModuleReference(node.moduleReference)) {
+      if (ts6.isImportEqualsDeclaration(node) && !node.isTypeOnly && ts6.isExternalModuleReference(node.moduleReference)) {
         const ref = node.moduleReference.expression;
-        const spec = ref && ts5.isStringLiteral(ref) ? ref.text : void 0;
+        const spec = ref && ts6.isStringLiteral(ref) ? ref.text : void 0;
         if (spec === "@s2script/sdk/unsafe") ambiguity(node, "unsafe Engine import-equals export or alias prevents proving legacy timing/null behavior");
         else if (spec === "node:module" || spec === "module") ambiguity(node, "module loader import-equals export or alias prevents complete local source analysis");
         else ambiguity(node, "import-equals module edge cannot be followed for complete source analysis");
       }
-      if (ts5.isImportSpecifier(node) && (node.propertyName?.text ?? node.name.text) === "createRequire") {
+      if (ts6.isImportSpecifier(node) && (node.propertyName?.text ?? node.name.text) === "createRequire") {
         ambiguity(node, "indirect module loader factory prevents complete local source analysis");
       }
-      if (ts5.isCallExpression(node) && (ts5.isIdentifier(node.expression) && node.expression.text === "require" || node.expression.kind === ts5.SyntaxKind.ImportKeyword)) {
+      if (ts6.isCallExpression(node) && (ts6.isIdentifier(node.expression) && node.expression.text === "require" || node.expression.kind === ts6.SyntaxKind.ImportKeyword)) {
         const arg = node.arguments[0];
-        if (arg && (ts5.isStringLiteral(arg) || ts5.isNoSubstitutionTemplateLiteral(arg)) && arg.text === "@s2script/sdk/unsafe") {
+        if (arg && (ts6.isStringLiteral(arg) || ts6.isNoSubstitutionTemplateLiteral(arg)) && arg.text === "@s2script/sdk/unsafe") {
           ambiguity(node, "indirect Engine namespace load from unsafe SDK prevents proving legacy timing/null behavior");
         }
-        if (arg && (ts5.isStringLiteral(arg) || ts5.isNoSubstitutionTemplateLiteral(arg)) && ["node:module", "module"].includes(arg.text)) {
+        if (arg && (ts6.isStringLiteral(arg) || ts6.isNoSubstitutionTemplateLiteral(arg)) && ["node:module", "module"].includes(arg.text)) {
           ambiguity(node, "indirect module loader import prevents complete local source analysis");
         }
       }
-      if (ts5.isIdentifier(node) && node.text === "require") {
+      if (ts6.isIdentifier(node) && node.text === "require") {
         const parent = node.parent;
-        const directCall = ts5.isCallExpression(parent) && parent.expression === node;
-        const declaredName = (ts5.isVariableDeclaration(parent) || ts5.isParameter(parent)) && parent.name === node;
-        const propertyName = (ts5.isPropertyAccessExpression(parent) || ts5.isPropertyAssignment(parent)) && parent.name === node;
-        if (declaredName || ts5.isImportSpecifier(parent)) ambiguity(node, "shadowed module loader binding prevents complete local source analysis");
+        const directCall = ts6.isCallExpression(parent) && parent.expression === node;
+        const declaredName = (ts6.isVariableDeclaration(parent) || ts6.isParameter(parent)) && parent.name === node;
+        const propertyName = (ts6.isPropertyAccessExpression(parent) || ts6.isPropertyAssignment(parent)) && parent.name === node;
+        if (declaredName || ts6.isImportSpecifier(parent)) ambiguity(node, "shadowed module loader binding prevents complete local source analysis");
         else if (!directCall && !propertyName) ambiguity(node, "indirect module loader alias or escape prevents complete local source analysis");
       }
-      if (ts5.isIdentifier(node) && node.text === "createRequire") {
+      if (ts6.isIdentifier(node) && node.text === "createRequire") {
         const parent = node.parent;
-        if (!ts5.isImportSpecifier(parent) && !((ts5.isVariableDeclaration(parent) || ts5.isParameter(parent)) && parent.name === node)) {
+        if (!ts6.isImportSpecifier(parent) && !((ts6.isVariableDeclaration(parent) || ts6.isParameter(parent)) && parent.name === node)) {
           ambiguity(node, "indirect module loader factory prevents complete local source analysis");
         }
       }
-      if (ts5.isIdentifier(node) && (node.text === "globalThis" || node.text === "global" || node.text === "module")) {
+      if (ts6.isIdentifier(node) && (node.text === "globalThis" || node.text === "global" || node.text === "module")) {
         const parent = node.parent;
-        const declaredName = (ts5.isVariableDeclaration(parent) || ts5.isParameter(parent)) && parent.name === node;
+        const declaredName = (ts6.isVariableDeclaration(parent) || ts6.isParameter(parent)) && parent.name === node;
         if (!declaredName) {
-          if (ts5.isPropertyAccessExpression(parent) && parent.expression === node) {
+          if (ts6.isPropertyAccessExpression(parent) && parent.expression === node) {
             if (node.text !== "module" && parent.name.text === "Engine") ambiguity(parent, "indirect global Engine access prevents proving legacy timing/null behavior");
             else if (parent.name.text === "require" || parent.name.text === "createRequire") ambiguity(parent, "indirect module loader access prevents complete local source analysis");
             else if (node.text === "module" && parent.name.text !== "exports") ambiguity(parent, "indirect module loader or module escape prevents complete local source analysis");
-          } else if (ts5.isElementAccessExpression(parent) && parent.expression === node) {
+          } else if (ts6.isElementAccessExpression(parent) && parent.expression === node) {
             const key = parent.argumentExpression;
-            const literal = key && (ts5.isStringLiteral(key) || ts5.isNoSubstitutionTemplateLiteral(key)) ? key.text : void 0;
-            if (node.text !== "module" && literal === "Engine") ambiguity(parent, "computed global Engine access prevents proving legacy timing/null behavior");
-            else if (literal === "require" || literal === "createRequire" || node.text === "module") ambiguity(parent, "indirect module loader access prevents complete local source analysis");
-            else if (literal === void 0) ambiguity(parent, "computed global access may hide Engine or a module loader");
+            const literal2 = key && (ts6.isStringLiteral(key) || ts6.isNoSubstitutionTemplateLiteral(key)) ? key.text : void 0;
+            if (node.text !== "module" && literal2 === "Engine") ambiguity(parent, "computed global Engine access prevents proving legacy timing/null behavior");
+            else if (literal2 === "require" || literal2 === "createRequire" || node.text === "module") ambiguity(parent, "indirect module loader access prevents complete local source analysis");
+            else if (literal2 === void 0) ambiguity(parent, "computed global access may hide Engine or a module loader");
           } else ambiguity(node, `indirect ${node.text} escape may hide Engine or a module loader`);
         }
       }
-      if (ts5.isImportSpecifier(node) && node.propertyName?.text === "Engine" && node.name.text !== "Engine") {
-        report.ambiguities.push(`${relative4(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: imported Engine alias prevents proving legacy timing/null behavior`);
+      if (ts6.isImportSpecifier(node) && node.propertyName?.text === "Engine" && node.name.text !== "Engine") {
+        report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: imported Engine alias prevents proving legacy timing/null behavior`);
       }
-      if (ts5.isExportSpecifier(node) && (node.propertyName?.text ?? node.name.text) === "Engine") {
-        report.ambiguities.push(`${relative4(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: exported Engine escape prevents proving legacy timing/null behavior`);
+      if (ts6.isExportSpecifier(node) && (node.propertyName?.text ?? node.name.text) === "Engine") {
+        report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: exported Engine escape prevents proving legacy timing/null behavior`);
       }
-      if (ts5.isBindingElement(node) && node.propertyName && ts5.isIdentifier(node.propertyName) && node.propertyName.text === "Engine") {
-        report.ambiguities.push(`${relative4(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: destructured Engine alias prevents proving legacy timing/null behavior`);
+      if (ts6.isBindingElement(node) && node.propertyName && ts6.isIdentifier(node.propertyName) && node.propertyName.text === "Engine") {
+        report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: destructured Engine alias prevents proving legacy timing/null behavior`);
       }
-      if (ts5.isParameter(node) && hooks.size && ts5.isObjectBindingPattern(node.name) && node.name.elements.some((e) => namespaces.has(e.propertyName && ts5.isIdentifier(e.propertyName) ? e.propertyName.text : e.name.getText(source)))) {
-        report.ambiguities.push(`${relative4(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: destructured ctx hook namespace alias prevents proving callback timing`);
+      if (ts6.isParameter(node) && hooks.size && ts6.isObjectBindingPattern(node.name) && node.name.elements.some((e) => namespaces.has(e.propertyName && ts6.isIdentifier(e.propertyName) ? e.propertyName.text : e.name.getText(source)))) {
+        report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: destructured ctx hook namespace alias prevents proving callback timing`);
       }
-      if (ts5.isIdentifier(node) && (node.text === "Engine" || node.text === "ctx")) {
+      if (ts6.isIdentifier(node) && (node.text === "Engine" || node.text === "ctx")) {
         const parent = node.parent;
-        const declaration = (ts5.isVariableDeclaration(parent) || ts5.isParameter(parent) || ts5.isBindingElement(parent)) && parent.name === node;
-        const importName = ts5.isImportSpecifier(parent) || ts5.isImportClause(parent) || ts5.isNamespaceImport(parent) || ts5.isExportSpecifier(parent);
-        const propertyName = (ts5.isPropertyAccessExpression(parent) || ts5.isPropertyAssignment(parent)) && parent.name === node;
-        if (!declaration && !importName && !propertyName && !(ts5.isElementAccessExpression(parent) && parent.expression === node)) {
+        const declaration = (ts6.isVariableDeclaration(parent) || ts6.isParameter(parent) || ts6.isBindingElement(parent)) && parent.name === node;
+        const importName = ts6.isImportSpecifier(parent) || ts6.isImportClause(parent) || ts6.isNamespaceImport(parent) || ts6.isExportSpecifier(parent);
+        const propertyName = (ts6.isPropertyAccessExpression(parent) || ts6.isPropertyAssignment(parent)) && parent.name === node;
+        if (!declaration && !importName && !propertyName && !(ts6.isElementAccessExpression(parent) && parent.expression === node)) {
           let indirect = false;
-          if (ts5.isPropertyAccessExpression(parent) && parent.expression === node) {
-            if (node.text === "Engine") indirect = !(["call", "hook"].includes(parent.name.text) && ts5.isCallExpression(parent.parent) && parent.parent.expression === parent);
+          if (ts6.isPropertyAccessExpression(parent) && parent.expression === node) {
+            if (node.text === "Engine") indirect = !(["call", "hook"].includes(parent.name.text) && ts6.isCallExpression(parent.parent) && parent.parent.expression === parent);
             else if (namespaces.has(parent.name.text)) {
               const member = parent.parent;
-              indirect = !(ts5.isPropertyAccessExpression(member) && member.expression === parent && hooks.get(member.name.text) === parent.name.text && ts5.isCallExpression(member.parent) && member.parent.expression === member);
+              indirect = !(ts6.isPropertyAccessExpression(member) && member.expression === parent && hooks.get(member.name.text) === parent.name.text && ts6.isCallExpression(member.parent) && member.parent.expression === member);
             }
           } else indirect = node.text === "Engine" || hooks.size > 0;
-          if (indirect) report.ambiguities.push(`${relative4(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: indirect ${node.text} alias or escape prevents proving legacy timing/null behavior`);
+          if (indirect) report.ambiguities.push(`${relative5(report.package, file)}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: indirect ${node.text} alias or escape prevents proving legacy timing/null behavior`);
         }
       }
-      if (ts5.isElementAccessExpression(node) && ts5.isIdentifier(node.expression) && node.expression.text === "Engine") {
+      if (ts6.isElementAccessExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === "Engine") {
         const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
-        report.ambiguities.push(`${relative4(report.package, file)}:${line}: computed Engine lookup prevents proving timing/null behavior`);
+        report.ambiguities.push(`${relative5(report.package, file)}:${line}: computed Engine lookup prevents proving timing/null behavior`);
       }
-      if (ts5.isElementAccessExpression(node) && hooks.size && (ts5.isIdentifier(node.expression) && node.expression.text === "ctx" || ts5.isPropertyAccessExpression(node.expression) && ts5.isIdentifier(node.expression.expression) && node.expression.expression.text === "ctx")) {
+      if (ts6.isElementAccessExpression(node) && hooks.size && (ts6.isIdentifier(node.expression) && node.expression.text === "ctx" || ts6.isPropertyAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === "ctx")) {
         const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
-        report.ambiguities.push(`${relative4(report.package, file)}:${line}: computed ctx hook lookup prevents proving callback timing`);
+        report.ambiguities.push(`${relative5(report.package, file)}:${line}: computed ctx hook lookup prevents proving callback timing`);
       }
-      if (ts5.isPropertyAccessExpression(node) && ts5.isIdentifier(node.expression) && node.expression.text === "Engine" && ["call", "hook"].includes(node.name.text) && !(ts5.isCallExpression(node.parent) && node.parent.expression === node)) {
+      if (ts6.isPropertyAccessExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === "Engine" && ["call", "hook"].includes(node.name.text) && !(ts6.isCallExpression(node.parent) && node.parent.expression === node)) {
         const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
-        report.ambiguities.push(`${relative4(report.package, file)}:${line}: indirect Engine.${node.name.text} lookup prevents proving timing/null behavior`);
+        report.ambiguities.push(`${relative5(report.package, file)}:${line}: indirect Engine.${node.name.text} lookup prevents proving timing/null behavior`);
       }
-      if (ts5.isCallExpression(node)) {
+      if (ts6.isCallExpression(node)) {
         const expr = node.expression;
         let kind;
-        if (ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression) && expr.expression.text === "Engine" && ["call", "hook"].includes(expr.name.text)) kind = expr.name.text;
+        if (ts6.isPropertyAccessExpression(expr) && ts6.isIdentifier(expr.expression) && expr.expression.text === "Engine" && ["call", "hook"].includes(expr.name.text)) kind = expr.name.text;
         if (kind) {
           const arg = node.arguments[0];
           const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
-          if (!arg || !ts5.isStringLiteral(arg) && !ts5.isNoSubstitutionTemplateLiteral(arg)) report.ambiguities.push(`${relative4(report.package, file)}:${line}: dynamic Engine.${kind} reference prevents proving timing/null behavior`);
+          if (!arg || !ts6.isStringLiteral(arg) && !ts6.isNoSubstitutionTemplateLiteral(arg)) report.ambiguities.push(`${relative5(report.package, file)}:${line}: dynamic Engine.${kind} reference prevents proving timing/null behavior`);
           else {
             const name = arg.text;
-            if (!(kind === "call" ? calls.has(name) : hooks.has(name))) report.ambiguities.push(`${relative4(report.package, file)}:${line}: Engine.${kind} references undeclared ${name}`);
+            if (!(kind === "call" ? calls.has(name) : hooks.has(name))) report.ambiguities.push(`${relative5(report.package, file)}:${line}: Engine.${kind} references undeclared ${name}`);
             else report.sourceReferences.push({ file, line, kind: `Engine.${kind}`, name, manualEdit: `review ${kind} lookup, null behavior and callback timing for ${name}` });
           }
         }
-        if (ts5.isPropertyAccessExpression(expr) && ts5.isPropertyAccessExpression(expr.expression) && ts5.isIdentifier(expr.expression.expression) && expr.expression.expression.text === "ctx") {
+        if (ts6.isPropertyAccessExpression(expr) && ts6.isPropertyAccessExpression(expr.expression) && ts6.isIdentifier(expr.expression.expression) && expr.expression.expression.text === "ctx") {
           const ns = expr.expression.name.text;
           const name = expr.name.text;
           if (hooks.get(name) === ns) report.sourceReferences.push({ file, line: source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1, kind: "ctx hook", name, manualEdit: `review callback timing and replace ctx.${ns}.${name} manually` });
         }
       }
-      ts5.forEachChild(node, visit);
+      ts6.forEachChild(node, visit);
     };
     visit(source);
   }
 }
 function analyzeV1Migration(pluginDir, options = {}) {
   const dir = resolve26(pluginDir);
-  const destination = join35(dir, "gamedata", "functions.jsonc");
+  const destination = join36(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(join35(dir, "package.json"), readFileSync30(join35(dir, "package.json"), "utf8"));
+    pkg = parseFunctionFile(join36(dir, "package.json"), readFileSync31(join36(dir, "package.json"), "utf8"));
   } catch (e) {
     report.ambiguities.push(`package.json: ${e.message}`);
     return report;
@@ -14460,7 +14690,7 @@ function analyzeV1Migration(pluginDir, options = {}) {
   }
   let gd;
   try {
-    gd = parseFunctionFile(input, readFileSync30(input, "utf8"));
+    gd = parseFunctionFile(input, readFileSync31(input, "utf8"));
   } catch (e) {
     report.ambiguities.push(`gamedata: ${e.message}`);
     return report;
@@ -14560,10 +14790,10 @@ function analyzeV1Migration(pluginDir, options = {}) {
     }
   }
   report.output = author;
-  report.generatedDeclarations = ["gamedata.d.ts", "hooks.d.ts"].map((n3) => join35(dir, ".s2script", n3)).filter(existsSync20);
+  report.generatedDeclarations = ["gamedata.d.ts", "hooks.d.ts"].map((n3) => join36(dir, ".s2script", n3)).filter(existsSync21);
   for (const file of report.generatedDeclarations) {
     try {
-      report.generatedDeclarationHashes[file] = createHash5("sha256").update(readFileSync30(file)).digest("hex");
+      report.generatedDeclarationHashes[file] = createHash6("sha256").update(readFileSync31(file)).digest("hex");
     } catch (e) {
       report.ambiguities.push(`${file}: generated declaration could not be read: ${e.message}`);
     }
@@ -14582,7 +14812,7 @@ function migrateV1Package(pluginDir, options = {}) {
   const report = analyzeV1Migration(pluginDir, options);
   if (report.ambiguities.length || !report.output) return report;
   const dest = report.destination;
-  const temp = join35(dirname10(dest), `.functions.jsonc.${process.pid}.${randomUUID()}.tmp`);
+  const temp = join36(dirname10(dest), `.functions.jsonc.${process.pid}.${randomUUID()}.tmp`);
   try {
     mkdirSync11(dirname10(dest), { recursive: true });
     const fd2 = openSync(temp, "wx", 384);
@@ -14604,7 +14834,7 @@ function migrateV1Package(pluginDir, options = {}) {
     report.publication = void 0;
     report.ambiguities.push(`${dest}: publication failed: ${e.message}`);
   } finally {
-    if (existsSync20(temp)) unlinkSync(temp);
+    if (existsSync21(temp)) unlinkSync(temp);
   }
   return report;
 }
@@ -14623,9 +14853,9 @@ async function run11(argv2) {
 }
 
 // src/commands/pack.ts
-import { createHash as createHash6 } from "node:crypto";
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync24 } from "node:fs";
-import { join as join36, resolve as resolve27 } from "node:path";
+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";
 function formatBytes(n3) {
   if (n3 < 1e3) return `${n3}B`;
   if (n3 < 1e3 * 1e3) return `${(n3 / 1e3).toFixed(1)}kB`;
@@ -14633,9 +14863,9 @@ function formatBytes(n3) {
 }
 function packPackage(dir) {
   const absDir = resolve27(dir);
-  const pkg = JSON.parse(readFileSync31(join36(absDir, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync32(join37(absDir, "package.json"), "utf8"));
   if (typeof pkg.name !== "string" || typeof pkg.version !== "string") {
-    throw new Error(`${join36(absDir, "package.json")}: "name" and "version" are required to pack`);
+    throw new Error(`${join37(absDir, "package.json")}: "name" and "version" are required to pack`);
   }
   const pack = packSourceTarball(absDir, pkg);
   return {
@@ -14647,8 +14877,8 @@ function packPackage(dir) {
       filename: tarballFilename(pkg.name, pkg.version),
       size: pack.tarball.length,
       unpackedSize: pack.unpackedSize,
-      shasum: createHash6("sha1").update(pack.tarball).digest("hex"),
-      integrity: `sha512-${createHash6("sha512").update(pack.tarball).digest("base64")}`,
+      shasum: createHash7("sha1").update(pack.tarball).digest("hex"),
+      integrity: `sha512-${createHash7("sha512").update(pack.tarball).digest("base64")}`,
       files: pack.files,
       entryCount: pack.files.length
     }
@@ -14693,8 +14923,8 @@ async function run12(argv2) {
 }
 
 // src/commands/server.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join37, resolve as resolve28 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join38, resolve as resolve28 } from "node:path";
 async function run13(argv2) {
   const [sub, dir] = positionals(argv2, ["--registry", "--name"]);
   if (sub !== "init") {
@@ -14703,7 +14933,7 @@ async function run13(argv2) {
   }
   const root = dir ? resolve28(dir) : findAddonRoot(".") ?? resolve28("addons", "s2script");
   try {
-    if (!existsSync21(join37(root, "plugins"))) {
+    if (!existsSync22(join38(root, "plugins"))) {
       throw new Error(`${root} has no plugins/ directory \u2014 pass your addons/s2script directory`);
     }
     const report = await serverInit({
@@ -14715,7 +14945,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 ${join37(root, "plugins.json")} and plugins-lock.json \u2014 ${report.managed.length} managed, ${report.unmanaged.length} left as they are`
+      `wrote ${join38(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));