@rhost/testkit 1.5.0 → 1.5.2

package/node_modules/@ursamu/mushcode/src/lint/rules/missing_wildcard.ts

@@ -0,0 +1,40 @@
+import type { ASTNode }  from "../../../parser/mod.ts";
+import type { Diagnostic } from "../mod.ts";
+import { findAll }          from "../../traverse/walk.js";
+
+/**
+ * missing-wildcard
+ *
+ * Reports when a DollarPattern or ListenPattern action uses a positional
+ * substitution %N (N ≥ 1) but the pattern contains fewer than N wildcards.
+ *
+ * In TinyMUX:
+ *   %0 = the full matched input (always available)
+ *   %1 = first wildcard match, %2 = second, … %9 = ninth
+ *
+ * So if the action uses %2, the pattern must have at least 2 wildcards.
+ */
+export function checkMissingWildcard(node: ASTNode): Diagnostic[] {
+  if (node.type !== "DollarPattern" && node.type !== "ListenPattern") return [];
+
+  const pattern = node.pattern as ASTNode;
+  const action  = node.action  as ASTNode;
+
+  const wildcardCount = findAll(pattern, "Wildcard").length;
+
+  const maxPositional = findAll(action, "Substitution")
+    .map(s => s.code as string)
+    .filter(code => /^[1-9]$/.test(code))
+    .reduce((max, code) => Math.max(max, parseInt(code)), 0);
+
+  if (maxPositional > wildcardCount) {
+    return [{
+      rule:     "missing-wildcard",
+      severity: "warning",
+      message:  `Pattern has ${wildcardCount} wildcard(s) but action uses %${maxPositional} `
+              + `— needs at least ${maxPositional} wildcard(s) in pattern`,
+      node: pattern,
+    }];
+  }
+  return [];
+}

package/node_modules/@ursamu/mushcode/src/lint/rules/register_before_set.js

@@ -0,0 +1,59 @@
+import { findAll } from "../../traverse/walk.js";
+/**
+ * register-before-set
+ *
+ * Reports %q<name> substitutions and r(<name>) calls where the named register
+ * has no corresponding setq(<name>, ...) anywhere in the same attribute value.
+ *
+ * This catches typos (using %q0 when you meant %0) and missing initialisation.
+ *
+ * Limitation: purely static — cannot detect registers set in other attributes
+ * called via u() before this one runs.  Use severity "info" to reflect this.
+ */ export function checkRegisterBeforeSet(root) {
+  const setRegisters = new Set();
+  const readNodes = [];
+  // Collect all setq() writes
+  for (const node of findAll(root, "FunctionCall")){
+    if (node.name.toLowerCase() !== "setq") continue;
+    const args = node.args;
+    if (args.length < 1) continue;
+    const nameStr = literalText(args[0]);
+    if (nameStr !== null) setRegisters.add(nameStr);
+  }
+  // Collect all register reads — %q<name> substitutions
+  for (const node of findAll(root, "Substitution")){
+    const code = node.code;
+    if (!code.startsWith("q")) continue;
+    const name = code.slice(1); // "q0" → "0", "qfoo" → "foo"
+    if (name) readNodes.push({
+      name,
+      node
+    });
+  }
+  // Collect r(<name>) function calls
+  for (const node of findAll(root, "FunctionCall")){
+    if (node.name.toLowerCase() !== "r") continue;
+    const args = node.args;
+    if (args.length !== 1) continue;
+    const name = literalText(args[0]);
+    if (name !== null) readNodes.push({
+      name,
+      node
+    });
+  }
+  return readNodes.filter(({ name })=>!setRegisters.has(name)).map(({ name, node })=>({
+      rule: "register-before-set",
+      severity: "info",
+      message: `Register "%q${name}" is read but no setq("${name}", …) found in this attribute`,
+      node
+    }));
+}
+/** Extract the literal string value of a single-literal Arg node, or null. */ function literalText(arg) {
+  if (arg.type !== "Arg") return null;
+  const parts = arg.parts;
+  if (parts.length === 1 && parts[0].type === "Literal") {
+    return parts[0].value;
+  }
+  return null;
+}
+//# sourceMappingURL=register_before_set.js.map

package/node_modules/@ursamu/mushcode/src/lint/rules/register_before_set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register_before_set.js","sources":["./register_before_set.ts"],"names":[],"mappings":"AAEA,SAAS,OAAO,iCAA0C;AAE1D;;;;;;;;;;CAUC,GACD,OAAO,SAAS,uBAAuB,IAAa;EAClD,MAAM,eAAe,IAAI;EACzB,MAAM,YAAoD,EAAE;EAE5D,4BAA4B;EAC5B,KAAK,MAAM,QAAQ,QAAQ,MAAM,gBAAiB;IAChD,IAAI,AAAC,KAAK,IAAI,CAAY,WAAW,OAAO,QAAQ;IACpD,MAAM,OAAO,KAAK,IAAI;IACtB,IAAI,KAAK,MAAM,GAAG,GAAG;IACrB,MAAM,UAAU,YAAY,IAAI,CAAC,EAAE;IACnC,IAAI,YAAY,MAAM,aAAa,GAAG,CAAC;EACzC;EAEA,sDAAsD;EACtD,KAAK,MAAM,QAAQ,QAAQ,MAAM,gBAAiB;IAChD,MAAM,OAAO,KAAK,IAAI;IACtB,IAAI,CAAC,KAAK,UAAU,CAAC,MAAM;IAC3B,MAAM,OAAO,KAAK,KAAK,CAAC,IAAI,6BAA6B;IACzD,IAAI,MAAM,UAAU,IAAI,CAAC;MAAE;MAAM;IAAK;EACxC;EAEA,mCAAmC;EACnC,KAAK,MAAM,QAAQ,QAAQ,MAAM,gBAAiB;IAChD,IAAI,AAAC,KAAK,IAAI,CAAY,WAAW,OAAO,KAAK;IACjD,MAAM,OAAO,KAAK,IAAI;IACtB,IAAI,KAAK,MAAM,KAAK,GAAG;IACvB,MAAM,OAAO,YAAY,IAAI,CAAC,EAAE;IAChC,IAAI,SAAS,MAAM,UAAU,IAAI,CAAC;MAAE;MAAM;IAAK;EACjD;EAEA,OAAO,UACJ,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,GAAK,CAAC,aAAa,GAAG,CAAC,OACvC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAK,CAAC;MACxB,MAAU;MACV,UAAU;MACV,SAAU,CAAC,YAAY,EAAE,KAAK,uBAAuB,EAAE,KAAK,6BAA6B,CAAC;MAC1F;IACF,CAAC;AACL;AAEA,4EAA4E,GAC5E,SAAS,YAAY,GAAY;EAC/B,IAAI,IAAI,IAAI,KAAK,OAAO,OAAO;EAC/B,MAAM,QAAQ,IAAI,KAAK;EACvB,IAAI,MAAM,MAAM,KAAK,KAAK,KAAK,CAAC,EAAE,CAAC,IAAI,KAAK,WAAW;IACrD,OAAO,KAAK,CAAC,EAAE,CAAC,KAAK;EACvB;EACA,OAAO;AACT"}

package/node_modules/@ursamu/mushcode/src/lint/rules/register_before_set.ts

@@ -0,0 +1,64 @@
+import type { ASTNode }  from "../../../parser/mod.ts";
+import type { Diagnostic } from "../mod.ts";
+import { findAll }          from "../../traverse/walk.js";
+
+/**
+ * register-before-set
+ *
+ * Reports %q<name> substitutions and r(<name>) calls where the named register
+ * has no corresponding setq(<name>, ...) anywhere in the same attribute value.
+ *
+ * This catches typos (using %q0 when you meant %0) and missing initialisation.
+ *
+ * Limitation: purely static — cannot detect registers set in other attributes
+ * called via u() before this one runs.  Use severity "info" to reflect this.
+ */
+export function checkRegisterBeforeSet(root: ASTNode): Diagnostic[] {
+  const setRegisters = new Set<string>();
+  const readNodes: Array<{ name: string; node: ASTNode }> = [];
+
+  // Collect all setq() writes
+  for (const node of findAll(root, "FunctionCall")) {
+    if ((node.name as string).toLowerCase() !== "setq") continue;
+    const args = node.args as ASTNode[];
+    if (args.length < 1) continue;
+    const nameStr = literalText(args[0]);
+    if (nameStr !== null) setRegisters.add(nameStr);
+  }
+
+  // Collect all register reads — %q<name> substitutions
+  for (const node of findAll(root, "Substitution")) {
+    const code = node.code as string;
+    if (!code.startsWith("q")) continue;
+    const name = code.slice(1); // "q0" → "0", "qfoo" → "foo"
+    if (name) readNodes.push({ name, node });
+  }
+
+  // Collect r(<name>) function calls
+  for (const node of findAll(root, "FunctionCall")) {
+    if ((node.name as string).toLowerCase() !== "r") continue;
+    const args = node.args as ASTNode[];
+    if (args.length !== 1) continue;
+    const name = literalText(args[0]);
+    if (name !== null) readNodes.push({ name, node });
+  }
+
+  return readNodes
+    .filter(({ name }) => !setRegisters.has(name))
+    .map(({ name, node }) => ({
+      rule:     "register-before-set",
+      severity: "info" as const,
+      message:  `Register "%q${name}" is read but no setq("${name}", …) found in this attribute`,
+      node,
+    }));
+}
+
+/** Extract the literal string value of a single-literal Arg node, or null. */
+function literalText(arg: ASTNode): string | null {
+  if (arg.type !== "Arg") return null;
+  const parts = arg.parts as ASTNode[];
+  if (parts.length === 1 && parts[0].type === "Literal") {
+    return parts[0].value as string;
+  }
+  return null;
+}

package/node_modules/@ursamu/mushcode/src/print/lock_printer.js

@@ -0,0 +1,43 @@
+/**
+ * Print a lock expression subtree back to its canonical string form.
+ * Only called when the root was parsed with the "LockExpr" start rule.
+ */ export function printLock(node) {
+  return printLockNode(node, null);
+}
+function printLockNode(node, parentType) {
+  switch(node.type){
+    case "LockOr":
+      {
+        const inner = node.operands.map((op)=>printLockNode(op, "LockOr")).join("|");
+        // Parens needed when OR appears inside AND context
+        return parentType === "LockAnd" ? `(${inner})` : inner;
+      }
+    case "LockAnd":
+      {
+        return node.operands.map((op)=>printLockNode(op, "LockAnd")).join("&");
+      }
+    case "LockNot":
+      {
+        const operand = node.operand;
+        const inner = printLockNode(operand, "LockNot");
+        // Re-add parens if the operand is a compound expression
+        const needsParens = operand.type === "LockOr" || operand.type === "LockAnd";
+        return needsParens ? `!(${inner})` : `!${inner}`;
+      }
+    case "LockMe":
+      return "me";
+    case "LockDbref":
+      return node.dbref;
+    case "LockFlagCheck":
+      return `flag^${node.flag}`;
+    case "LockTypeCheck":
+      return `type^${node.typeName}`;
+    case "LockAttrCheck":
+      return `attr^${node.attribute}`;
+    case "LockPlayerName":
+      return `=${node.name}`;
+    default:
+      throw new Error(`printLock: unexpected node type "${node.type}"`);
+  }
+}
+//# sourceMappingURL=lock_printer.js.map

package/node_modules/@ursamu/mushcode/src/print/lock_printer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock_printer.js","sources":["./lock_printer.ts"],"names":[],"mappings":"AAEA;;;CAGC,GACD,OAAO,SAAS,UAAU,IAAa;EACrC,OAAO,cAAc,MAAM;AAC7B;AAEA,SAAS,cAAc,IAAa,EAAE,UAAyB;EAC7D,OAAQ,KAAK,IAAI;IACf,KAAK;MAAU;QACb,MAAM,QAAQ,AAAC,KAAK,QAAQ,CACzB,GAAG,CAAC,CAAA,KAAM,cAAc,IAAI,WAC5B,IAAI,CAAC;QACR,mDAAmD;QACnD,OAAO,eAAe,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG;MACnD;IACA,KAAK;MAAW;QACd,OAAO,AAAC,KAAK,QAAQ,CAClB,GAAG,CAAC,CAAA,KAAM,cAAc,IAAI,YAC5B,IAAI,CAAC;MACV;IACA,KAAK;MAAW;QACd,MAAM,UAAU,KAAK,OAAO;QAC5B,MAAM,QAAQ,cAAc,SAAS;QACrC,wDAAwD;QACxD,MAAM,cAAc,QAAQ,IAAI,KAAK,YAAY,QAAQ,IAAI,KAAK;QAClE,OAAO,cAAc,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO;MAClD;IACA,KAAK;MAAkB,OAAO;IAC9B,KAAK;MAAkB,OAAO,KAAK,KAAK;IACxC,KAAK;MAAkB,OAAO,CAAC,KAAK,EAAE,KAAK,IAAI,EAAE;IACjD,KAAK;MAAkB,OAAO,CAAC,KAAK,EAAE,KAAK,QAAQ,EAAE;IACrD,KAAK;MAAkB,OAAO,CAAC,KAAK,EAAE,KAAK,SAAS,EAAE;IACtD,KAAK;MAAkB,OAAO,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE;IAC7C;MACE,MAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;EACpE;AACF"}

package/node_modules/@ursamu/mushcode/src/print/lock_printer.ts

@@ -0,0 +1,41 @@
+import type { ASTNode } from "../../parser/mod.ts";
+
+/**
+ * Print a lock expression subtree back to its canonical string form.
+ * Only called when the root was parsed with the "LockExpr" start rule.
+ */
+export function printLock(node: ASTNode): string {
+  return printLockNode(node, null);
+}
+
+function printLockNode(node: ASTNode, parentType: string | null): string {
+  switch (node.type) {
+    case "LockOr": {
+      const inner = (node.operands as ASTNode[])
+        .map(op => printLockNode(op, "LockOr"))
+        .join("|");
+      // Parens needed when OR appears inside AND context
+      return parentType === "LockAnd" ? `(${inner})` : inner;
+    }
+    case "LockAnd": {
+      return (node.operands as ASTNode[])
+        .map(op => printLockNode(op, "LockAnd"))
+        .join("&");
+    }
+    case "LockNot": {
+      const operand = node.operand as ASTNode;
+      const inner = printLockNode(operand, "LockNot");
+      // Re-add parens if the operand is a compound expression
+      const needsParens = operand.type === "LockOr" || operand.type === "LockAnd";
+      return needsParens ? `!(${inner})` : `!${inner}`;
+    }
+    case "LockMe":         return "me";
+    case "LockDbref":      return node.dbref as string;
+    case "LockFlagCheck":  return `flag^${node.flag}`;
+    case "LockTypeCheck":  return `type^${node.typeName}`;
+    case "LockAttrCheck":  return `attr^${node.attribute}`;
+    case "LockPlayerName": return `=${node.name}`;
+    default:
+      throw new Error(`printLock: unexpected node type "${node.type}"`);
+  }
+}

package/node_modules/@ursamu/mushcode/src/print/mod.js

@@ -0,0 +1,17 @@
+/**
+ * @module
+ * Converts an AST back to a canonical softcode string via `print()`.
+ * Supports compact (semicolon-separated) and pretty (newline-separated) modes.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@ursamu/mushcode/parse";
+ * import { print } from "@ursamu/mushcode/print";
+ *
+ * const ast = parse("@pemit %#=Hello;@pemit %#=World");
+ * console.log(print(ast, { mode: "pretty" }));
+ * // @pemit %#=Hello
+ * // @pemit %#=World
+ * ```
+ */ export { print } from "./printer.js";
+//# sourceMappingURL=mod.js.map

package/node_modules/@ursamu/mushcode/src/print/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sources":["./mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAAS,KAAK,uBAA8C"}

package/node_modules/@ursamu/mushcode/src/print/mod.ts

@@ -0,0 +1,18 @@
+/**
+ * @module
+ * Converts an AST back to a canonical softcode string via `print()`.
+ * Supports compact (semicolon-separated) and pretty (newline-separated) modes.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@ursamu/mushcode/parse";
+ * import { print } from "@ursamu/mushcode/print";
+ *
+ * const ast = parse("@pemit %#=Hello;@pemit %#=World");
+ * console.log(print(ast, { mode: "pretty" }));
+ * // @pemit %#=Hello
+ * // @pemit %#=World
+ * ```
+ */
+export type { PrintMode, PrintOptions } from "./printer.js";
+export { print }                        from "./printer.js";

package/node_modules/@ursamu/mushcode/src/print/printer.js

@@ -0,0 +1,91 @@
+import { printLock } from "./lock_printer.js";
+// ── Entry point ───────────────────────────────────────────────────────────────
+/**
+ * Convert an AST node back to a canonical softcode string.
+ *
+ * The output is semantically equivalent to the original source but whitespace
+ * may be normalised (e.g. `@pemit%#=x` becomes `@pemit %#=x`).
+ * Lock-expression nodes (LockOr, LockAnd, …) produced by the "LockExpr" start
+ * rule are printed via the lock printer.
+ */ export function print(node, opts) {
+  return printNode(node, opts);
+}
+// ── Dispatcher ────────────────────────────────────────────────────────────────
+function printNode(node, opts) {
+  // deno-lint-ignore no-explicit-any
+  const n = node;
+  switch(node.type){
+    // ── Commands ──────────────────────────────────────────────────────────────
+    case "CommandList":
+      {
+        const sep = opts?.mode === "pretty" ? ";\n" : ";";
+        return n.commands.map((c)=>printNode(c, opts)).join(sep);
+      }
+    case "AtCommand":
+      {
+        const sw = n.switches.map((s)=>`/${s}`).join("");
+        const obj = n.object ? " " + printNode(n.object, opts) : "";
+        const val = n.value != null ? "=" + printNode(n.value, opts) : "";
+        return `@${n.name}${sw}${obj}${val}`;
+      }
+    case "AttributeSet":
+      {
+        const obj = printNode(n.object, opts);
+        const val = n.value != null ? "=" + printNode(n.value, opts) : "";
+        return `&${n.attribute} ${obj}${val}`;
+      }
+    case "UserCommand":
+      return n.parts.map((p)=>printNode(p, opts)).join("");
+    // ── Patterns ──────────────────────────────────────────────────────────────
+    case "DollarPattern":
+      return "$" + printNode(n.pattern, opts) + ":" + printNode(n.action, opts);
+    case "ListenPattern":
+      return "^" + printNode(n.pattern, opts) + ":" + printNode(n.action, opts);
+    case "PatternAlts":
+      return n.patterns.map((p)=>printNode(p, opts)).join(";");
+    case "Pattern":
+      return n.parts.map((p)=>printNode(p, opts)).join("");
+    case "Wildcard":
+      return n.wildcard; // "*" or "?"
+    // ── Expression containers ─────────────────────────────────────────────────
+    case "EvalBlock":
+      return "[" + n.parts.map((p)=>printNode(p, opts)).join("") + "]";
+    case "BracedString":
+      return "{" + n.parts.map((p)=>printNode(p, opts)).join("") + "}";
+    case "FunctionCall":
+      {
+        const args = n.args.map((a)=>printNode(a, opts)).join(",");
+        return `${n.name}(${args})`;
+      }
+    case "Arg":
+      return n.parts.map((p)=>printNode(p, opts)).join("");
+    case "Text":
+      return n.parts.map((p)=>printNode(p, opts)).join("");
+    // ── Leaves ────────────────────────────────────────────────────────────────
+    case "Literal":
+      return n.value;
+    case "Escape":
+      return "\\" + n.char;
+    case "Substitution":
+      return "%" + n.code;
+    case "SpecialVar":
+      return n.code; // "##", "#@", "#$" — already includes #
+    case "TagRef":
+      return "#" + n.name;
+    // ── Lock expressions ──────────────────────────────────────────────────────
+    // These appear when using the "LockExpr" start rule.
+    case "LockOr":
+    case "LockAnd":
+    case "LockNot":
+    case "LockMe":
+    case "LockDbref":
+    case "LockFlagCheck":
+    case "LockTypeCheck":
+    case "LockAttrCheck":
+    case "LockPlayerName":
+      return printLock(node);
+    default:
+      throw new Error(`print: unhandled node type "${node.type}"`);
+  }
+}
+//# sourceMappingURL=printer.js.map

package/node_modules/@ursamu/mushcode/src/print/printer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"printer.js","sources":["./printer.ts"],"names":[],"mappings":"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"}

package/node_modules/@ursamu/mushcode/src/print/printer.ts

@@ -0,0 +1,132 @@
+import type { ASTNode } from "../../parser/mod.ts";
+import { printLock }   from "./lock_printer.js";
+
+// ── Options ───────────────────────────────────────────────────────────────────
+
+/** Controls how `CommandList` separators are rendered in the output. */
+export type PrintMode = "compact" | "pretty";
+
+/** Options for the {@link print} function. */
+export interface PrintOptions {
+  /** "compact" (default): CommandList joined by ";".
+   *  "pretty": CommandList joined by ";\n". */
+  mode?: PrintMode;
+}
+
+// ── Entry point ───────────────────────────────────────────────────────────────
+
+/**
+ * Convert an AST node back to a canonical softcode string.
+ *
+ * The output is semantically equivalent to the original source but whitespace
+ * may be normalised (e.g. `@pemit%#=x` becomes `@pemit %#=x`).
+ * Lock-expression nodes (LockOr, LockAnd, …) produced by the "LockExpr" start
+ * rule are printed via the lock printer.
+ */
+export function print(node: ASTNode, opts?: PrintOptions): string {
+  return printNode(node, opts);
+}
+
+// ── Dispatcher ────────────────────────────────────────────────────────────────
+
+function printNode(node: ASTNode, opts?: PrintOptions): string {
+  // deno-lint-ignore no-explicit-any
+  const n = node as any;
+  switch (node.type) {
+
+    // ── Commands ──────────────────────────────────────────────────────────────
+
+    case "CommandList": {
+      const sep = opts?.mode === "pretty" ? ";\n" : ";";
+      return (n.commands as ASTNode[]).map(c => printNode(c, opts)).join(sep);
+    }
+
+    case "AtCommand": {
+      const sw = (n.switches as string[]).map((s: string) => `/${s}`).join("");
+      const obj = n.object ? " " + printNode(n.object as ASTNode, opts) : "";
+      const val = n.value  != null ? "=" + printNode(n.value  as ASTNode, opts) : "";
+      return `@${n.name}${sw}${obj}${val}`;
+    }
+
+    case "AttributeSet": {
+      const obj = printNode(n.object as ASTNode, opts);
+      const val = n.value != null ? "=" + printNode(n.value as ASTNode, opts) : "";
+      return `&${n.attribute} ${obj}${val}`;
+    }
+
+    case "UserCommand":
+      return (n.parts as ASTNode[]).map(p => printNode(p, opts)).join("");
+
+    // ── Patterns ──────────────────────────────────────────────────────────────
+
+    case "DollarPattern":
+      return "$" + printNode(n.pattern as ASTNode, opts)
+           + ":" + printNode(n.action  as ASTNode, opts);
+
+    case "ListenPattern":
+      return "^" + printNode(n.pattern as ASTNode, opts)
+           + ":" + printNode(n.action  as ASTNode, opts);
+
+    case "PatternAlts":
+      return (n.patterns as ASTNode[]).map(p => printNode(p, opts)).join(";");
+
+    case "Pattern":
+      return (n.parts as ASTNode[]).map(p => printNode(p, opts)).join("");
+
+    case "Wildcard":
+      return n.wildcard as string;   // "*" or "?"
+
+    // ── Expression containers ─────────────────────────────────────────────────
+
+    case "EvalBlock":
+      return "[" + (n.parts as ASTNode[]).map(p => printNode(p, opts)).join("") + "]";
+
+    case "BracedString":
+      return "{" + (n.parts as ASTNode[]).map(p => printNode(p, opts)).join("") + "}";
+
+    case "FunctionCall": {
+      const args = (n.args as ASTNode[]).map(a => printNode(a, opts)).join(",");
+      return `${n.name}(${args})`;
+    }
+
+    case "Arg":
+      return (n.parts as ASTNode[]).map(p => printNode(p, opts)).join("");
+
+    case "Text":
+      return (n.parts as ASTNode[]).map(p => printNode(p, opts)).join("");
+
+    // ── Leaves ────────────────────────────────────────────────────────────────
+
+    case "Literal":
+      return n.value as string;
+
+    case "Escape":
+      return "\\" + (n.char as string);
+
+    case "Substitution":
+      return "%" + (n.code as string);
+
+    case "SpecialVar":
+      return n.code as string;   // "##", "#@", "#$" — already includes #
+
+    case "TagRef":
+      return "#" + (n.name as string);
+
+    // ── Lock expressions ──────────────────────────────────────────────────────
+    // These appear when using the "LockExpr" start rule.
+
+    case "LockOr":
+    case "LockAnd":
+    case "LockNot":
+    case "LockMe":
+    case "LockDbref":
+    case "LockFlagCheck":
+    case "LockTypeCheck":
+    case "LockAttrCheck":
+    case "LockPlayerName":
+      return printLock(node);
+
+    default:
+      throw new Error(`print: unhandled node type "${node.type}"`);
+  }
+}

package/node_modules/@ursamu/mushcode/src/traverse/child_slots.js

@@ -0,0 +1,129 @@
+// ============================================================================
+// child_slots.ts — authoritative child-field registry for every AST node type
+//
+// Used by walk() and transform() to know exactly which fields hold child nodes,
+// whether each field is a single node (possibly null) or an array of nodes.
+//
+// Leaf types (Literal, Escape, Substitution, SpecialVar, Wildcard, TagRef,
+// LockMe, LockDbref, LockFlagCheck, LockTypeCheck, LockAttrCheck,
+// LockPlayerName) have no entry — the walker treats missing entries as leaves.
+// ============================================================================
+export const CHILD_SLOTS = {
+  // ── Commands ────────────────────────────────────────────────────────────────
+  CommandList: [
+    {
+      field: "commands",
+      kind: "array"
+    }
+  ],
+  AtCommand: [
+    {
+      field: "object",
+      kind: "single"
+    },
+    {
+      field: "value",
+      kind: "single"
+    }
+  ],
+  AttributeSet: [
+    {
+      field: "object",
+      kind: "single"
+    },
+    {
+      field: "value",
+      kind: "single"
+    }
+  ],
+  UserCommand: [
+    {
+      field: "parts",
+      kind: "array"
+    }
+  ],
+  // ── Patterns ────────────────────────────────────────────────────────────────
+  DollarPattern: [
+    {
+      field: "pattern",
+      kind: "single"
+    },
+    {
+      field: "action",
+      kind: "single"
+    }
+  ],
+  ListenPattern: [
+    {
+      field: "pattern",
+      kind: "single"
+    },
+    {
+      field: "action",
+      kind: "single"
+    }
+  ],
+  PatternAlts: [
+    {
+      field: "patterns",
+      kind: "array"
+    }
+  ],
+  Pattern: [
+    {
+      field: "parts",
+      kind: "array"
+    }
+  ],
+  // ── Expression containers ───────────────────────────────────────────────────
+  EvalBlock: [
+    {
+      field: "parts",
+      kind: "array"
+    }
+  ],
+  BracedString: [
+    {
+      field: "parts",
+      kind: "array"
+    }
+  ],
+  FunctionCall: [
+    {
+      field: "args",
+      kind: "array"
+    }
+  ],
+  Arg: [
+    {
+      field: "parts",
+      kind: "array"
+    }
+  ],
+  Text: [
+    {
+      field: "parts",
+      kind: "array"
+    }
+  ],
+  // ── Lock expressions ────────────────────────────────────────────────────────
+  LockOr: [
+    {
+      field: "operands",
+      kind: "array"
+    }
+  ],
+  LockAnd: [
+    {
+      field: "operands",
+      kind: "array"
+    }
+  ],
+  LockNot: [
+    {
+      field: "operand",
+      kind: "single"
+    }
+  ]
+};
+//# sourceMappingURL=child_slots.js.map

package/node_modules/@ursamu/mushcode/src/traverse/child_slots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"child_slots.js","sources":["./child_slots.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,8EAA8E;AAC9E,EAAE;AACF,gFAAgF;AAChF,4EAA4E;AAC5E,EAAE;AACF,2EAA2E;AAC3E,kEAAkE;AAClE,+EAA+E;AAC/E,+EAA+E;AAS/E,OAAO,MAAM,cAAmD;EAC9D,+EAA+E;EAC/E,aAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,WAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;IACrC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,cAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;IACrC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,aAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EAEvD,+EAA+E;EAC/E,eAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;IACrC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,eAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;IACrC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,aAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,SAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EAEvD,+EAA+E;EAC/E,WAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,cAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,cAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,KAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,MAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EAEvD,+EAA+E;EAC/E,QAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,SAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;EACvD,SAAe;IAAC;MAAE,OAAO;MAAa,MAAM;IAAS;GAAE;AAKzD,EAAE"}