@rhost/testkit 1.5.1 → 1.5.3

package/node_modules/@ursamu/mushcode/src/lint/builtin_arities.js

@@ -0,0 +1,212 @@
+/**
+ * Known arity ranges for TinyMUX / RhostMUSH built-in functions.
+ * [minArgs, maxArgs] — use Infinity for unlimited upper bound.
+ *
+ * Only strictly-bounded functions are listed.  Omitting a function means the
+ * arg-count rule skips it entirely (no false positives for unknown functions).
+ */ export const ARITIES = {
+  // Arithmetic
+  add: [
+    1,
+    Infinity
+  ],
+  sub: [
+    1,
+    Infinity
+  ],
+  mul: [
+    1,
+    Infinity
+  ],
+  div: [
+    2,
+    2
+  ],
+  mod: [
+    2,
+    2
+  ],
+  abs: [
+    1,
+    1
+  ],
+  // Comparison
+  eq: [
+    2,
+    2
+  ],
+  neq: [
+    2,
+    2
+  ],
+  gt: [
+    2,
+    2
+  ],
+  gte: [
+    2,
+    2
+  ],
+  lt: [
+    2,
+    2
+  ],
+  lte: [
+    2,
+    2
+  ],
+  // Logic
+  and: [
+    1,
+    Infinity
+  ],
+  or: [
+    1,
+    Infinity
+  ],
+  not: [
+    1,
+    1
+  ],
+  // Control flow
+  if: [
+    2,
+    3
+  ],
+  ifelse: [
+    3,
+    3
+  ],
+  switch: [
+    3,
+    Infinity
+  ],
+  // Registers
+  setq: [
+    2,
+    2
+  ],
+  r: [
+    1,
+    1
+  ],
+  // Iteration
+  iter: [
+    2,
+    4
+  ],
+  map: [
+    2,
+    4
+  ],
+  filter: [
+    2,
+    3
+  ],
+  // Object / attribute
+  name: [
+    1,
+    1
+  ],
+  loc: [
+    1,
+    1
+  ],
+  get: [
+    1,
+    1
+  ],
+  set: [
+    2,
+    2
+  ],
+  v: [
+    1,
+    1
+  ],
+  u: [
+    1,
+    Infinity
+  ],
+  hasflag: [
+    2,
+    2
+  ],
+  hasattr: [
+    2,
+    2
+  ],
+  // String
+  strlen: [
+    1,
+    1
+  ],
+  mid: [
+    3,
+    3
+  ],
+  left: [
+    2,
+    2
+  ],
+  right: [
+    2,
+    2
+  ],
+  trim: [
+    1,
+    3
+  ],
+  ljust: [
+    2,
+    3
+  ],
+  rjust: [
+    2,
+    3
+  ],
+  center: [
+    2,
+    3
+  ],
+  // List / matching
+  words: [
+    1,
+    2
+  ],
+  match: [
+    2,
+    3
+  ],
+  pmatch: [
+    1,
+    1
+  ],
+  lcon: [
+    1,
+    2
+  ],
+  lwho: [
+    0,
+    1
+  ],
+  // Formatting
+  ansi: [
+    2,
+    Infinity
+  ],
+  // Tags (RhostMUSH)
+  tag: [
+    1,
+    1
+  ],
+  listtags: [
+    0,
+    1
+  ],
+  tagmatch: [
+    1,
+    1
+  ]
+};
+//# sourceMappingURL=builtin_arities.js.map

package/node_modules/@ursamu/mushcode/src/lint/builtin_arities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin_arities.js","sources":["./builtin_arities.ts"],"names":[],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,MAAM,UAAsD;EACjE,aAAa;EACb,KAAS;IAAC;IAAG;GAAS;EACtB,KAAS;IAAC;IAAG;GAAS;EACtB,KAAS;IAAC;IAAG;GAAS;EACtB,KAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,aAAa;EACb,IAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,IAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,IAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,QAAQ;EACR,KAAS;IAAC;IAAG;GAAS;EACtB,IAAS;IAAC;IAAG;GAAS;EACtB,KAAS;IAAC;IAAG;GAAE;EACf,eAAe;EACf,IAAS;IAAC;IAAG;GAAE;EACf,QAAS;IAAC;IAAG;GAAE;EACf,QAAS;IAAC;IAAG;GAAS;EACtB,YAAY;EACZ,MAAS;IAAC;IAAG;GAAE;EACf,GAAS;IAAC;IAAG;GAAE;EACf,YAAY;EACZ,MAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,QAAS;IAAC;IAAG;GAAE;EACf,qBAAqB;EACrB,MAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,GAAS;IAAC;IAAG;GAAE;EACf,GAAS;IAAC;IAAG;GAAS;EACtB,SAAS;IAAC;IAAG;GAAE;EACf,SAAS;IAAC;IAAG;GAAE;EACf,SAAS;EACT,QAAS;IAAC;IAAG;GAAE;EACf,KAAS;IAAC;IAAG;GAAE;EACf,MAAS;IAAC;IAAG;GAAE;EACf,OAAS;IAAC;IAAG;GAAE;EACf,MAAS;IAAC;IAAG;GAAE;EACf,OAAS;IAAC;IAAG;GAAE;EACf,OAAS;IAAC;IAAG;GAAE;EACf,QAAS;IAAC;IAAG;GAAE;EACf,kBAAkB;EAClB,OAAS;IAAC;IAAG;GAAE;EACf,OAAS;IAAC;IAAG;GAAE;EACf,QAAS;IAAC;IAAG;GAAE;EACf,MAAS;IAAC;IAAG;GAAE;EACf,MAAS;IAAC;IAAG;GAAE;EACf,aAAa;EACb,MAAS;IAAC;IAAG;GAAS;EACtB,mBAAmB;EACnB,KAAa;IAAC;IAAG;GAAE;EACnB,UAAa;IAAC;IAAG;GAAE;EACnB,UAAa;IAAC;IAAG;GAAE;AACrB,EAAE"}

package/node_modules/@ursamu/mushcode/src/lint/builtin_arities.ts

@@ -0,0 +1,68 @@
+/**
+ * Known arity ranges for TinyMUX / RhostMUSH built-in functions.
+ * [minArgs, maxArgs] — use Infinity for unlimited upper bound.
+ *
+ * Only strictly-bounded functions are listed.  Omitting a function means the
+ * arg-count rule skips it entirely (no false positives for unknown functions).
+ */
+export const ARITIES: Readonly<Record<string, [number, number]>> = {
+  // Arithmetic
+  add:     [1, Infinity],
+  sub:     [1, Infinity],
+  mul:     [1, Infinity],
+  div:     [2, 2],
+  mod:     [2, 2],
+  abs:     [1, 1],
+  // Comparison
+  eq:      [2, 2],
+  neq:     [2, 2],
+  gt:      [2, 2],
+  gte:     [2, 2],
+  lt:      [2, 2],
+  lte:     [2, 2],
+  // Logic
+  and:     [1, Infinity],
+  or:      [1, Infinity],
+  not:     [1, 1],
+  // Control flow
+  if:      [2, 3],
+  ifelse:  [3, 3],
+  switch:  [3, Infinity],
+  // Registers
+  setq:    [2, 2],
+  r:       [1, 1],
+  // Iteration
+  iter:    [2, 4],
+  map:     [2, 4],
+  filter:  [2, 3],
+  // Object / attribute
+  name:    [1, 1],
+  loc:     [1, 1],
+  get:     [1, 1],
+  set:     [2, 2],
+  v:       [1, 1],
+  u:       [1, Infinity],
+  hasflag: [2, 2],
+  hasattr: [2, 2],
+  // String
+  strlen:  [1, 1],
+  mid:     [3, 3],
+  left:    [2, 2],
+  right:   [2, 2],
+  trim:    [1, 3],
+  ljust:   [2, 3],
+  rjust:   [2, 3],
+  center:  [2, 3],
+  // List / matching
+  words:   [1, 2],
+  match:   [2, 3],
+  pmatch:  [1, 1],
+  lcon:    [1, 2],
+  lwho:    [0, 1],
+  // Formatting
+  ansi:    [2, Infinity],
+  // Tags (RhostMUSH)
+  tag:         [1, 1],
+  listtags:    [0, 1],
+  tagmatch:    [1, 1],
+};

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

@@ -0,0 +1,60 @@
+/**
+ * @module
+ * Static analysis for softcode: `lint()` runs built-in rules and returns
+ * `Diagnostic` findings with severity, rule ID, and the offending AST node.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@ursamu/mushcode/parse";
+ * import { lint }  from "@ursamu/mushcode/lint";
+ *
+ * const ast  = parse("$finger:@pemit %#=[u(me/FN)]");
+ * const diags = lint(ast);
+ * diags.forEach(d => console.log(`[${d.severity}] ${d.rule}: ${d.message}`));
+ * ```
+ */ import { walk } from "../traverse/walk.js";
+import { checkMissingWildcard } from "./rules/missing_wildcard.js";
+import { checkIterVarOutsideIter } from "./rules/iter_var_outside_iter.js";
+import { checkArgCount } from "./rules/arg_count.js";
+import { checkRegisterBeforeSet } from "./rules/register_before_set.js";
+// ── Available rules ───────────────────────────────────────────────────────────
+/** All built-in rule IDs.  Pass a subset to `LintOptions.rules` to enable only those rules. */ export const RULES = [
+  "missing-wildcard",
+  "iter-var-outside-iter",
+  "arg-count",
+  "register-before-set"
+];
+// ── lint ──────────────────────────────────────────────────────────────────────
+/**
+ * Run static analysis on an AST and return an array of diagnostics.
+ *
+ * Rules are applied at every DollarPattern/ListenPattern/FunctionCall/… node
+ * anywhere in the tree, so this works correctly on CommandList roots too.
+ *
+ * @example
+ * const diags = lint(parse("$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]"));
+ * diags.forEach(d => console.log(`[${d.severity}] ${d.rule}: ${d.message}`));
+ */ export function lint(root, opts) {
+  const enabled = new Set(opts?.rules ?? RULES);
+  const diags = [];
+  // Rules that examine individual nodes as we walk
+  walk(root, {
+    enter (node) {
+      if (enabled.has("missing-wildcard")) {
+        diags.push(...checkMissingWildcard(node));
+      }
+    }
+  });
+  // Rules that need a full-tree view (run once on the root)
+  if (enabled.has("iter-var-outside-iter")) {
+    diags.push(...checkIterVarOutsideIter(root));
+  }
+  if (enabled.has("arg-count")) {
+    diags.push(...checkArgCount(root));
+  }
+  if (enabled.has("register-before-set")) {
+    diags.push(...checkRegisterBeforeSet(root));
+  }
+  return diags;
+}
+//# sourceMappingURL=mod.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sources":["./mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAED,SAAS,IAAI,8BAAsD;AACnE,SAAS,oBAAoB,sCAA8C;AAC3E,SAAS,uBAAuB,2CAAgD;AAChF,SAAS,aAAa,+BAA8C;AACpE,SAAS,sBAAsB,yCAA+C;AAyB9E,iFAAiF;AAEjF,6FAA6F,GAC7F,OAAO,MAAM,QAAQ;EACnB;EACA;EACA;EACA;CACD,CAAU;AAKX,iFAAiF;AAEjF;;;;;;;;;CASC,GACD,OAAO,SAAS,KAAK,IAAa,EAAE,IAAkB;EACpD,MAAM,UAAU,IAAI,IAAI,MAAM,SAAS;EACvC,MAAM,QAAsB,EAAE;EAE9B,iDAAiD;EACjD,KAAK,MAAM;IACT,OAAM,IAAI;MACR,IAAI,QAAQ,GAAG,CAAC,qBAAqB;QACnC,MAAM,IAAI,IAAI,qBAAqB;MACrC;IACF;EACF;EAEA,0DAA0D;EAC1D,IAAI,QAAQ,GAAG,CAAC,0BAA0B;IACxC,MAAM,IAAI,IAAI,wBAAwB;EACxC;EACA,IAAI,QAAQ,GAAG,CAAC,cAAc;IAC5B,MAAM,IAAI,IAAI,cAAc;EAC9B;EACA,IAAI,QAAQ,GAAG,CAAC,wBAAwB;IACtC,MAAM,IAAI,IAAI,uBAAuB;EACvC;EAEA,OAAO;AACT"}

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

@@ -0,0 +1,96 @@
+/**
+ * @module
+ * Static analysis for softcode: `lint()` runs built-in rules and returns
+ * `Diagnostic` findings with severity, rule ID, and the offending AST node.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@ursamu/mushcode/parse";
+ * import { lint }  from "@ursamu/mushcode/lint";
+ *
+ * const ast  = parse("$finger:@pemit %#=[u(me/FN)]");
+ * const diags = lint(ast);
+ * diags.forEach(d => console.log(`[${d.severity}] ${d.rule}: ${d.message}`));
+ * ```
+ */
+import type { ASTNode }                from "../../parser/mod.ts";
+import { walk }                         from "../traverse/walk.js";
+import { checkMissingWildcard }         from "./rules/missing_wildcard.js";
+import { checkIterVarOutsideIter }      from "./rules/iter_var_outside_iter.js";
+import { checkArgCount }                from "./rules/arg_count.js";
+import { checkRegisterBeforeSet }       from "./rules/register_before_set.js";
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+/** Severity level of a lint diagnostic. */
+export type Severity = "error" | "warning" | "info";
+
+/** A single lint finding produced by a rule. */
+export interface Diagnostic {
+  /** Identifier for the rule that produced this diagnostic. */
+  rule:     string;
+  /** How serious the finding is. */
+  severity: Severity;
+  /** Human-readable description of the issue. */
+  message:  string;
+  /** The AST node most closely associated with the issue. */
+  node:     ASTNode;
+}
+
+/** Options passed to the {@link lint} function. */
+export interface LintOptions {
+  /** Whitelist of rule IDs to run.  Omit to run all rules. */
+  rules?: string[];
+}
+
+// ── Available rules ───────────────────────────────────────────────────────────
+
+/** All built-in rule IDs.  Pass a subset to `LintOptions.rules` to enable only those rules. */
+export const RULES = [
+  "missing-wildcard",
+  "iter-var-outside-iter",
+  "arg-count",
+  "register-before-set",
+] as const;
+
+/** Union type of every known rule ID string. */
+export type RuleId = (typeof RULES)[number];
+
+// ── lint ──────────────────────────────────────────────────────────────────────
+
+/**
+ * Run static analysis on an AST and return an array of diagnostics.
+ *
+ * Rules are applied at every DollarPattern/ListenPattern/FunctionCall/… node
+ * anywhere in the tree, so this works correctly on CommandList roots too.
+ *
+ * @example
+ * const diags = lint(parse("$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]"));
+ * diags.forEach(d => console.log(`[${d.severity}] ${d.rule}: ${d.message}`));
+ */
+export function lint(root: ASTNode, opts?: LintOptions): Diagnostic[] {
+  const enabled = new Set(opts?.rules ?? RULES);
+  const diags: Diagnostic[] = [];
+
+  // Rules that examine individual nodes as we walk
+  walk(root, {
+    enter(node) {
+      if (enabled.has("missing-wildcard")) {
+        diags.push(...checkMissingWildcard(node));
+      }
+    },
+  });
+
+  // Rules that need a full-tree view (run once on the root)
+  if (enabled.has("iter-var-outside-iter")) {
+    diags.push(...checkIterVarOutsideIter(root));
+  }
+  if (enabled.has("arg-count")) {
+    diags.push(...checkArgCount(root));
+  }
+  if (enabled.has("register-before-set")) {
+    diags.push(...checkRegisterBeforeSet(root));
+  }
+
+  return diags;
+}

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

@@ -0,0 +1,37 @@
+import { findAll } from "../../traverse/walk.js";
+import { ARITIES } from "../builtin_arities.js";
+/**
+ * arg-count
+ *
+ * Reports FunctionCall nodes where the number of arguments falls outside the
+ * known [minArgs, maxArgs] range for that built-in function.
+ *
+ * Only functions listed in ARITIES are checked; user-defined functions and
+ * unrecognised names are silently skipped.
+ */ export function checkArgCount(root) {
+  const diagnostics = [];
+  for (const node of findAll(root, "FunctionCall")){
+    const name = node.name.toLowerCase();
+    const arity = ARITIES[name];
+    if (!arity) continue; // not a known built-in — skip
+    const [min, max] = arity;
+    const argc = node.args.length;
+    if (argc < min) {
+      diagnostics.push({
+        rule: "arg-count",
+        severity: "warning",
+        message: `${node.name}() requires at least ${min} argument(s), got ${argc}`,
+        node
+      });
+    } else if (argc > max) {
+      diagnostics.push({
+        rule: "arg-count",
+        severity: "warning",
+        message: `${node.name}() accepts at most ${max} argument(s), got ${argc}`,
+        node
+      });
+    }
+  }
+  return diagnostics;
+}
+//# sourceMappingURL=arg_count.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arg_count.js","sources":["./arg_count.ts"],"names":[],"mappings":"AAEA,SAAS,OAAO,iCAA0C;AAC1D,SAAS,OAAO,gCAAyC;AAEzD;;;;;;;;CAQC,GACD,OAAO,SAAS,cAAc,IAAa;EACzC,MAAM,cAA4B,EAAE;EAEpC,KAAK,MAAM,QAAQ,QAAQ,MAAM,gBAAiB;IAChD,MAAM,OAAQ,AAAC,KAAK,IAAI,CAAY,WAAW;IAC/C,MAAM,QAAQ,OAAO,CAAC,KAAK;IAC3B,IAAI,CAAC,OAAO,UAAU,8BAA8B;IAEpD,MAAM,CAAC,KAAK,IAAI,GAAG;IACnB,MAAM,OAAO,AAAC,KAAK,IAAI,CAAe,MAAM;IAE5C,IAAI,OAAO,KAAK;MACd,YAAY,IAAI,CAAC;QACf,MAAU;QACV,UAAU;QACV,SAAU,GAAG,KAAK,IAAI,CAAC,qBAAqB,EAAE,IAAI,kBAAkB,EAAE,MAAM;QAC5E;MACF;IACF,OAAO,IAAI,OAAO,KAAK;MACrB,YAAY,IAAI,CAAC;QACf,MAAU;QACV,UAAU;QACV,SAAU,GAAG,KAAK,IAAI,CAAC,mBAAmB,EAAE,IAAI,kBAAkB,EAAE,MAAM;QAC1E;MACF;IACF;EACF;EAEA,OAAO;AACT"}

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

@@ -0,0 +1,44 @@
+import type { ASTNode }  from "../../../parser/mod.ts";
+import type { Diagnostic } from "../mod.ts";
+import { findAll }          from "../../traverse/walk.js";
+import { ARITIES }          from "../builtin_arities.js";
+
+/**
+ * arg-count
+ *
+ * Reports FunctionCall nodes where the number of arguments falls outside the
+ * known [minArgs, maxArgs] range for that built-in function.
+ *
+ * Only functions listed in ARITIES are checked; user-defined functions and
+ * unrecognised names are silently skipped.
+ */
+export function checkArgCount(root: ASTNode): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+
+  for (const node of findAll(root, "FunctionCall")) {
+    const name  = (node.name as string).toLowerCase();
+    const arity = ARITIES[name];
+    if (!arity) continue; // not a known built-in — skip
+
+    const [min, max] = arity;
+    const argc = (node.args as ASTNode[]).length;
+
+    if (argc < min) {
+      diagnostics.push({
+        rule:     "arg-count",
+        severity: "warning",
+        message:  `${node.name}() requires at least ${min} argument(s), got ${argc}`,
+        node,
+      });
+    } else if (argc > max) {
+      diagnostics.push({
+        rule:     "arg-count",
+        severity: "warning",
+        message:  `${node.name}() accepts at most ${max} argument(s), got ${argc}`,
+        node,
+      });
+    }
+  }
+
+  return diagnostics;
+}

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

@@ -0,0 +1,55 @@
+import { walk } from "../../traverse/walk.js";
+const ITER_VARS = new Set([
+  "##",
+  "#@",
+  "#$"
+]);
+/**
+ * iter-var-outside-iter
+ *
+ * Reports when ##, #@, or #$ (iteration SpecialVars) appear outside an
+ * iter() function call or @dolist command, where they have no defined value.
+ *
+ * Valid contexts:
+ *   iter(list, body) — ## is the current element in `body`
+ *   @dolist list={body} — ## is the current element in `body`
+ *
+ * The rule is conservative: any nesting under an iter/dolist suppresses the
+ * warning for the entire subtree, avoiding false positives on patterns like
+ * iter(iter(inner, ##), ##).
+ */ export function checkIterVarOutsideIter(root) {
+  const diagnostics = [];
+  let iterDepth = 0;
+  walk(root, {
+    enter (node) {
+      if (isIterContext(node)) {
+        iterDepth++;
+        return; // continue into children
+      }
+      if (node.type === "SpecialVar" && ITER_VARS.has(node.code)) {
+        if (iterDepth === 0) {
+          diagnostics.push({
+            rule: "iter-var-outside-iter",
+            severity: "warning",
+            message: `"${node.code}" is only meaningful inside iter() or @dolist`,
+            node
+          });
+        }
+      }
+    },
+    leave (node) {
+      if (isIterContext(node)) iterDepth--;
+    }
+  });
+  return diagnostics;
+}
+function isIterContext(node) {
+  if (node.type === "FunctionCall") {
+    return node.name.toLowerCase() === "iter" || node.name.toLowerCase() === "ilist" || node.name.toLowerCase() === "map";
+  }
+  if (node.type === "AtCommand") {
+    return node.name.toLowerCase() === "dolist";
+  }
+  return false;
+}
+//# sourceMappingURL=iter_var_outside_iter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iter_var_outside_iter.js","sources":["./iter_var_outside_iter.ts"],"names":[],"mappings":"AAEA,SAAS,IAAI,iCAA6C;AAE1D,MAAM,YAAY,IAAI,IAAI;EAAC;EAAM;EAAM;CAAK;AAE5C;;;;;;;;;;;;;CAaC,GACD,OAAO,SAAS,wBAAwB,IAAa;EACnD,MAAM,cAA4B,EAAE;EACpC,IAAI,YAAY;EAEhB,KAAK,MAAM;IACT,OAAM,IAAI;MACR,IAAI,cAAc,OAAO;QACvB;QACA,QAAQ,yBAAyB;MACnC;MACA,IAAI,KAAK,IAAI,KAAK,gBAAgB,UAAU,GAAG,CAAC,KAAK,IAAI,GAAa;QACpE,IAAI,cAAc,GAAG;UACnB,YAAY,IAAI,CAAC;YACf,MAAU;YACV,UAAU;YACV,SAAU,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,6CAA6C,CAAC;YACtE;UACF;QACF;MACF;IACF;IACA,OAAM,IAAI;MACR,IAAI,cAAc,OAAO;IAC3B;EACF;EAEA,OAAO;AACT;AAEA,SAAS,cAAc,IAAa;EAClC,IAAI,KAAK,IAAI,KAAK,gBAAgB;IAChC,OAAO,AAAC,KAAK,IAAI,CAAY,WAAW,OAAO,UACxC,AAAC,KAAK,IAAI,CAAY,WAAW,OAAO,WACxC,AAAC,KAAK,IAAI,CAAY,WAAW,OAAO;EACjD;EACA,IAAI,KAAK,IAAI,KAAK,aAAa;IAC7B,OAAO,AAAC,KAAK,IAAI,CAAY,WAAW,OAAO;EACjD;EACA,OAAO;AACT"}

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

@@ -0,0 +1,60 @@
+import type { ASTNode }  from "../../../parser/mod.ts";
+import type { Diagnostic } from "../mod.ts";
+import { walk }             from "../../traverse/walk.js";
+
+const ITER_VARS = new Set(["##", "#@", "#$"]);
+
+/**
+ * iter-var-outside-iter
+ *
+ * Reports when ##, #@, or #$ (iteration SpecialVars) appear outside an
+ * iter() function call or @dolist command, where they have no defined value.
+ *
+ * Valid contexts:
+ *   iter(list, body) — ## is the current element in `body`
+ *   @dolist list={body} — ## is the current element in `body`
+ *
+ * The rule is conservative: any nesting under an iter/dolist suppresses the
+ * warning for the entire subtree, avoiding false positives on patterns like
+ * iter(iter(inner, ##), ##).
+ */
+export function checkIterVarOutsideIter(root: ASTNode): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  let iterDepth = 0;
+
+  walk(root, {
+    enter(node) {
+      if (isIterContext(node)) {
+        iterDepth++;
+        return; // continue into children
+      }
+      if (node.type === "SpecialVar" && ITER_VARS.has(node.code as string)) {
+        if (iterDepth === 0) {
+          diagnostics.push({
+            rule:     "iter-var-outside-iter",
+            severity: "warning",
+            message:  `"${node.code}" is only meaningful inside iter() or @dolist`,
+            node,
+          });
+        }
+      }
+    },
+    leave(node) {
+      if (isIterContext(node)) iterDepth--;
+    },
+  });
+
+  return diagnostics;
+}
+
+function isIterContext(node: ASTNode): boolean {
+  if (node.type === "FunctionCall") {
+    return (node.name as string).toLowerCase() === "iter" ||
+           (node.name as string).toLowerCase() === "ilist" ||
+           (node.name as string).toLowerCase() === "map";
+  }
+  if (node.type === "AtCommand") {
+    return (node.name as string).toLowerCase() === "dolist";
+  }
+  return false;
+}

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

@@ -0,0 +1,31 @@
+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) {
+  if (node.type !== "DollarPattern" && node.type !== "ListenPattern") return [];
+  const pattern = node.pattern;
+  const action = node.action;
+  const wildcardCount = findAll(pattern, "Wildcard").length;
+  const maxPositional = findAll(action, "Substitution").map((s)=>s.code).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 [];
+}
+//# sourceMappingURL=missing_wildcard.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"missing_wildcard.js","sources":["./missing_wildcard.ts"],"names":[],"mappings":"AAEA,SAAS,OAAO,iCAA0C;AAE1D;;;;;;;;;;;CAWC,GACD,OAAO,SAAS,qBAAqB,IAAa;EAChD,IAAI,KAAK,IAAI,KAAK,mBAAmB,KAAK,IAAI,KAAK,iBAAiB,OAAO,EAAE;EAE7E,MAAM,UAAU,KAAK,OAAO;EAC5B,MAAM,SAAU,KAAK,MAAM;EAE3B,MAAM,gBAAgB,QAAQ,SAAS,YAAY,MAAM;EAEzD,MAAM,gBAAgB,QAAQ,QAAQ,gBACnC,GAAG,CAAC,CAAA,IAAK,EAAE,IAAI,EACf,MAAM,CAAC,CAAA,OAAQ,UAAU,IAAI,CAAC,OAC9B,MAAM,CAAC,CAAC,KAAK,OAAS,KAAK,GAAG,CAAC,KAAK,SAAS,QAAQ;EAExD,IAAI,gBAAgB,eAAe;IACjC,OAAO;MAAC;QACN,MAAU;QACV,UAAU;QACV,SAAU,CAAC,YAAY,EAAE,cAAc,8BAA8B,EAAE,cAAc,CAAC,CAAC,GAC7E,CAAC,iBAAiB,EAAE,cAAc,uBAAuB,CAAC;QACpE,MAAM;MACR;KAAE;EACJ;EACA,OAAO,EAAE;AACX"}