@rhost/testkit 1.5.1 → 1.5.2

package/node_modules/@ursamu/mushcode/tests/07-dollar-patterns.test.ts

@@ -0,0 +1,156 @@
+// ============================================================================
+// 07 — Dollar-sign command patterns  $<pattern>:<action>
+//    — Listen patterns              ^<pattern>:<action>
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+// ── DollarPattern ─────────────────────────────────────────────────────────────
+
+describe("DollarPattern — basic", () => {
+  it("$+finger *:@pemit %#=Hi → DollarPattern", () => {
+    const ast = mustParse("$+finger *:@pemit %#=Hi");
+    assertEquals(ast.type, "DollarPattern");
+  });
+
+  it("pattern contains Wildcard(*)", () => {
+    const ast = mustParse("$+finger *:@pemit %#=Hi");
+    const wc = findAll(ast.pattern, "Wildcard");
+    assertEquals(wc.length, 1);
+    assertEquals(wc[0].wildcard, "*");
+  });
+
+  it("pattern has literal prefix before wildcard", () => {
+    const ast = mustParse("$+finger *:@pemit %#=Hi");
+    assertEquals(ast.pattern.type, "Pattern");
+    const lits = findAll(ast.pattern, "Literal");
+    assertEquals(lits[0].value, "+finger ");
+  });
+
+  it("action is the @pemit AtCommand", () => {
+    const ast = mustParse("$+finger *:@pemit %#=Hi");
+    assertEquals(ast.action.type, "AtCommand");
+    assertEquals(ast.action.name, "pemit");
+  });
+});
+
+describe("DollarPattern — action command lists", () => {
+  it("$hi:say Hi;@pemit %#=! → action is CommandList", () => {
+    const ast = mustParse("$hi:say Hi;@pemit %#=!");
+    assertEquals(ast.type, "DollarPattern");
+    assertEquals(ast.action.type, "CommandList");
+    assertEquals(ast.action.commands.length, 2);
+  });
+
+  it("action with eval block: $greet *:@pemit %#=[name(%0)]!", () => {
+    const ast = mustParse("$greet *:@pemit %#=[name(%0)]!");
+    const blocks = findAll(ast, "EvalBlock");
+    assertEquals(blocks.length >= 1, true);
+  });
+});
+
+describe("DollarPattern — pattern alternatives (;-separated)", () => {
+  it("$hi;hello;hey *:@pemit → PatternAlts with 3 patterns", () => {
+    const ast = mustParse("$hi;hello;hey *:@pemit %#=Greetings!");
+    assertEquals(ast.type, "DollarPattern");
+    assertEquals(ast.pattern.type, "PatternAlts");
+    assertEquals(ast.pattern.patterns.length, 3);
+  });
+
+  it("each alternative is a Pattern node", () => {
+    const ast = mustParse("$hi;hello:say Hi");
+    assertEquals(ast.pattern.patterns[0].type, "Pattern");
+    assertEquals(ast.pattern.patterns[1].type, "Pattern");
+  });
+
+  it("single alternative stays as Pattern (not PatternAlts)", () => {
+    const ast = mustParse("$greet *:say Hi");
+    assertEquals(ast.pattern.type, "Pattern");
+  });
+});
+
+describe("DollarPattern — wildcard variants", () => {
+  it("? wildcard: $+stat ? → single-char wildcard", () => {
+    const ast = mustParse("$+stat ?:say stat");
+    const wc = findAll(ast.pattern, "Wildcard");
+    assertEquals(wc[0].wildcard, "?");
+  });
+
+  it("multiple wildcards: $* *:say two wildcards", () => {
+    const ast = mustParse("$* *:say two");
+    const wc = findAll(ast.pattern, "Wildcard");
+    assertEquals(wc.length, 2);
+  });
+
+  it("escaped colon in pattern: $foo\\:bar:action", () => {
+    const ast = mustParse("$foo\\:bar:say action");
+    assertEquals(ast.type, "DollarPattern");
+    const esc = findAll(ast.pattern, "Escape");
+    assertEquals(esc[0].char, ":");
+  });
+});
+
+describe("DollarPattern — switch in pattern", () => {
+  it("$+stat/set *=*:action → = in pattern is literal", () => {
+    const ast = mustParse("$+stat/set *=*:@pemit %#=ok");
+    assertEquals(ast.type, "DollarPattern");
+    // pattern should have wildcards and '=' as literal
+    const wc = findAll(ast.pattern, "Wildcard");
+    assertEquals(wc.length >= 2, true);
+  });
+});
+
+describe("DollarPattern — complex real-world examples", () => {
+  it("finger pattern with u() call in action", () => {
+    const ast = mustParse("$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]");
+    assertEquals(ast.type, "DollarPattern");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "u");
+  });
+
+  it("gold give pattern: $+give *=*:@pemit ...", () => {
+    const src = "$+give *=*:@switch [isnum(%1)]=0,{@pemit %#=Not a number.},{@pemit %#=Gave.}";
+    const ast = mustParse(src);
+    assertEquals(ast.type, "DollarPattern");
+    assertEquals(ast.action.type, "AtCommand");
+  });
+});
+
+// ── ListenPattern ─────────────────────────────────────────────────────────────
+
+describe("ListenPattern — basic", () => {
+  it("^*hello*:@pemit → ListenPattern", () => {
+    const ast = mustParse("^*hello*:@pemit %#=I heard you");
+    assertEquals(ast.type, "ListenPattern");
+  });
+
+  it("pattern and action parsed same as DollarPattern", () => {
+    const ast = mustParse("^*hello*:@pemit %#=I heard you");
+    assertEquals(ast.pattern.type, "Pattern");
+    assertEquals(ast.action.type, "AtCommand");
+  });
+
+  it("^ with wildcard: ^* hi *:action → wildcard in pattern", () => {
+    const ast = mustParse("^* hi *:say heard it");
+    const wc = findAll(ast.pattern, "Wildcard");
+    assertEquals(wc.length >= 1, true);
+  });
+
+  it("^ with pattern alternatives: ^hi;hello:action", () => {
+    const ast = mustParse("^hi;hello:say hi");
+    assertEquals(ast.type, "ListenPattern");
+    assertEquals(ast.pattern.type, "PatternAlts");
+    assertEquals(ast.pattern.patterns.length, 2);
+  });
+});
+
+describe("DollarPattern vs ListenPattern disambiguation", () => {
+  it("$ → DollarPattern, ^ → ListenPattern, both are AttributeValue", () => {
+    const dp = mustParse("$greet *:say hi");
+    const lp = mustParse("^*hi*:say hi");
+    assertEquals(dp.type, "DollarPattern");
+    assertEquals(lp.type, "ListenPattern");
+  });
+});

package/node_modules/@ursamu/mushcode/tests/08-lock-expressions.test.ts

@@ -0,0 +1,159 @@
+// ============================================================================
+// 08 — Lock expressions (LockExpr start rule)
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { parseLock } from "./helpers.ts";
+
+describe("Lock primaries", () => {
+  it("me → LockMe", () => {
+    assertEquals(parseLock("me").type, "LockMe");
+  });
+
+  it("#123 → LockDbref", () => {
+    const ast = parseLock("#123");
+    assertEquals(ast.type, "LockDbref");
+    assertEquals(ast.dbref, "#123");
+  });
+
+  it("#-1 → LockDbref (negative dbref)", () => {
+    const ast = parseLock("#-1");
+    assertEquals(ast.type, "LockDbref");
+    assertEquals(ast.dbref, "#-1");
+  });
+
+  it("flag^WIZARD → LockFlagCheck", () => {
+    const ast = parseLock("flag^WIZARD");
+    assertEquals(ast.type, "LockFlagCheck");
+    assertEquals(ast.flag, "WIZARD");
+  });
+
+  it("type^ROOM → LockTypeCheck", () => {
+    const ast = parseLock("type^ROOM");
+    assertEquals(ast.type, "LockTypeCheck");
+    assertEquals(ast.typeName, "ROOM");
+  });
+
+  it("attr^MYATTR → LockAttrCheck", () => {
+    const ast = parseLock("attr^MYATTR");
+    assertEquals(ast.type, "LockAttrCheck");
+    assertEquals(ast.attribute, "MYATTR");
+  });
+
+  it("=PlayerName → LockPlayerName", () => {
+    const ast = parseLock("=Alice");
+    assertEquals(ast.type, "LockPlayerName");
+    assertEquals(ast.name, "Alice");
+  });
+
+  it("=Player Name → LockPlayerName preserves spaces", () => {
+    const ast = parseLock("=Player Name");
+    assertEquals(ast.type, "LockPlayerName");
+    assertEquals(ast.name, "Player Name");
+  });
+});
+
+describe("LockNot", () => {
+  it("!me → LockNot wrapping LockMe", () => {
+    const ast = parseLock("!me");
+    assertEquals(ast.type, "LockNot");
+    assertEquals(ast.operand.type, "LockMe");
+  });
+
+  it("!flag^WIZARD → LockNot wrapping LockFlagCheck", () => {
+    const ast = parseLock("!flag^WIZARD");
+    assertEquals(ast.type, "LockNot");
+    assertEquals(ast.operand.type, "LockFlagCheck");
+  });
+
+  it("!!me → double negation", () => {
+    const ast = parseLock("!!me");
+    assertEquals(ast.type, "LockNot");
+    assertEquals(ast.operand.type, "LockNot");
+  });
+});
+
+describe("LockOr (| operator)", () => {
+  it("me|#123 → LockOr with two operands", () => {
+    const ast = parseLock("me|#123");
+    assertEquals(ast.type, "LockOr");
+    assertEquals(ast.operands.length, 2);
+    assertEquals(ast.operands[0].type, "LockMe");
+    assertEquals(ast.operands[1].type, "LockDbref");
+  });
+
+  it("flag^WIZARD|flag^ADMIN → LockOr", () => {
+    const ast = parseLock("flag^WIZARD|flag^ADMIN");
+    assertEquals(ast.type, "LockOr");
+    assertEquals(ast.operands[0].flag, "WIZARD");
+    assertEquals(ast.operands[1].flag, "ADMIN");
+  });
+
+  it("a|b|c → LockOr with 3 operands (left-associative via PEG list)", () => {
+    const ast = parseLock("me|#123|#456");
+    assertEquals(ast.type, "LockOr");
+    assertEquals(ast.operands.length, 3);
+  });
+});
+
+describe("LockAnd (& operator)", () => {
+  it("me&#123 → LockAnd with two operands", () => {
+    const ast = parseLock("me&#123");
+    assertEquals(ast.type, "LockAnd");
+    assertEquals(ast.operands.length, 2);
+    assertEquals(ast.operands[0].type, "LockMe");
+    assertEquals(ast.operands[1].type, "LockDbref");
+  });
+
+  it("flag^WIZARD&flag^BUILDER → LockAnd", () => {
+    const ast = parseLock("flag^WIZARD&flag^BUILDER");
+    assertEquals(ast.type, "LockAnd");
+  });
+});
+
+describe("Operator precedence: & binds tighter than |", () => {
+  it("a|b&c → LockOr(a, LockAnd(b,c))", () => {
+    const ast = parseLock("me|flag^WIZARD&#123");
+    assertEquals(ast.type, "LockOr");
+    assertEquals(ast.operands[0].type, "LockMe");
+    assertEquals(ast.operands[1].type, "LockAnd");
+  });
+});
+
+describe("Parenthesized lock expressions", () => {
+  it("(me) → LockMe (parens stripped)", () => {
+    assertEquals(parseLock("(me)").type, "LockMe");
+  });
+
+  it("(me|#123)&flag^WIZARD → LockAnd(LockOr, LockFlagCheck)", () => {
+    const ast = parseLock("(me|#123)&flag^WIZARD");
+    assertEquals(ast.type, "LockAnd");
+    assertEquals(ast.operands[0].type, "LockOr");
+    assertEquals(ast.operands[1].type, "LockFlagCheck");
+  });
+});
+
+describe("Complex real-world lock expressions", () => {
+  it("flag^WIZARD|flag^ADMIN → wizard or admin", () => {
+    const ast = parseLock("flag^WIZARD|flag^ADMIN");
+    assertEquals(ast.type, "LockOr");
+  });
+
+  it("me|=Alice → owner or specific player", () => {
+    const ast = parseLock("me|=Alice");
+    assertEquals(ast.type, "LockOr");
+    assertEquals(ast.operands[1].type, "LockPlayerName");
+  });
+
+  it("!me → not owner", () => {
+    assertEquals(parseLock("!me").type, "LockNot");
+  });
+
+  it("attr^STAFF|flag^WIZARD → attr check or flag check", () => {
+    const ast = parseLock("attr^STAFF|flag^WIZARD");
+    assertEquals(ast.type, "LockOr");
+    assertEquals(ast.operands[0].type, "LockAttrCheck");
+    assertEquals(ast.operands[1].type, "LockFlagCheck");
+  });
+});

package/node_modules/@ursamu/mushcode/tests/09-edge-cases.test.ts

@@ -0,0 +1,162 @@
+// ============================================================================
+// 09 — Edge cases, deep nesting, real-world patterns
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+describe("Deep nesting", () => {
+  it("5-level nested function calls parse without error", () => {
+    const src = "[if(gt(abs(add(mul(%0,2),3)),10),yes,no)]";
+    const ast = mustParse(src);
+    // Start wraps in UserCommand; the eval block is the first part
+    assertEquals(ast.parts[0].type, "EvalBlock");
+    const fns = findAll(ast, "FunctionCall");
+    assertEquals(fns.length >= 4, true);
+  });
+
+  it("deeply nested braces {{{{{inner}}}}} parse without error", () => {
+    const ast = mustParse("{{{{{inner}}}}}");
+    const braces = findAll(ast, "BracedString");
+    assertEquals(braces.length, 5);
+  });
+
+  it("nested eval inside brace inside function: [f({[g(x)]})] parses", () => {
+    const ast = mustParse("[f({[g(x)]})]");
+    const fns = findAll(ast, "FunctionCall");
+    assertEquals(fns.length, 2);
+  });
+});
+
+describe("Real-world softcode patterns", () => {
+  it("+finger command with u() delegation", () => {
+    const src = "$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]";
+    const ast = mustParse(src);
+    assertEquals(ast.type, "DollarPattern");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "u");
+    assertEquals(fn.args[0].parts[0].value, "me/FN_FINGER");
+  });
+
+  it("+who with iter over lwho()", () => {
+    const src = "$+who:@pemit %#=[iter(lwho(),[name(##)] (#[loc(##)]),%r)]";
+    const ast = mustParse(src);
+    assertEquals(ast.type, "DollarPattern");
+    const iter = findFirst(ast, "FunctionCall");
+    assertEquals(iter.name === "iter" || findAll(ast, "FunctionCall").some(f => f.name === "iter"), true);
+  });
+
+  it("@switch with setq and register read", () => {
+    const src = "@switch [setq(0,pmatch(%0))]=1,{@pemit %#=Found: [r(0)]},{@pemit %#=Not found.}";
+    const ast = mustParse(src);
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "switch");
+    const braces = findAll(ast.value, "BracedString");
+    assertEquals(braces.length, 2);
+  });
+
+  it("@dolist with iter ##", () => {
+    const src = "@dolist [lwho()]={@pemit ##=Restart in 5 minutes.}";
+    const ast = mustParse(src);
+    assertEquals(ast.name, "dolist");
+    const sv = findAll(ast, "SpecialVar");
+    assertEquals(sv.length >= 1, true);
+  });
+
+  it("score display with column formatting", () => {
+    const src = "[ljust(Name,20)][rjust(Score,10)]";
+    const ast = mustParse(src);
+    const fns = findAll(ast, "FunctionCall");
+    assertEquals(fns.some(f => f.name === "ljust"), true);
+    assertEquals(fns.some(f => f.name === "rjust"), true);
+  });
+});
+
+describe("ANSI formatting patterns", () => {
+  it("%ch%crRed Bold Text%cn parses as 4 substitutions", () => {
+    const ast = mustParse("%ch%crRed Bold Text%cn");
+    const subs = findAll(ast, "Substitution");
+    assertEquals(subs.length, 3); // ch, cr, cn
+  });
+
+  it("ansi() function call", () => {
+    const ast = mustParse("[ansi(hg,SUCCESS)]");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "ansi");
+    assertEquals(fn.args[0].parts[0].value, "hg");
+  });
+});
+
+describe("Multiple commands with complex content", () => {
+  it("three-command sequence with eval blocks", () => {
+    const src = "@pemit %#=Step 1: [add(1,1)];@pemit %#=Step 2: [mul(2,2)];@pemit %#=Done";
+    const ast = mustParse(src);
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands.length, 3);
+  });
+
+  it("attribute set followed by trigger", () => {
+    const src = "&TEMP me=[add(%0,1)];@trigger me/DO_THING=%qresult";
+    const ast = mustParse(src);
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands[0].type, "AttributeSet");
+    assertEquals(ast.commands[1].type, "AtCommand");
+  });
+});
+
+describe("Whitespace handling", () => {
+  it("leading/trailing whitespace stripped by Start rule", () => {
+    const ast = mustParse("  @pemit %#=hi  ");
+    assertEquals(ast.type, "AtCommand");
+  });
+
+  it("@pemit with space before object: '@pemit   me=hi' parses", () => {
+    const ast = mustParse("@pemit   me=hi");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "pemit");
+  });
+});
+
+describe("Special dbref syntax in object positions", () => {
+  it("#123 in @trigger object position", () => {
+    const ast = mustParse("@trigger #123/ATTR=hello");
+    assertEquals(ast.type, "AtCommand");
+    // Object should contain a '#' literal followed by '123/ATTR'
+    const lits = findAll(ast.object, "Literal");
+    // deno-lint-ignore no-explicit-any
+    const joined = lits.map((l) => (l as any).value as string).join("");
+    assertEquals(joined.includes("#123"), true);
+  });
+
+  it("##-based iteration: [iter(list,## has [strlen(##)] chars)]", () => {
+    const ast = mustParse("[iter(list,## has [strlen(##)] chars)]");
+    const sv = findAll(ast, "SpecialVar");
+    assertEquals(sv.length, 2);
+    // deno-lint-ignore no-explicit-any
+    assertEquals(sv.every((s) => (s as any).code === "##"), true);
+  });
+});
+
+describe("Empty command list elements", () => {
+  it("single command with no content → UserCommand with empty parts", () => {
+    const ast = mustParse("");
+    assertEquals(ast.type, "UserCommand");
+    assertEquals(ast.parts.length, 0);
+  });
+});
+
+describe("Percent-sign edge cases", () => {
+  it("%% → single Substitution with code '%'", () => {
+    const subs = findAll(mustParse("%%"), "Substitution");
+    assertEquals(subs.length, 1);
+    assertEquals(subs[0].code, "%");
+  });
+
+  it("100% → literal '100' then Substitution(unknown?) → graceful", () => {
+    // % at end of input with no code — grammar either errors or produces Substitution
+    // Just verify it doesn't crash when % has a following char
+    const ast = mustParse("100%%");
+    assertEquals(findAll(ast, "Substitution").length, 1);
+  });
+});

package/node_modules/@ursamu/mushcode/tests/10-regression.test.ts

@@ -0,0 +1,211 @@
+// ============================================================================
+// 10 — Regression tests for every bug fixed in mux-softcode.pegjs
+//
+// Each test is named after the bug it covers and includes a "was broken"
+// comment explaining the pre-fix behaviour.
+// ============================================================================
+
+import { assertEquals, assertNotEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+// ── BUG 1: %: (enactor objid) was not in SubCode ─────────────────────────────
+
+describe("BUG-1: %: enactor objid substitution", () => {
+  it("%: parses as Substitution(code=':')", () => {
+    // Was: parse error — ':' not in single-char class
+    const subs = findAll(mustParse("%:"), "Substitution");
+    assertEquals(subs.length, 1);
+    assertEquals(subs[0].code, ":");
+  });
+
+  it("%: works inside a function argument", () => {
+    // Was: parse error inside function arg
+    const fn = findFirst(mustParse("[f(%:)]"), "FunctionCall");
+    assertEquals(fn.args[0].parts[0].code, ":");
+  });
+
+  it("%: works in @pemit value", () => {
+    const ast = mustParse("@pemit %#=ObjID=%:");
+    // deno-lint-ignore no-explicit-any
+    assertEquals(findAll(ast.value, "Substitution").some((s) => (s as any).code === ":"), true);
+  });
+});
+
+// ── BUG 2: %k/%K (moniker) was not in SubCode ────────────────────────────────
+
+describe("BUG-2: %k/%K moniker substitution", () => {
+  it("%k parses as Substitution(code='k')", () => {
+    // Was: parse error
+    const subs = findAll(mustParse("%k"), "Substitution");
+    assertEquals(subs.length, 1);
+    assertEquals(subs[0].code, "k");
+  });
+
+  it("%K parses as Substitution(code='K')", () => {
+    const subs = findAll(mustParse("%K"), "Substitution");
+    assertEquals(subs.length, 1);
+    assertEquals(subs[0].code, "K");
+  });
+
+  it("%k in an @pemit value parses correctly", () => {
+    const ast = mustParse("@pemit %#=Hello, %k!");
+    assertNotEquals(findAll(ast.value, "Substitution").length, 0);
+  });
+});
+
+// ── BUG 3: %qA–%qZ (uppercase register names) ────────────────────────────────
+
+describe("BUG-3: %qA–%qZ uppercase register names", () => {
+  const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  for (const c of uppercase) {
+    it(`%q${c} parses as Substitution(code='q${c}')`, () => {
+      // Was: SubCode tried "q" n:[0-9a-z] — uppercase letters fell through
+      // to the single-char fallback which also didn't include 'q', causing parse error.
+      const subs = findAll(mustParse(`%q${c}`), "Substitution");
+      assertEquals(subs.length, 1);
+      assertEquals(subs[0].code, `q${c}`);
+    });
+  }
+});
+
+// ── BUG 4: Named registers (%qfoo, %qmy_reg) ─────────────────────────────────
+
+describe("BUG-4: Named registers (multi-char)", () => {
+  it("%qfoo parses as Substitution(code='qfoo')", () => {
+    const subs = findAll(mustParse("%qfoo"), "Substitution");
+    assertEquals(subs[0].code, "qfoo");
+  });
+
+  it("%qmy_reg parses correctly", () => {
+    const subs = findAll(mustParse("%qmy_reg"), "Substitution");
+    assertEquals(subs[0].code, "qmy_reg");
+  });
+
+  it("%qResult (mixed-case) parses correctly", () => {
+    const subs = findAll(mustParse("%qResult"), "Substitution");
+    assertEquals(subs[0].code, "qResult");
+  });
+
+  it("%q0 (single digit) still works as before", () => {
+    const subs = findAll(mustParse("%q0"), "Substitution");
+    assertEquals(subs[0].code, "q0");
+  });
+
+  it("%qa (single letter) still works as before", () => {
+    const subs = findAll(mustParse("%qa"), "Substitution");
+    assertEquals(subs[0].code, "qa");
+  });
+});
+
+// ── BUG 5: Bare ( in function arguments caused parse error ───────────────────
+
+describe("BUG-5: Bare ( in function arguments", () => {
+  it("add(1,(2)) — (2) parses as Literal '(2)'", () => {
+    // Was: ArgLiteralChars excluded '(' so parsing failed
+    const fn = findFirst(mustParse("[add(1,(2))]"), "FunctionCall");
+    assertEquals(fn.args[1].parts[0].value, "(2)");
+  });
+
+  it("pemit(%#,(text)) — (text) is a literal arg", () => {
+    const fn = findFirst(mustParse("[pemit(%#,(text))]"), "FunctionCall");
+    assertEquals(fn.args[1].parts[0].value, "(text)");
+  });
+
+  it("f((a)) — ((a)) is a literal wrapping a", () => {
+    const fn = findFirst(mustParse("[f((a))]"), "FunctionCall");
+    assertEquals(fn.args[0].parts[0].value, "(a)");
+  });
+
+  it("nested balanced parens: f(((x))) — (((x))) as Literal", () => {
+    const fn = findFirst(mustParse("[f(((x)))]"), "FunctionCall");
+    assertEquals(fn.args[0].parts[0].value, "((x))");
+  });
+
+  it("mix of function call and paren group: f(add(1,2),(x)) — correct arg count", () => {
+    const fn = findFirst(mustParse("[f(add(1,2),(x))]"), "FunctionCall");
+    assertEquals(fn.name, "f");
+    assertEquals(fn.args.length, 2);
+    const inner = findFirst(fn.args[0], "FunctionCall");
+    assertEquals(inner.name, "add");
+    assertEquals(fn.args[1].parts[0].value, "(x)");
+  });
+});
+
+// ── BUG 6: ^ listen patterns not recognised ──────────────────────────────────
+
+describe("BUG-6: ^-listen patterns", () => {
+  it("^*hello*:action → ListenPattern (was: parsed as UserCommand)", () => {
+    // Was: AttributeValue = DollarPattern / CommandList — ^ not handled
+    const ast = mustParse("^*hello*:@pemit %#=Heard it");
+    assertEquals(ast.type, "ListenPattern");
+  });
+
+  it("ListenPattern has pattern and action like DollarPattern", () => {
+    const ast = mustParse("^*hi*:say hi");
+    assertEquals(ast.pattern.type, "Pattern");
+    assertEquals(ast.action.type, "UserCommand");
+  });
+
+  it("^ with alternatives: ^hi;hello:action → PatternAlts", () => {
+    const ast = mustParse("^hi;hello:say heard");
+    assertEquals(ast.pattern.type, "PatternAlts");
+  });
+
+  it("listen pattern does NOT change parse of DollarPattern", () => {
+    const ast = mustParse("$greet *:say hi");
+    assertEquals(ast.type, "DollarPattern");
+  });
+});
+
+// ── BUG 7: &ATTR obj (no =value) treated as UserCommand ──────────────────────
+
+describe("BUG-7: AttributeSet without = (clear attribute form)", () => {
+  it("&SCORE me → AttributeSet, value:null (was: UserCommand)", () => {
+    // Was: AttributeSet required '=', so '&SCORE me' fell to UserCommand
+    const ast = mustParse("&SCORE me");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.attribute, "SCORE");
+    assertEquals(ast.value, null);
+  });
+
+  it("&CMD_WALK me → AttributeSet attribute='CMD_WALK'", () => {
+    const ast = mustParse("&CMD_WALK me");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.attribute, "CMD_WALK");
+  });
+
+  it("&ATTR obj=val → still works (normal form unaffected)", () => {
+    const ast = mustParse("&ATTR me=hello");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.value.parts[0].value, "hello");
+  });
+
+  it("&ATTR in command list: @pemit %#=ok;&SCORE me → two commands", () => {
+    const ast = mustParse("@pemit %#=ok;&SCORE me");
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands[1].type, "AttributeSet");
+    assertEquals(ast.commands[1].value, null);
+  });
+});
+
+// ── BUG 8: %=ATTR substitution not handled ───────────────────────────────────
+
+describe("BUG-8: %=attr substitution", () => {
+  it("%=SCORE → Substitution(code='=SCORE')", () => {
+    const subs = findAll(mustParse("%=SCORE"), "Substitution");
+    assertEquals(subs.length, 1);
+    assertEquals(subs[0].code, "=SCORE");
+  });
+
+  it("%=MY_ATTR → Substitution with hyphenated name", () => {
+    const subs = findAll(mustParse("%=MY_ATTR"), "Substitution");
+    assertEquals(subs[0].code, "=MY_ATTR");
+  });
+
+  it("%=SCORE works inside a function arg", () => {
+    const fn = findFirst(mustParse("[pemit(%#,%=SCORE)]"), "FunctionCall");
+    assertEquals(fn.args[1].parts[0].code, "=SCORE");
+  });
+});