@s2script/sdk 0.10.1 → 0.11.0

package/dist/cli.js

@@ -1539,7 +1539,7 @@ var PLATFORM = "linuxsteamrt64";
 var ARG_KINDS = ["bool", "int", "float", "string", "vector", "entity"];
 var RET_KINDS = ["void", "bool", "int", "float", "entity"];
 var INT_CLASS_ARGS = /* @__PURE__ */ new Set(["bool", "int", "string", "vector", "entity"]);
-var MAX_INT_ARGS = 5;
+var MAX_INT_ARGS = 9;
 var MAX_FLOAT_ARGS = 8;
 
 // src/gamedata/validate.ts
@@ -1604,8 +1604,12 @@ function validatePluginGamedata(gd, opts) {
     }
     const decl = rawDecl;
     const recv = decl.receiver;
-    if (!recv || recv.kind !== "entity") {
-      errs.push(`${where}: receiver.kind must be "entity" in v1`);
+    if (!recv || recv.kind !== "entity" && recv.kind !== "none") {
+      errs.push(`${where}: receiver.kind must be "entity" or "none"`);
+    } else if (recv.kind === "none") {
+      if (recv.via !== void 0) {
+        errs.push(`${where}: receiver.kind "none" cannot carry a 'via' sub-object hop`);
+      }
     } else if (recv.via !== void 0) {
       const via = recv.via;
       if (typeof via?.class !== "string" || typeof via?.field !== "string") {
@@ -1649,7 +1653,7 @@ function validatePluginGamedata(gd, opts) {
         else floats++;
       }
       if (ints > MAX_INT_ARGS) {
-        errs.push(`${where}: ${ints} integer-class args exceeds the max of ${MAX_INT_ARGS} (\`this\` occupies rdi)`);
+        errs.push(`${where}: ${ints} integer-class args exceeds the max of ${MAX_INT_ARGS}`);
       }
       if (floats > MAX_FLOAT_ARGS) {
         errs.push(`${where}: ${floats} float args exceeds the max of ${MAX_FLOAT_ARGS}`);
@@ -1710,8 +1714,9 @@ function generateGamedataTypes(gd) {
   const lines = Object.keys(calls).sort().map((name) => {
     const decl = calls[name];
     const names = decl.argNames;
+    const receiverless = decl.receiver?.kind === "none";
     const params = [
-      "self: EntityRef",
+      ...receiverless ? [] : ["self: EntityRef"],
       ...decl.args.map((a2, i2) => `${names?.[i2] ?? `a${i2}`}: ${ARG_TS[a2]}`)
     ];
     return `    ${name}: (${params.join(", ")}) => ${RET_TS[decl.returns]};`;
@@ -4585,6 +4590,37 @@ import { readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from
 import { join as join13 } from "node:path";
 
 // src/schemagen/model.ts
+function enumMemberNames(enumName, members) {
+  const raw = {};
+  for (const m of members) raw[m] = m;
+  if (members.length === 0) return raw;
+  const stem = enumName.replace(/_t$/, "").replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+  if (stem === "") return raw;
+  const stripped = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of members) {
+    const up = m.toUpperCase();
+    let rest = null;
+    for (const sep3 of ["_", ""]) {
+      const pfx = stem + sep3;
+      if (up.startsWith(pfx) && m.length > pfx.length) {
+        rest = m.slice(pfx.length);
+        break;
+      }
+    }
+    if (rest === null && /^k[A-Z]/.test(m)) rest = m.slice(1);
+    if (rest === null) return raw;
+    const name = /^[0-9]/.test(rest) ? `_${rest}` : rest;
+    if (seen.has(name)) return raw;
+    seen.add(name);
+    stripped[m] = name;
+  }
+  return stripped;
+}
+function enumTsName(schemaName) {
+  const id = schemaName.replace(/[^A-Za-z0-9_$]/g, "_");
+  return /^[0-9]/.test(id) ? `_${id}` : id;
+}
 var READ = {
   f32: "readFloat32",
   bool: "readBool",
@@ -4683,7 +4719,7 @@ function classifyField(type, embeddable = /* @__PURE__ */ new Set()) {
   }
   if (type.kind === "enum") {
     const w = ENUM_WIDTH[type.size ?? 0];
-    if (w) return { accessorKind: w, writable: WRITE[w] !== void 0 };
+    if (w) return { accessorKind: w, writable: WRITE[w] !== void 0, enumType: type.name };
     return { skip: `enum '${type.name ?? ""}' byte width not stated by the schema` };
   }
   if (type.kind === "class") {
@@ -4705,7 +4741,7 @@ function flattenedFields(model, className) {
   }
   return chain.flatMap((c2) => c2.ownFields);
 }
-function buildModel(catalog, requested, embeddable = []) {
+function buildModel(catalog, requested, embeddable = [], enumCatalog = {}) {
   for (const n3 of embeddable) if (!catalog[n3]) throw new Error(`gen-schema: embedded class '${n3}' is not in the catalog`);
   const restrict = embeddable.length > 0 ? new Set(embeddable) : null;
   const canEmbed = (n3) => !!catalog[n3] && transparentValue(catalog, n3) === null && (restrict === null || restrict.has(n3));
@@ -4751,7 +4787,7 @@ function buildModel(catalog, requested, embeddable = []) {
         emb.push({ propName: idiomaticName(f.name), rawName: f.name, declaringClass: owner, embeddedClass: c2.embedded });
         continue;
       }
-      out.push({ propName: idiomaticName(f.name), rawName: f.name, declaringClass: owner, accessorKind: c2.accessorKind, writable: c2.writable, strLen: c2.strLen, addOffset: c2.addOffset });
+      out.push({ propName: idiomaticName(f.name), rawName: f.name, declaringClass: owner, accessorKind: c2.accessorKind, writable: c2.writable, strLen: c2.strLen, addOffset: c2.addOffset, enumType: c2.enumType });
     }
   };
   const classes = ordered.map((className) => {
@@ -4819,12 +4855,42 @@ function buildModel(catalog, requested, embeddable = []) {
     collisions.push(`${prop} <- ${renamed.sort().join(", ")}${soleWinner ? ` (kept by ${winnerCls})` : ""}`);
   }
   collisions.sort();
-  return { classes, embedded, collisions };
+  const referenced = /* @__PURE__ */ new Set();
+  const noteEnum = (f) => {
+    if (f.type.kind === "enum" && f.type.name && enumCatalog[f.type.name]) referenced.add(f.type.name);
+  };
+  for (const cls of inClosure) for (const f of catalog[cls].fields) noteEnum(f);
+  for (const e of embedded) for (const owner of new Set(e.fields.map((f) => f.declaringClass))) {
+    for (const f of catalog[owner]?.fields ?? []) noteEnum(f);
+  }
+  const byTsName = /* @__PURE__ */ new Map();
+  for (const n3 of referenced) {
+    const id = enumTsName(n3);
+    (byTsName.get(id) ?? byTsName.set(id, []).get(id)).push(n3);
+  }
+  const ambiguous = /* @__PURE__ */ new Set();
+  for (const [, group] of byTsName) if (group.length > 1) for (const n3 of group) ambiguous.add(n3);
+  const enums = [...referenced].filter((n3) => !ambiguous.has(n3)).sort().map((className) => {
+    const values = enumCatalog[className].values;
+    const names = enumMemberNames(className, Object.keys(values));
+    return {
+      className,
+      tsName: enumTsName(className),
+      members: Object.keys(values).sort().map((raw) => ({ name: names[raw], raw, value: values[raw] }))
+    };
+  });
+  for (const n3 of [...ambiguous].sort()) collisions.push(`enum ${n3} -> ${enumTsName(n3)} (ambiguous; emitted as number)`);
+  return { classes, embedded, enums, 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 enumTs = new Map(model.enums.map((e) => [e.className, e.tsName]));
+  const tsType = (f) => {
+    const id = f.enumType ? enumTs.get(f.enumType) : void 0;
+    return id ? `${id} | null` : TSTYPE[f.accessorKind];
+  };
   const names = new Set(model.classes.map((c2) => c2.className));
   const out = [HEADER, 'import type { EntityRef } from "@s2script/sdk/entity";'];
   const vecClasses = /* @__PURE__ */ new Set();
@@ -4838,10 +4904,21 @@ function emitDts(model) {
   }
   if (vecClasses.size) out.push(`import type { ${[...vecClasses].sort().join(", ")} } from "@s2script/sdk/math";`);
   out.push("");
+  for (const e of model.enums) {
+    out.push(`export declare const ${e.tsName}: {`);
+    for (const m of e.members) {
+      const doc = m.name === m.raw ? "" : `  /** \`${m.raw}\` */
+`;
+      out.push(`${doc}  readonly ${m.name}: ${m.value};`);
+    }
+    out.push("};");
+    if (e.tsName !== e.className) out.push(`/** Schema enum \`${e.className}\`. */`);
+    out.push(`export type ${e.tsName} = (typeof ${e.tsName})[keyof typeof ${e.tsName}];`, "");
+  }
   for (const e of model.embedded) {
     out.push(`export interface ${e.className} {`);
     for (const f of e.fields) {
-      out.push(`  ${f.writable ? "" : "readonly "}${f.propName}: ${TSTYPE[f.accessorKind]};`);
+      out.push(`  ${f.writable ? "" : "readonly "}${f.propName}: ${tsType(f)};`);
     }
     for (const f of e.embeddedFields) out.push(`  readonly ${f.propName}: ${f.embeddedClass};`);
     out.push("}", "");
@@ -4851,7 +4928,7 @@ function emitDts(model) {
     out.push(`export interface ${c2.className}${ext} {`);
     for (const f of c2.ownFields) {
       const ro = f.writable ? "" : "readonly ";
-      out.push(`  ${ro}${f.propName}: ${TSTYPE[f.accessorKind]};`);
+      out.push(`  ${ro}${f.propName}: ${tsType(f)};`);
     }
     for (const f of c2.embeddedFields) out.push(`  readonly ${f.propName}: ${f.embeddedClass};`);
     out.push("}", "");
@@ -4947,6 +5024,13 @@ function emitJs(model) {
   out.push("  var P = {");
   for (const c2 of model.classes) if (c2.parent) out.push(`    ${S(c2.className)}: ${S(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} });`);
+    }
+  }
   out.push(
     "  // Walk the ancestor chain rather than storing every inherited accessor per class. Flattening",
     "  // into each table duplicated the whole chain 3.77x on the CS2 class set and grew as",
@@ -4972,7 +5056,7 @@ function emitJs(model) {
     "  }",
     "  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 });",
+    "  globalThis.__s2pkg_cs2 = Object.assign({}, globalThis.__s2pkg_cs2, { wrapEntity: wrap }" + (model.enums.length > 0 ? ", E_CONST);" : ");"),
     "})();"
   );
   return out.join("\n");
@@ -4980,6 +5064,7 @@ function emitJs(model) {
 
 // src/schemagen/gen.ts
 var CATALOG_PATH = "games/cs2/gamedata/schema-catalog.json";
+var ENUMS_PATH = "games/cs2/gamedata/schema-enums.json";
 var LIST_PATH = "games/cs2/codegen-classes.json";
 var EMBED_PATH = "games/cs2/codegen-embedded.json";
 var JS_OUT = "games/cs2/js/schema.generated.js";
@@ -4992,7 +5077,12 @@ function runGenSchema(repoRoot2, opts) {
     embed = JSON.parse(readFileSync13(join13(repoRoot2, EMBED_PATH), "utf8"));
   } catch {
   }
-  const model = buildModel(catalog, list, embed);
+  let enumCatalog = {};
+  try {
+    enumCatalog = JSON.parse(readFileSync13(join13(repoRoot2, ENUMS_PATH), "utf8"));
+  } catch {
+  }
+  const model = buildModel(catalog, list, embed, enumCatalog);
   const dts = emitDts(model);
   const js = emitJs(model);
   const fields = model.classes.reduce((n3, c2) => n3 + c2.ownFields.length, 0);
@@ -5220,6 +5310,9 @@ function emitNavJs(model) {
   }
   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 () {`);
+    out.push(`    if (this.path.length > 0) this.root.notifyStateChanged(this.path[0]);`);
+    out.push(`  };`);
     out.push(`  Object.defineProperties(${w.wrapper}.prototype, {`);
     for (const f of w.fields) {
       const own = `off(${S2(f.declaringClass)},${S2(f.rawName)})`;
@@ -5319,6 +5412,16 @@ function emitNavDts(model) {
       out.push(` */`);
     }
     out.push(`export interface ${w.wrapper} {`);
+    out.push(
+      "  /**",
+      "   * Flag this sub-object for network replication after writing to it.",
+      "   *",
+      "   * Setters do not do this for you. For most targets it does not matter \u2014 the server reads the",
+      "   * field every tick \u2014 but anything a CLIENT renders (a scoreboard counter, say) will not update",
+      "   * until you call this.",
+      "   */",
+      "  notifyChanged(): void;"
+    );
     for (const f of w.fields) {
       out.push(`  ${f.navWritable ? "" : "readonly "}${f.propName}: ${TSTYPE[f.accessorKind]};`);
     }

package/entity.d.ts

@@ -116,6 +116,20 @@ export declare class EntityRef {
   notifyStateChanged(offset: number): void;
   /** Raw identity-slot flags (engine m_flags), or null when stale/unavailable. Bit meanings are game-specific. */
   identityFlags(): number | null;
+  /**
+   * CLEAR identity-slot flag bits; returns the flags after the write, or null when stale.
+   *
+   * Clear-only by design: `mask` names bits to DROP and nothing can be raised, because handing a
+   * plugin the ability to set arbitrary identity bits is a far larger foot-gun than the one this
+   * closes. The invalid-ehandle bit is refused outright — a dead slot must never be presentable as
+   * live.
+   *
+   * The case this exists for is the staging bit. `setModel` asserts that an entity is NOT in the
+   * staging list, and a created-but-unspawned entity is, so the create -> setModel -> spawn ordering
+   * (what CS2's own body spawner does) is otherwise unavailable and the alternatives produce
+   * half-initialised entities that clients fail to copy.
+   */
+  clearIdentityFlags(mask: number): number | null;
   /** DispatchSpawn this created entity. With keyvalues, the entity's own Spawn() parses them (the
    *  SourceMod DispatchKeyValue / CSSharp DispatchSpawn(kv) mechanism). Returns false if stale,
    *  unresolved, or the keyvalue map is rejected (non-finite number, unsupported value type, empty

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@s2script/sdk",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "MIT OR Apache-2.0",
   "description": "s2script SDK — the builtin capability types (imported as @s2script/sdk/entity, …) plus the `s2s` CLI for building Source 2 / CS2 plugins.",
   "type": "module",