@s2script/sdk 0.0.1 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,1280 @@
+#!/usr/bin/env node
+
+// src/build.ts
+import * as esbuild from "esbuild";
+import AdmZip from "adm-zip";
+import { readFileSync as readFileSync4, mkdirSync } from "node:fs";
+import { resolve as resolve4, join as join4 } from "node:path";
+
+// src/typecheck/typecheck.ts
+import ts from "typescript";
+import { existsSync as existsSync2, readdirSync, readFileSync, writeFileSync, rmSync, mkdtempSync } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { tmpdir } from "node:os";
+
+// src/packages-resolve.ts
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function isPackagesDir(dir) {
+  const abs = resolve(dir);
+  return existsSync(join(abs, "sdk", "globals.d.ts")) || existsSync(join(abs, "sdk", "entity.d.ts"));
+}
+function findPackagesDirNearCli(fromCliUrl = import.meta.url) {
+  const start = dirname(fileURLToPath(fromCliUrl));
+  for (const rel of ["../..", "../../.."]) {
+    const candidate = join(start, rel);
+    if (isPackagesDir(candidate)) return resolve(candidate);
+  }
+  return void 0;
+}
+function resolvePackagesDir(opts) {
+  if (opts?.explicit) {
+    const abs = resolve(opts.explicit);
+    if (!isPackagesDir(abs)) {
+      throw new Error(`packages dir does not look like @s2script stubs: ${abs}`);
+    }
+    return abs;
+  }
+  const env = process.env.S2SCRIPT_PACKAGES_DIR;
+  if (env) {
+    const abs = resolve(env);
+    if (!isPackagesDir(abs)) {
+      throw new Error(`S2SCRIPT_PACKAGES_DIR does not look like @s2script stubs: ${abs}`);
+    }
+    return abs;
+  }
+  const nearCli = findPackagesDirNearCli(opts?.fromCliUrl);
+  if (nearCli) return nearCli;
+  if (opts?.pluginDir) {
+    const nm = join(resolve(opts.pluginDir), "node_modules", "@s2script");
+    if (isPackagesDir(nm)) return nm;
+  }
+  throw new Error(
+    "cannot resolve @s2script/sdk/* types: no packages dir found.\n  Install `@s2script/sdk` in the plugin (npm i -D @s2script/sdk),\n  or set S2SCRIPT_PACKAGES_DIR / pass --packages-dir."
+  );
+}
+
+// src/typecheck/typecheck.ts
+function localDeclarationFiles(pluginDir) {
+  const srcDir = join2(pluginDir, "src");
+  if (!existsSync2(srcDir)) return [];
+  return readdirSync(srcDir).filter((f) => f.endsWith(".d.ts")).map((f) => join2(srcDir, f));
+}
+function declaredModules(dtsFiles) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of dtsFiles) {
+    const body = readFileSync(f, "utf8");
+    for (const m of body.matchAll(/declare\s+module\s+["']([^"']+)["']/g)) out.add(m[1]);
+  }
+  return out;
+}
+function typecheckPlugin(pluginDir, opts) {
+  const absDir = resolve2(pluginDir);
+  const packagesDir = opts?.packagesDir ? resolve2(opts.packagesDir) : resolvePackagesDir({ pluginDir: absDir });
+  const pkg = JSON.parse(readFileSync(join2(absDir, "package.json"), "utf8"));
+  const s2 = pkg.s2script ?? {};
+  const entryRel = s2.main ?? pkg.main;
+  if (!entryRel) throw new Error(`typecheckPlugin: no entry point in ${join2(absDir, "package.json")}`);
+  const entry = resolve2(absDir, entryRel);
+  const isAlwaysResolved = (d) => d.startsWith("@s2script/sdk/") || d === "@s2script/cs2" || d.startsWith("@s2script/cs2/");
+  const localDts = localDeclarationFiles(absDir);
+  const locallyDeclared = declaredModules(localDts);
+  const deps = [
+    ...Object.keys(s2.pluginDependencies ?? {}),
+    ...Object.keys(s2.optionalPluginDependencies ?? {})
+    // Never stub a module the plugin declares itself — a shorthand `declare module "X";` and a
+    // full `declare module "X" { … }` for the same X collide.
+  ].filter((d) => !isAlwaysResolved(d) && !locallyDeclared.has(d));
+  const options = {
+    strict: true,
+    noEmit: true,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    module: ts.ModuleKind.ESNext,
+    target: ts.ScriptTarget.ES2020,
+    lib: ["lib.es2020.d.ts"],
+    types: [],
+    baseUrl: packagesDir,
+    paths: {
+      // Builtins are `@s2script/sdk/<cap>` → packages/sdk/<cap>.d.ts. The `@s2script/*` fallback
+      // now serves only @s2script/cs2 → packages/cs2/index.d.ts (the legacy per-package builtin
+      // dirs are deleted). tsc picks the longest matching prefix, so `@s2script/sdk/*` wins for
+      // sdk imports.
+      "@s2script/sdk/*": ["sdk/*.d.ts"],
+      "@s2script/*": ["*/index.d.ts"]
+    },
+    skipLibCheck: true
+  };
+  const rootNames = [entry, join2(packagesDir, "sdk", "globals.d.ts"), ...localDts];
+  const tmp = mkdtempSync(join2(tmpdir(), "s2tc-"));
+  try {
+    if (deps.length) {
+      const stub = join2(tmp, "ambient.d.ts");
+      writeFileSync(stub, deps.map((d) => `declare module ${JSON.stringify(d)};`).join("\n") + "\n");
+      rootNames.push(stub);
+    }
+    const program = ts.createProgram(rootNames, options);
+    const diags = [
+      ...program.getSyntacticDiagnostics(),
+      ...program.getSemanticDiagnostics(),
+      ...program.getGlobalDiagnostics()
+    ];
+    const out = diags.map((d) => {
+      let file = "?", line = 0, col = 0;
+      if (d.file && d.start !== void 0) {
+        const lc = d.file.getLineAndCharacterOfPosition(d.start);
+        file = d.file.fileName;
+        line = lc.line + 1;
+        col = lc.character + 1;
+      }
+      return { file, line, col, code: d.code, message: ts.flattenDiagnosticMessageText(d.messageText, "\n") };
+    });
+    return { ok: out.length === 0, diagnostics: out };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function formatDiagnostics(diags) {
+  return diags.map((d) => `  ${d.file}:${d.line}:${d.col} \u2014 TS${d.code}: ${d.message}`).join("\n");
+}
+
+// src/config-validate.ts
+function validateConfigBlock(config) {
+  const errs = [];
+  if (config == null) return errs;
+  if (typeof config !== "object" || Array.isArray(config)) return ["s2script.config must be an object"];
+  for (const [key, raw] of Object.entries(config)) {
+    if (typeof raw !== "object" || raw === null) {
+      errs.push(`config '${key}': must be { type, default }`);
+      continue;
+    }
+    const decl = raw;
+    const t = decl.type, d = decl.default;
+    if (t !== "string" && t !== "int" && t !== "float" && t !== "bool") {
+      errs.push(`config '${key}': unknown type ${JSON.stringify(t)} (want string|int|float|bool)`);
+      continue;
+    }
+    const ok = t === "string" && typeof d === "string" || t === "int" && typeof d === "number" && Number.isInteger(d) || t === "float" && typeof d === "number" || t === "bool" && typeof d === "boolean";
+    if (!ok) errs.push(`config '${key}': default ${JSON.stringify(d)} does not match type '${t}'`);
+  }
+  return errs;
+}
+
+// src/publish-gate.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "node:fs";
+import { join as join3, resolve as resolve3 } from "node:path";
+function hasPublishes(publishes) {
+  if (publishes == null) return false;
+  if (typeof publishes === "string") return publishes.trim().length > 0;
+  if (typeof publishes === "object") return Object.keys(publishes).length > 0;
+  return false;
+}
+function assertPublishesTypes(pkg, pluginDir) {
+  const publishes = pkg.s2script?.publishes;
+  if (!hasPublishes(publishes)) {
+    return { ok: true, typesPath: null };
+  }
+  const typesRel = pkg.types ?? pkg.typings;
+  if (!typesRel || typeof typesRel !== "string") {
+    return {
+      ok: false,
+      error: 'publishes is set but "types" is missing \u2014 add api.d.ts and set "types": "api.d.ts"'
+    };
+  }
+  if (!typesRel.endsWith(".d.ts")) {
+    return {
+      ok: false,
+      error: `published API must be a .d.ts file (got ${JSON.stringify(typesRel)})`
+    };
+  }
+  const typesPath = resolve3(pluginDir, typesRel);
+  if (!existsSync3(typesPath)) {
+    return { ok: false, error: `types file not found: ${typesRel}` };
+  }
+  const st = statSync(typesPath);
+  if (!st.isFile() || st.size === 0) {
+    return { ok: false, error: `types file is empty or not a file: ${typesRel}` };
+  }
+  const body = readFileSync2(typesPath, "utf8").trim();
+  if (!body) {
+    return { ok: false, error: `types file is empty: ${typesRel}` };
+  }
+  return { ok: true, typesPath };
+}
+
+// src/publishes.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync3 } from "node:fs";
+function expandPublishes(authored, pkgName, pkgVersion) {
+  if (authored === void 0 || authored === null) return {};
+  if (typeof authored === "string") {
+    if (authored.trim() !== "self") {
+      throw new Error(
+        `publishes: the only valid string form is "self" (got ${JSON.stringify(authored)}); use the map form to publish a differently-named contract`
+      );
+    }
+    return { [pkgName]: pkgVersion };
+  }
+  if (typeof authored !== "object") {
+    throw new Error(`publishes must be "self" or an object (got ${typeof authored})`);
+  }
+  const out = {};
+  for (const [iface, range] of Object.entries(authored)) {
+    if (typeof range !== "string") {
+      throw new Error(`publishes[${JSON.stringify(iface)}] must be a version range string`);
+    }
+    out[iface] = range;
+  }
+  return out;
+}
+function hashContract(typesPath) {
+  return createHash("sha256").update(readFileSync3(typesPath)).digest("hex");
+}
+var CONCRETE_SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+function isConcreteVersion(v) {
+  return CONCRETE_SEMVER.test(v.trim());
+}
+function derivePublishes(authored, pkgName, pkgVersion, typesPath) {
+  const expanded = expandPublishes(authored, pkgName, pkgVersion);
+  const names = Object.keys(expanded);
+  if (names.length === 0) return {};
+  if (names.length > 1) {
+    throw new Error(
+      `publishes declares ${names.length} interfaces (${names.join(", ")}) but a plugin ships a single "types" contract, so they would all carry the SAME typesSha256 \u2014 a hash that cannot say which contract is which. Publish one interface per plugin (a per-interface "types" map is not supported).`
+    );
+  }
+  if (typesPath === null) {
+    throw new Error(
+      `publishes is set but no contract .d.ts was resolved \u2014 set "types": "api.d.ts" in package.json`
+    );
+  }
+  for (const [iface, v] of Object.entries(expanded)) {
+    if (!isConcreteVersion(v)) {
+      throw new Error(
+        `publishes[${JSON.stringify(iface)}] = ${JSON.stringify(v)} is a RANGE. Resolving a range against a published contract requires the registry (design spec \xA74.6, \xA710 \u2014 not yet implemented). Use a concrete version for a contract you ship yourself, or "self".`
+      );
+    }
+  }
+  const typesSha256 = hashContract(typesPath);
+  const out = {};
+  for (const name of names) {
+    out[name] = { version: expanded[name].trim(), typesSha256 };
+  }
+  return out;
+}
+
+// src/build.ts
+async function buildPlugin(dir, packagesDir) {
+  const absDir = resolve4(dir);
+  const pkgPath = join4(absDir, "package.json");
+  const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+  const gate = assertPublishesTypes(pkg, absDir);
+  if (!gate.ok) {
+    throw new Error(`publish gate failed: ${gate.error}`);
+  }
+  const s2 = pkg.s2script ?? {};
+  const derivedPublishes = derivePublishes(s2.publishes, pkg.name, pkg.version, gate.typesPath);
+  const tc = typecheckPlugin(absDir, packagesDir !== void 0 ? { packagesDir } : void 0);
+  if (!tc.ok) {
+    throw new Error(`typecheck failed (${tc.diagnostics.length} error(s)):
+${formatDiagnostics(tc.diagnostics)}`);
+  }
+  const { name, version } = pkg;
+  const apiVersion = s2.apiVersion ?? "";
+  const pluginDependencies = s2.pluginDependencies ?? {};
+  const optionalPluginDependencies = s2.optionalPluginDependencies ?? {};
+  const config = s2.config ?? void 0;
+  if (config !== void 0) {
+    const cfgErrs = validateConfigBlock(config);
+    if (cfgErrs.length) throw new Error(`invalid s2script.config:
+  ${cfgErrs.join("\n  ")}`);
+  }
+  const external = Array.from(/* @__PURE__ */ new Set([
+    "@s2script/*",
+    ...Object.keys(pluginDependencies),
+    ...Object.keys(optionalPluginDependencies)
+  ]));
+  const entryRelative = s2.main ?? pkg.main;
+  if (!entryRelative) {
+    throw new Error(
+      `buildPlugin: no entry point found in ${pkgPath} (set s2script.main or main)`
+    );
+  }
+  const entryPoint = join4(absDir, entryRelative);
+  const result = await esbuild.build({
+    entryPoints: [entryPoint],
+    bundle: true,
+    platform: "neutral",
+    format: "cjs",
+    external,
+    target: "es2020",
+    write: false
+  });
+  const pluginJs = result.outputFiles[0].text;
+  const manifest = {
+    id: name,
+    version,
+    apiVersion,
+    // <-- MUST be "apiVersion" to match #[serde(rename = "apiVersion")]
+    pluginDependencies,
+    optionalPluginDependencies
+  };
+  if (Object.keys(derivedPublishes).length > 0) {
+    manifest.publishes = derivedPublishes;
+  }
+  if (config !== void 0) manifest.config = config;
+  const zip = new AdmZip();
+  zip.addFile("manifest.json", Buffer.from(JSON.stringify(manifest, null, 2)));
+  zip.addFile("plugin.js", Buffer.from(pluginJs));
+  if (gate.typesPath !== null && Object.keys(derivedPublishes).length > 0) {
+    const contract = readFileSync4(gate.typesPath);
+    for (const iface of Object.keys(derivedPublishes)) {
+      const safe = iface.replace(/[^a-zA-Z0-9._-]/g, "_");
+      zip.addFile(`types/${safe}.d.ts`, contract);
+    }
+  }
+  const sanitizedId = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const outDir = join4(absDir, "dist");
+  mkdirSync(outDir, { recursive: true });
+  const outPath = join4(outDir, `${sanitizedId}.s2sp`);
+  zip.writeZip(outPath);
+  return outPath;
+}
+
+// src/schemagen/gen.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/schemagen/model.ts
+var READ = {
+  f32: "readFloat32",
+  bool: "readBool",
+  i8: "readInt8",
+  i16: "readInt16",
+  i32: "readInt32",
+  u8: "readUInt8",
+  u16: "readUInt16",
+  u32: "readUInt32",
+  handle: "readHandle",
+  u64: "readUInt64",
+  i64: "readInt64",
+  f64: "readFloat64",
+  str: "readString",
+  vector: "readFloats",
+  qangle: "readFloats"
+};
+var WRITE = {
+  f32: "writeFloat32",
+  bool: "writeBool",
+  i8: "writeInt8",
+  i16: "writeInt16",
+  i32: "writeInt32",
+  u8: "writeUInt8",
+  u16: "writeUInt16",
+  u32: "writeUInt32"
+};
+var TSTYPE = {
+  f32: "number | null",
+  bool: "boolean | null",
+  i8: "number | null",
+  i16: "number | null",
+  i32: "number | null",
+  u8: "number | null",
+  u16: "number | null",
+  u32: "number | null",
+  handle: "EntityRef | null",
+  u64: "string | null",
+  i64: "string | null",
+  f64: "number | null",
+  str: "string | null",
+  vector: "Vector | null",
+  qangle: "QAngle | null"
+};
+var ATOMIC = {
+  float32: { k: "f32", w: true },
+  bool: { k: "bool", w: true },
+  int8: { k: "i8", w: true },
+  int16: { k: "i16", w: true },
+  int32: { k: "i32", w: true },
+  uint8: { k: "u8", w: true },
+  uint16: { k: "u16", w: true },
+  uint32: { k: "u32", w: true },
+  uint64: { k: "u64", w: false },
+  int64: { k: "i64", w: false },
+  float64: { k: "f64", w: false }
+  // no narrow 64-bit writers
+};
+var VEC = { Vector: "vector", VectorWS: "vector", QAngle: "qangle" };
+var VEC_INFO = {
+  vector: { cls: "Vector", count: 3 },
+  qangle: { cls: "QAngle", count: 3 }
+};
+var KNOWN_TAGS = /* @__PURE__ */ new Set(["i", "n", "b", "h", "fl", "f", "u", "e", "p", "a", "v", "vec", "ang", "q", "sz", "isz", "ch", "clr", "un"]);
+function idiomaticName(raw) {
+  const s = raw.replace(/^m_/, "");
+  const m = s.match(/^([a-z]+)([A-Z].*)$/);
+  const core = m && KNOWN_TAGS.has(m[1]) ? m[2] : s;
+  return core.charAt(0).toLowerCase() + core.slice(1);
+}
+function classifyField(type) {
+  if (type.kind === "handle") return { accessorKind: "handle", writable: false };
+  if (type.kind === "atomic") {
+    const vk = VEC[type.name ?? ""];
+    if (vk) return { accessorKind: vk, writable: false };
+    const m = ATOMIC[type.name ?? ""];
+    if (m) return { accessorKind: m.k, writable: m.w };
+    return { skip: `atomic '${type.name}' is not a scalar (string/vector/compound)` };
+  }
+  if (type.kind === "unknown") {
+    const cm = (type.name ?? "").match(/^char\[(\d+)\]$/);
+    if (cm) return { accessorKind: "str", writable: false, strLen: parseInt(cm[1], 10) };
+    return { skip: `unmapped 'unknown' type '${type.name ?? ""}'` };
+  }
+  if (type.kind === "enum") return { skip: "enum byte-width absent from catalog (deferred)" };
+  if (type.kind === "class") return { skip: `embedded class '${type.name ?? ""}' deferred` };
+  if (type.kind === "ptr") return { skip: "raw pointer" };
+  return { skip: `unmapped kind '${type.kind}'` };
+}
+function flattenedFields(model, className) {
+  const byName = new Map(model.classes.map((c) => [c.className, c]));
+  const chain = [];
+  let cur = className;
+  while (cur && byName.has(cur)) {
+    const c = byName.get(cur);
+    chain.unshift(c);
+    cur = c.parent;
+  }
+  return chain.flatMap((c) => c.ownFields);
+}
+function buildModel(catalog, requested) {
+  const inClosure = /* @__PURE__ */ new Set();
+  for (const start of requested) {
+    if (!catalog[start]) throw new Error(`gen-schema: requested class '${start}' is not in the catalog`);
+    let cur = start;
+    while (cur && catalog[cur] && !inClosure.has(cur)) {
+      inClosure.add(cur);
+      cur = catalog[cur].parent;
+    }
+  }
+  const depth = (c) => {
+    let d = 0, cur = c;
+    while (cur && catalog[cur]?.parent && inClosure.has(catalog[cur].parent)) {
+      d++;
+      cur = catalog[cur].parent;
+    }
+    return d;
+  };
+  const ordered = [...inClosure].sort((a, b) => depth(a) - depth(b) || (a < b ? -1 : a > b ? 1 : 0));
+  const classes = ordered.map((className) => {
+    const parent = catalog[className].parent;
+    const ownFields = [];
+    const skipped = [];
+    for (const f of catalog[className].fields) {
+      const c = classifyField(f.type);
+      if ("skip" in c) {
+        skipped.push({ className, rawName: f.name, reason: c.skip });
+        continue;
+      }
+      ownFields.push({ propName: idiomaticName(f.name), rawName: f.name, declaringClass: className, accessorKind: c.accessorKind, writable: c.writable, strLen: c.strLen });
+    }
+    return { className, parent: parent && inClosure.has(parent) ? parent : null, ownFields, skipped };
+  });
+  const byProp = /* @__PURE__ */ new Map();
+  for (const c of classes) for (const f of c.ownFields) {
+    (byProp.get(f.propName) ?? byProp.set(f.propName, []).get(f.propName)).push(f);
+  }
+  const collisions = [];
+  for (const [prop, fields] of byProp) {
+    const distinct = new Set(fields.map((f) => `${f.declaringClass}.${f.rawName}`));
+    if (distinct.size >= 2) {
+      for (const f of fields) f.propName = f.rawName;
+      collisions.push(`${prop} \u2190 ${[...distinct].sort().join(", ")}`);
+    }
+  }
+  collisions.sort();
+  return { classes, collisions };
+}
+
+// src/schemagen/emit-dts.ts
+var HEADER = "// GENERATED by `s2script gen-schema` from schema-catalog.json \u2014 DO NOT EDIT.";
+function emitDts(model) {
+  const names = new Set(model.classes.map((c) => c.className));
+  const out = [HEADER, 'import type { EntityRef } from "@s2script/sdk/entity";'];
+  const vecClasses = /* @__PURE__ */ new Set();
+  for (const c of model.classes) for (const f of c.ownFields) {
+    const vi = VEC_INFO[f.accessorKind];
+    if (vi) vecClasses.add(vi.cls);
+  }
+  if (vecClasses.size) out.push(`import type { ${[...vecClasses].sort().join(", ")} } from "@s2script/sdk/math";`);
+  out.push("");
+  for (const c of model.classes) {
+    const ext = c.parent && names.has(c.parent) ? ` extends ${c.parent}` : "";
+    out.push(`export interface ${c.className}${ext} {`);
+    for (const f of c.ownFields) {
+      const ro = f.writable ? "" : "readonly ";
+      out.push(`  ${ro}${f.propName}: ${TSTYPE[f.accessorKind]};`);
+    }
+    out.push("}", "");
+  }
+  return out.join("\n");
+}
+
+// src/schemagen/emit-js.ts
+var HEADER2 = "// GENERATED by `s2script gen-schema` from schema-catalog.json \u2014 DO NOT EDIT.";
+var S = JSON.stringify;
+function emitJs(model) {
+  const out = [HEADER2, "(function () {", "  var off = __s2_schema_offset;", "  var A = {};"];
+  const vecClasses = /* @__PURE__ */ new Set();
+  for (const c of model.classes) for (const f of flattenedFields(model, c.className)) {
+    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};`);
+  }
+  for (const c of model.classes) {
+    out.push(`  A[${S(c.className)}] = {`);
+    for (const f of flattenedFields(model, c.className)) {
+      const resolve7 = `off(${S(f.declaringClass)},${S(f.rawName)})`;
+      let entry;
+      if (f.accessorKind === "str") {
+        entry = `get: function () { return this.ref.readString(${resolve7}, ${f.strLen}); }`;
+      } else if (f.accessorKind === "u64" || f.accessorKind === "i64") {
+        entry = `get: function () { var v = this.ref.${READ[f.accessorKind]}(${resolve7}); return v === null ? null : v.toString(); }`;
+      } else if (VEC_INFO[f.accessorKind]) {
+        const vi = VEC_INFO[f.accessorKind];
+        entry = `get: function () { var a = this.ref.readFloats(${resolve7}, ${vi.count}); return a === null ? null : new ${vi.cls}(a[0], a[1], a[2]); }`;
+      } else {
+        entry = `get: function () { return this.ref.${READ[f.accessorKind]}(${resolve7}); }`;
+      }
+      if (f.writable) {
+        const wm = WRITE[f.accessorKind];
+        entry += `, set: function (v) { var o = ${resolve7}; if (this.ref.${wm}(o, v)) this.ref.notifyStateChanged(o); }`;
+      }
+      out.push(`    ${S(f.propName)}: { ${entry} },`);
+    }
+    out.push("  };");
+  }
+  out.push(
+    "  function applyAccessors(proto, className) {",
+    "    var defs = A[className]; if (!defs) return;",
+    "    for (var name in defs) {",
+    "      Object.defineProperty(proto, name, { get: defs[name].get, set: defs[name].set, enumerable: true, configurable: true });",
+    "    }",
+    "  }",
+    "  function wrap(className, ref) { var o = { ref: ref }; applyAccessors(o, className); return o; }",
+    "  globalThis.__s2pkg_cs2_schema = { applyAccessors: applyAccessors, wrap: wrap };",
+    "})();"
+  );
+  return out.join("\n");
+}
+
+// src/schemagen/gen.ts
+var CATALOG_PATH = "games/cs2/gamedata/schema-catalog.json";
+var LIST_PATH = "games/cs2/codegen-classes.json";
+var JS_OUT = "games/cs2/js/schema.generated.js";
+var DTS_OUT = "packages/cs2/schema.generated.d.ts";
+function runGenSchema(repoRoot, opts) {
+  const catalog = JSON.parse(readFileSync5(join5(repoRoot, CATALOG_PATH), "utf8"));
+  const list = JSON.parse(readFileSync5(join5(repoRoot, LIST_PATH), "utf8"));
+  const model = buildModel(catalog, list);
+  const dts = emitDts(model);
+  const js = emitJs(model);
+  const fields = model.classes.reduce((n, c) => n + c.ownFields.length, 0);
+  const skipped = model.classes.reduce((n, c) => n + c.skipped.length, 0);
+  const drift = [];
+  const files = [[JS_OUT, js], [DTS_OUT, dts]];
+  for (const [rel, content] of files) {
+    const abs = join5(repoRoot, rel);
+    if (opts.check) {
+      let cur = "";
+      try {
+        cur = readFileSync5(abs, "utf8");
+      } catch {
+      }
+      if (cur !== content) drift.push(rel);
+    } else {
+      writeFileSync2(abs, content);
+    }
+  }
+  if (model.collisions.length) console.error(`gen-schema: ${model.collisions.length} name collision(s) \u2192 raw fallback:
+  ` + model.collisions.join("\n  "));
+  for (const c of model.classes) if (c.skipped.length) console.error(`gen-schema: ${c.className}: skipped ${c.skipped.length} field(s)`);
+  return { classes: model.classes.length, fields, skipped, drift };
+}
+
+// src/eventgen/gen.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join6 } from "node:path";
+
+// src/eventgen/model.ts
+var TYPE_TO_GETTER = {
+  bool: "getBool",
+  float: "getFloat",
+  int: "getInt",
+  player: "getPlayerSlot",
+  string: "getString",
+  uint64: "getUint64"
+};
+function pascalCase(name) {
+  return name.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function buildEventModel(catalog) {
+  return Object.keys(catalog).sort().map((event) => {
+    const fields = catalog[event];
+    const byGetter = {
+      getBool: [],
+      getFloat: [],
+      getInt: [],
+      getPlayerSlot: [],
+      getString: [],
+      getUint64: []
+    };
+    for (const field of Object.keys(fields).sort()) {
+      const type = fields[field];
+      const getter = TYPE_TO_GETTER[type];
+      if (getter) byGetter[getter].push(field);
+    }
+    return {
+      event,
+      iface: pascalCase(event) + "Event",
+      byGetter
+    };
+  });
+}
+
+// src/eventgen/emit-dts.ts
+var HEADER3 = "// GENERATED by `s2script gen-events` from event-catalog.json \u2014 DO NOT EDIT.";
+var GETTER_RET = {
+  getBool: "boolean",
+  getFloat: "number",
+  getInt: "number",
+  getPlayerSlot: "number",
+  getString: "string",
+  getUint64: "string"
+};
+function emitEventDts(model) {
+  const out = [
+    HEADER3,
+    'import type { GameEvent, HookResultValue } from "@s2script/sdk/events";',
+    ""
+  ];
+  for (const { iface, byGetter } of model) {
+    out.push(`export interface ${iface} extends GameEvent {`);
+    for (const getter of Object.keys(byGetter)) {
+      const fields = byGetter[getter];
+      if (fields.length === 0) continue;
+      const keys = fields.map((f) => `"${f}"`).join(" | ");
+      const ret = GETTER_RET[getter];
+      out.push(`  ${getter}(key: ${keys}): ${ret};`);
+    }
+    out.push("}", "");
+  }
+  out.push("export interface GameEvents {");
+  for (const { event, iface } of model) {
+    out.push(`  ${event}: ${iface};`);
+  }
+  out.push("}", "");
+  out.push(
+    "export function on<K extends keyof GameEvents>(name: K, handler: (ev: GameEvents[K]) => void): void;",
+    "export function on(name: string, handler: (ev: GameEvent) => void): void;",
+    "export function onPre<K extends keyof GameEvents>(name: K, handler: (ev: GameEvents[K]) => HookResultValue | void): void;",
+    "export function onPre(name: string, handler: (ev: GameEvent) => HookResultValue | void): void;",
+    "export function fire<K extends keyof GameEvents>(name: K, fields?: Record<string, number | string | boolean | bigint>, dontBroadcast?: boolean): boolean;",
+    "export function fire(name: string, fields?: Record<string, number | string | boolean | bigint>, dontBroadcast?: boolean): boolean;"
+  );
+  return out.join("\n") + "\n";
+}
+
+// src/eventgen/gen.ts
+var CATALOG_PATH2 = "games/cs2/gamedata/event-catalog.json";
+var DTS_OUT2 = "packages/cs2/events.generated.d.ts";
+function runGenEvents(repoRoot, opts) {
+  const catalog = JSON.parse(readFileSync6(join6(repoRoot, CATALOG_PATH2), "utf8"));
+  const model = buildEventModel(catalog);
+  const dts = emitEventDts(model);
+  const drift = [];
+  const abs = join6(repoRoot, DTS_OUT2);
+  if (opts.check) {
+    let cur = "";
+    try {
+      cur = readFileSync6(abs, "utf8");
+    } catch {
+    }
+    if (cur !== dts) drift.push(DTS_OUT2);
+  } else {
+    writeFileSync3(abs, dts);
+  }
+  return { events: model.length, drift };
+}
+
+// src/navgen/gen.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+
+// src/navgen/model.ts
+var SUPPORTED_NAV_KINDS = /* @__PURE__ */ new Set([
+  "i8",
+  "i16",
+  "i32",
+  "u8",
+  "u16",
+  "u32",
+  "f32",
+  "bool",
+  "u64",
+  "i64",
+  "handle",
+  "vector",
+  "qangle"
+]);
+function buildNavModel(config, catalog) {
+  const targetClasses = [...new Set(config.map((e) => e.target))];
+  const schemaModel = buildModel(catalog, targetClasses);
+  const sorted = [...config].sort((a, b) => a.wrapper < b.wrapper ? -1 : a.wrapper > b.wrapper ? 1 : 0);
+  const wrappers = sorted.map((entry) => {
+    const all = flattenedFields(schemaModel, entry.target);
+    const fields = [];
+    const skippedKinds = [];
+    for (const f of all) {
+      if (SUPPORTED_NAV_KINDS.has(f.accessorKind)) {
+        fields.push(f);
+      } else {
+        skippedKinds.push({ propName: f.propName, accessorKind: f.accessorKind });
+      }
+    }
+    return {
+      wrapper: entry.wrapper,
+      prop: entry.prop,
+      source: entry.source,
+      target: entry.target,
+      path: entry.path,
+      fields,
+      skippedKinds
+    };
+  });
+  return { wrappers };
+}
+
+// src/navgen/emit-js.ts
+var HEADER4 = "// GENERATED by `s2script gen-nav` from nav-targets.json \u2014 DO NOT EDIT.";
+var S2 = JSON.stringify;
+var READ_VIA = {
+  f32: "readFloat32Via",
+  bool: "readBoolVia",
+  i8: "readInt8Via",
+  i16: "readInt16Via",
+  i32: "readInt32Via",
+  u8: "readUInt8Via",
+  u16: "readUInt16Via",
+  u32: "readUInt32Via"
+};
+function emitNavJs(model) {
+  const out = [HEADER4, "(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};`);
+  }
+  for (const w of model.wrappers) {
+    out.push(`  function ${w.wrapper}(root, path) { this.root = root; this.path = path; }`);
+    out.push(`  Object.defineProperties(${w.wrapper}.prototype, {`);
+    for (const f of w.fields) {
+      const resolve7 = `off(${S2(f.declaringClass)},${S2(f.rawName)})`;
+      let getter;
+      const kind = f.accessorKind;
+      if (kind === "u64") {
+        getter = `get: function () { var v = this.root.readUInt64Via(this.path, ${resolve7}); return v === null ? null : v.toString(); }`;
+      } else if (kind === "i64") {
+        getter = `get: function () { var v = this.root.readInt64Via(this.path, ${resolve7}); 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, ${resolve7}, ${vi.count}); return a === null ? null : new ${vi.cls}(a[0], a[1], a[2]); }`;
+      } else if (kind === "handle") {
+        getter = `get: function () { return this.root.readHandleVia(this.path, ${resolve7}); }`;
+      } else {
+        const method = READ_VIA[kind];
+        if (!method) continue;
+        getter = `get: function () { return this.root.${method}(this.path, ${resolve7}); }`;
+      }
+      out.push(`    ${S2(f.propName)}: { ${getter} },`);
+    }
+    out.push("  });");
+  }
+  const bySource = /* @__PURE__ */ new Map();
+  for (const w of model.wrappers) {
+    if (!bySource.has(w.source)) bySource.set(w.source, []);
+    bySource.get(w.source).push(w);
+  }
+  out.push("  function applyNav(proto, className) {");
+  for (const [src, wrappers] of [...bySource.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)) {
+    out.push(`    if (className === ${S2(src)}) {`);
+    for (const w of wrappers) {
+      out.push(`      Object.defineProperty(proto, ${S2(w.prop)}, {`);
+      out.push(`        get: function () {`);
+      out.push(`          var _p = [];`);
+      for (let i = 0; i < w.path.length; i++) {
+        const h = w.path[i];
+        out.push(`          var o${i} = off(${S2(h.cls)},${S2(h.field)}); if (o${i} < 0) return null; _p.push(o${i});`);
+      }
+      out.push(`          return new ${w.wrapper}(this.ref, _p);`);
+      out.push(`        }, enumerable: true, configurable: true,`);
+      out.push(`      });`);
+    }
+    out.push("    }");
+  }
+  out.push("  }");
+  out.push("  globalThis.__s2pkg_cs2_nav = { applyNav: applyNav };");
+  out.push("})();");
+  out.push("");
+  return out.join("\n");
+}
+
+// src/navgen/emit-dts.ts
+var HEADER5 = "// GENERATED by `s2script gen-nav` from nav-targets.json \u2014 DO NOT EDIT.";
+function emitNavDts(model) {
+  let needsEntityRef = false;
+  let needsVector = false;
+  let needsQAngle = false;
+  for (const w of model.wrappers) {
+    for (const f of w.fields) {
+      if (f.accessorKind === "handle") needsEntityRef = true;
+      const vi = VEC_INFO[f.accessorKind];
+      if (vi?.cls === "Vector") needsVector = true;
+      if (vi?.cls === "QAngle") needsQAngle = true;
+    }
+  }
+  const out = [HEADER5];
+  const mathTypes = [];
+  if (needsVector) mathTypes.push("Vector");
+  if (needsQAngle) mathTypes.push("QAngle");
+  if (mathTypes.length) out.push(`import type { ${mathTypes.join(", ")} } from "@s2script/sdk/math";`);
+  if (needsEntityRef) out.push('import type { EntityRef } from "@s2script/sdk/entity";');
+  out.push("");
+  for (const w of model.wrappers) {
+    out.push(`export interface ${w.wrapper} {`);
+    for (const f of w.fields) {
+      out.push(`  readonly ${f.propName}: ${TSTYPE[f.accessorKind]};`);
+    }
+    out.push("}", "");
+  }
+  return out.join("\n");
+}
+
+// src/navgen/gen.ts
+var TARGETS_PATH = "games/cs2/nav-targets.json";
+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(repoRoot, opts) {
+  const config = JSON.parse(readFileSync7(join7(repoRoot, TARGETS_PATH), "utf8"));
+  const catalog = JSON.parse(readFileSync7(join7(repoRoot, CATALOG_PATH3), "utf8"));
+  const model = buildNavModel(config, catalog);
+  const js = emitNavJs(model);
+  const dts = emitNavDts(model);
+  const fields = model.wrappers.reduce((n, w) => n + w.fields.length, 0);
+  const drift = [];
+  const files = [[JS_OUT2, js], [DTS_OUT3, dts]];
+  for (const [rel, content] of files) {
+    const abs = join7(repoRoot, rel);
+    if (opts.check) {
+      let cur = "";
+      try {
+        cur = readFileSync7(abs, "utf8");
+      } catch {
+      }
+      if (cur !== content) drift.push(rel);
+    } else {
+      writeFileSync4(abs, content);
+    }
+  }
+  return { wrappers: model.wrappers.length, fields, drift };
+}
+
+// src/create/create.ts
+import {
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync5,
+  existsSync as existsSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync8
+} from "node:fs";
+import { dirname as dirname2, join as join8, resolve as resolve5, basename } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function readCliVersion() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join8(here, "..", "package.json"),
+    // dist/cli.js → packages/sdk/package.json
+    join8(here, "..", "..", "package.json")
+    // src/create → packages/sdk/package.json
+  ];
+  for (const p of candidates) {
+    if (!existsSync4(p)) continue;
+    try {
+      const pkg = JSON.parse(readFileSync8(p, "utf8"));
+      if (pkg.name === "@s2script/sdk" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.1.0";
+}
+function findLocalPackagesDir() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  const candidates = [
+    join8(here, "..", ".."),
+    // dist/cli.js → packages
+    join8(here, "..", "..", "..")
+    // src/create → packages
+  ];
+  for (const c of candidates) {
+    if (isPackagesDir(c)) return resolve5(c);
+  }
+  return void 0;
+}
+function defaultNameFromPath(dir) {
+  const base = basename(resolve5(dir));
+  const slug = base.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "plugin";
+  return `@plugin/${slug}`;
+}
+async function promptSelect(rl, question, choices, defaultValue) {
+  console.log(question);
+  choices.forEach((c, i) => {
+    const mark = c.value === defaultValue ? "*" : " ";
+    console.log(`  ${mark} ${i + 1}) ${c.label}`);
+  });
+  const raw = (await rl.question(`  (default ${defaultValue}): `)).trim();
+  if (!raw) return defaultValue;
+  const asNum = Number(raw);
+  if (Number.isInteger(asNum) && asNum >= 1 && asNum <= choices.length) {
+    return choices[asNum - 1].value;
+  }
+  const hit = choices.find(
+    (c) => c.value === raw || c.label.toLowerCase() === raw.toLowerCase()
+  );
+  return hit?.value ?? defaultValue;
+}
+async function promptText(rl, question, defaultValue) {
+  const raw = (await rl.question(`${question} (${defaultValue}): `)).trim();
+  return raw || defaultValue;
+}
+function assertGame(v) {
+  if (v === void 0) return void 0;
+  if (v === "cs2" || v === "none") return v;
+  throw new Error(`invalid --game ${JSON.stringify(v)} (expected cs2|none)`);
+}
+function assertInstall(v) {
+  if (v === void 0) return void 0;
+  if (v === "npm" || v === "pnpm" || v === "yarn" || v === "bun" || v === "none") return v;
+  throw new Error(`invalid --install ${JSON.stringify(v)} (expected npm|pnpm|yarn|bun|none)`);
+}
+function createPackageNames(game) {
+  if (game === "cs2") {
+    return ["sdk", "cs2"];
+  }
+  return ["sdk"];
+}
+function resolvePublishedVersion(pkg) {
+  const r = spawnSync("npm", ["view", pkg, "version"], { encoding: "utf8", timeout: 5e3 });
+  return versionSpecFrom(r.status, r.stdout);
+}
+function versionSpecFrom(status, stdout) {
+  const v = (stdout ?? "").trim();
+  return status === 0 && /^\d+\.\d+\.\d+/.test(v) ? `^${v}` : "latest";
+}
+function registryDevDeps(game, sdkVersion, resolve7 = resolvePublishedVersion) {
+  const deps = {};
+  for (const n of createPackageNames(game)) {
+    deps[`@s2script/${n}`] = n === "sdk" ? `^${sdkVersion}` : resolve7(`@s2script/${n}`);
+  }
+  return deps;
+}
+function fileDevDeps(packagesDir, game) {
+  const deps = {};
+  for (const n of createPackageNames(game)) {
+    const abs = join8(packagesDir, n);
+    if (!existsSync4(join8(abs, "package.json"))) return void 0;
+    deps[`@s2script/${n}`] = `file:${abs}`;
+  }
+  return deps;
+}
+function pluginSource(game) {
+  if (game === "cs2") {
+    return `import { Commands } from "@s2script/sdk/commands";
+import { Chat } from "@s2script/sdk/chat";
+
+export function onLoad(): void {
+  Commands.register("hello", (ctx) => {
+    ctx.reply("hello from s2script");
+    if (ctx.callerSlot >= 0) {
+      Chat.toSlot(ctx.callerSlot, "hello from s2script");
+    }
+  });
+}
+
+export function onUnload(): void {}
+`;
+  }
+  return `import { OnGameFrame } from "@s2script/sdk/frame";
+import { delay } from "@s2script/sdk/timers";
+
+export function onLoad(): void {
+  let n = 0;
+  OnGameFrame.subscribe(() => {
+    n += 1;
+  });
+  void delay(1000).then(() => {
+    console.log("s2script plugin alive; frames so far:", n);
+  });
+}
+
+export function onUnload(): void {}
+`;
+}
+function tsconfigJson() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        strict: true,
+        noEmit: true,
+        moduleResolution: "bundler",
+        module: "ESNext",
+        target: "ES2020",
+        lib: ["ES2020"],
+        types: [],
+        skipLibCheck: true
+      },
+      include: ["src", "node_modules/@s2script/sdk/globals.d.ts"]
+    },
+    null,
+    2
+  ) + "\n";
+}
+function packageJsonContent(name, game, version, localPackagesDir) {
+  const fileDeps = localPackagesDir ? fileDevDeps(localPackagesDir, game) : void 0;
+  const devDependencies = fileDeps ?? registryDevDeps(game, version);
+  return JSON.stringify(
+    {
+      name,
+      version: "0.1.0",
+      private: true,
+      main: "src/plugin.ts",
+      scripts: {
+        build: "s2s build ."
+      },
+      devDependencies,
+      s2script: {
+        apiVersion: "1.x"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function gitignore() {
+  return `node_modules/
+dist/
+*.s2sp
+.DS_Store
+`;
+}
+function runInstall(dir, pm) {
+  if (pm === "none") return;
+  const r = spawnSync(pm, ["install"], {
+    cwd: dir,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (r.error) throw r.error;
+  if (r.status !== 0) throw new Error(`${pm} install failed (exit ${r.status})`);
+}
+async function createPlugin(opts = {}) {
+  const targetPath = resolve5(opts.path ?? ".");
+  const interactive = Boolean(input.isTTY && output.isTTY && !opts.yes);
+  let game = assertGame(opts.game);
+  let name = opts.name;
+  let install = opts.noInstall ? "none" : assertInstall(opts.install);
+  const template = opts.template ?? "minimal";
+  if (template !== "minimal") {
+    throw new Error(`unknown template ${JSON.stringify(template)} (v1 supports: minimal)`);
+  }
+  if (existsSync4(targetPath)) {
+    const kids = readdirSync2(targetPath);
+    const meaningful = kids.filter((k) => k !== ".git");
+    if (meaningful.length) {
+      throw new Error(`target directory is not empty: ${targetPath}`);
+    }
+  }
+  if (interactive) {
+    const rl = createInterface({ input, output });
+    try {
+      if (!game) {
+        game = await promptSelect(
+          rl,
+          "Which game?",
+          [
+            { value: "cs2", label: "Counter-Strike 2" },
+            { value: "none", label: "Engine-generic only (no game package)" }
+          ],
+          "cs2"
+        );
+      }
+      if (!name) {
+        name = await promptText(rl, "Plugin package name", defaultNameFromPath(targetPath));
+      }
+      if (!install) {
+        install = await promptSelect(
+          rl,
+          "Install dependencies?",
+          [
+            { value: "npm", label: "npm" },
+            { value: "pnpm", label: "pnpm" },
+            { value: "yarn", label: "yarn" },
+            { value: "bun", label: "bun" },
+            { value: "none", label: "skip" }
+          ],
+          "npm"
+        );
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  game = game ?? "cs2";
+  name = name ?? defaultNameFromPath(targetPath);
+  install = install ?? (opts.noInstall ? "none" : "npm");
+  const version = readCliVersion();
+  const localPackagesDir = findLocalPackagesDir();
+  mkdirSync2(join8(targetPath, "src"), { recursive: true });
+  writeFileSync5(
+    join8(targetPath, "package.json"),
+    packageJsonContent(name, game, version, localPackagesDir)
+  );
+  writeFileSync5(join8(targetPath, "tsconfig.json"), tsconfigJson());
+  writeFileSync5(join8(targetPath, "src", "plugin.ts"), pluginSource(game));
+  writeFileSync5(join8(targetPath, ".gitignore"), gitignore());
+  let installed = false;
+  if (install !== "none") {
+    runInstall(targetPath, install);
+    installed = true;
+  }
+  return {
+    dir: targetPath,
+    name,
+    game,
+    installed,
+    skippedInstall: install === "none",
+    packageManager: install
+  };
+}
+
+// src/cli.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname3, join as join9, resolve as resolve6 } from "node:path";
+var argv = process.argv.slice(2);
+var command = argv[0];
+function repoRootFromCli() {
+  return join9(dirname3(fileURLToPath3(import.meta.url)), "..", "..", "..");
+}
+function parseFlag(args, name) {
+  const eq = args.find((a) => a.startsWith(`${name}=`));
+  if (eq) return eq.slice(name.length + 1);
+  const i = args.indexOf(name);
+  if (i >= 0 && args[i + 1] && !args[i + 1].startsWith("-")) return args[i + 1];
+  return void 0;
+}
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+if (command === "gen-schema") {
+  const repoRoot = repoRootFromCli();
+  const check = argv[1] === "--check";
+  const r = runGenSchema(repoRoot, { check });
+  if (check) {
+    if (r.drift.length) {
+      console.error(`FAIL: generated files out of date \u2014 run \`s2s gen-schema\`:
+  ${r.drift.join("\n  ")}`);
+      process.exit(1);
+    }
+    console.log(`schema codegen up to date (${r.classes} classes, ${r.fields} fields, ${r.skipped} skipped)`);
+  } else {
+    console.log(`gen-schema: wrote ${r.classes} classes, ${r.fields} fields (${r.skipped} skipped)`);
+  }
+} else if (command === "gen-events") {
+  const repoRoot = repoRootFromCli();
+  const check = argv[1] === "--check";
+  const r = runGenEvents(repoRoot, { check });
+  if (check) {
+    if (r.drift.length) {
+      console.error(`FAIL: generated files out of date \u2014 run \`s2s gen-events\`:
+  ${r.drift.join("\n  ")}`);
+      process.exit(1);
+    }
+    console.log(`event codegen up to date (${r.events} events)`);
+  } else {
+    console.log(`gen-events: wrote ${r.events} events`);
+  }
+} else if (command === "gen-nav") {
+  const repoRoot = repoRootFromCli();
+  const check = argv[1] === "--check";
+  const r = runGenNav(repoRoot, { check });
+  if (check) {
+    if (r.drift.length) {
+      console.error(`FAIL: generated files out of date \u2014 run \`s2s gen-nav\`:
+  ${r.drift.join("\n  ")}`);
+      process.exit(1);
+    }
+    console.log(`nav codegen up to date (${r.wrappers} wrappers, ${r.fields} fields)`);
+  } else {
+    console.log(`gen-nav: wrote ${r.wrappers} wrappers, ${r.fields} fields`);
+  }
+} else if (command === "create") {
+  const args = argv.slice(1);
+  const pathArg = args.find((a) => !a.startsWith("-"));
+  try {
+    const result = await createPlugin({
+      path: pathArg,
+      name: parseFlag(args, "--name"),
+      game: parseFlag(args, "--game"),
+      template: parseFlag(args, "--template"),
+      install: parseFlag(args, "--install"),
+      noInstall: hasFlag(args, "--no-install"),
+      yes: hasFlag(args, "--yes") || hasFlag(args, "-y")
+    });
+    console.log(`created ${result.dir}`);
+    if (result.installed) console.log(`dependencies installed (${result.packageManager})`);
+    else if (!result.skippedInstall) console.log(`next: cd ${result.dir} && npm install && npm run build`);
+    else console.log(`next: cd ${result.dir} && npm run build`);
+  } catch (e) {
+    console.error(String(e instanceof Error ? e.message : e));
+    process.exit(1);
+  }
+} else if (command === "build" && argv[1]) {
+  const args = argv.slice(1);
+  const dir = args.find((a) => !a.startsWith("-"));
+  const packagesDirFlag = parseFlag(args, "--packages-dir");
+  try {
+    const packagesDir = resolvePackagesDir({
+      explicit: packagesDirFlag,
+      pluginDir: resolve6(dir),
+      fromCliUrl: import.meta.url
+    });
+    console.log(await buildPlugin(dir, packagesDir));
+  } catch (e) {
+    console.error(String(e instanceof Error ? e.message : e));
+    process.exit(1);
+  }
+} else {
+  console.error(
+    "Usage:\n  s2s create [path] [--game cs2|none] [--name <pkg>] [--template minimal]\n             [--install npm|pnpm|yarn|bun|none] [--no-install] [-y]\n  s2s build <dir> [--packages-dir <path>]\n  s2s gen-schema [--check]\n  s2s gen-events [--check]\n  s2s gen-nav [--check]"
+  );
+  process.exit(1);
+}