@rhost/testkit 1.5.0 → 1.5.2

package/node_modules/@ursamu/mushcode/tests/03-function-calls.test.ts

@@ -0,0 +1,184 @@
+// ============================================================================
+// 03 — Function calls inside eval blocks
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+function evalFn(src: string) {
+  const ast = mustParse(src);
+  return findFirst(ast, "FunctionCall");
+}
+
+describe("Zero-argument functions", () => {
+  it("lwho()  → FunctionCall, args:[]", () => {
+    const fn = evalFn("[lwho()]");
+    assertEquals(fn.name, "lwho");
+    assertEquals(fn.args.length, 0);
+  });
+
+  it("secs()  → FunctionCall, args:[]", () => {
+    const fn = evalFn("[secs()]");
+    assertEquals(fn.name, "secs");
+    assertEquals(fn.args.length, 0);
+  });
+
+  it("time()  → FunctionCall, args:[]", () => {
+    const fn = evalFn("[time()]");
+    assertEquals(fn.name, "time");
+    assertEquals(fn.args.length, 0);
+  });
+});
+
+describe("One-argument functions", () => {
+  it("name(%#) → FunctionCall, 1 arg containing Substitution", () => {
+    const fn = evalFn("[name(%#)]");
+    assertEquals(fn.name, "name");
+    assertEquals(fn.args.length, 1);
+    assertEquals(fn.args[0].parts[0].type, "Substitution");
+    assertEquals(fn.args[0].parts[0].code, "#");
+  });
+
+  it("strlen(hello) → FunctionCall, 1 literal arg", () => {
+    const fn = evalFn("[strlen(hello)]");
+    assertEquals(fn.args[0].parts[0].value, "hello");
+  });
+});
+
+describe("Multi-argument functions", () => {
+  it("add(1,2) → two literal args", () => {
+    const fn = evalFn("[add(1,2)]");
+    assertEquals(fn.name, "add");
+    assertEquals(fn.args.length, 2);
+    assertEquals(fn.args[0].parts[0].value, "1");
+    assertEquals(fn.args[1].parts[0].value, "2");
+  });
+
+  it("if(gt(%0,10),big,small) → 3 args", () => {
+    const fn = evalFn("[if(gt(%0,10),big,small)]");
+    assertEquals(fn.name, "if");
+    assertEquals(fn.args.length, 3);
+  });
+
+  it("setq(0,hello) → 2 args, first is digit literal", () => {
+    const fn = evalFn("[setq(0,hello)]");
+    assertEquals(fn.args[0].parts[0].value, "0");
+    assertEquals(fn.args[1].parts[0].value, "hello");
+  });
+});
+
+describe("Empty arguments", () => {
+  it("setq(0,) → second arg is empty Arg node", () => {
+    const fn = evalFn("[setq(0,)]");
+    assertEquals(fn.args.length, 2);
+    assertEquals(fn.args[1].parts.length, 0);
+  });
+
+  it("f(,b) → first arg empty, second is 'b'", () => {
+    const fn = evalFn("[f(,b)]");
+    assertEquals(fn.args[0].parts.length, 0);
+    assertEquals(fn.args[1].parts[0].value, "b");
+  });
+
+  it("iter(list,,delim) → middle arg is empty", () => {
+    const fn = evalFn("[iter(list,,delim)]");
+    assertEquals(fn.args.length, 3);
+    assertEquals(fn.args[1].parts.length, 0);
+  });
+});
+
+describe("Nested function calls", () => {
+  it("add(mul(2,3),1) → outer add, inner mul", () => {
+    const add = evalFn("[add(mul(2,3),1)]");
+    assertEquals(add.name, "add");
+    const mul = findFirst(add.args[0], "FunctionCall");
+    assertEquals(mul.name, "mul");
+    assertEquals(mul.args[0].parts[0].value, "2");
+    assertEquals(mul.args[1].parts[0].value, "3");
+  });
+
+  it("if(gt(%0,10),big,small) → nested gt inside if", () => {
+    const ifFn = evalFn("[if(gt(%0,10),big,small)]");
+    const gt = findFirst(ifFn.args[0], "FunctionCall");
+    assertEquals(gt.name, "gt");
+  });
+
+  it("setq(0,pmatch(trim(%0))) → 3 levels of nesting", () => {
+    const fn = evalFn("[setq(0,pmatch(trim(%0)))]");
+    assertEquals(fn.name, "setq");
+    const pmatch = findFirst(fn.args[1], "FunctionCall");
+    assertEquals(pmatch.name, "pmatch");
+    const trim = findFirst(pmatch.args[0], "FunctionCall");
+    assertEquals(trim.name, "trim");
+  });
+});
+
+describe("Function call with substitutions in args", () => {
+  it("u(me/FN_FINGER,%0) → u with 2 args, second is Substitution(0)", () => {
+    const fn = evalFn("[u(me/FN_FINGER,%0)]");
+    assertEquals(fn.name, "u");
+    assertEquals(fn.args[0].parts[0].value, "me/FN_FINGER");
+    assertEquals(fn.args[1].parts[0].code, "0");
+  });
+
+  it("ansi(hg,SUCCESS) → 2 literal args", () => {
+    const fn = evalFn("[ansi(hg,SUCCESS)]");
+    assertEquals(fn.args[0].parts[0].value, "hg");
+    assertEquals(fn.args[1].parts[0].value, "SUCCESS");
+  });
+});
+
+describe("Back-to-back eval blocks", () => {
+  it("[setq(0,hello)][r(0)] → two FunctionCalls", () => {
+    const ast = mustParse("[setq(0,hello)][r(0)]");
+    const fns = findAll(ast, "FunctionCall");
+    assertEquals(fns.length, 2);
+    assertEquals(fns[0].name, "setq");
+    assertEquals(fns[1].name, "r");
+  });
+});
+
+describe("Function args with braces protecting commas", () => {
+  it("iter([lcon(%L)],{##: name},, ) → brace-protected output template", () => {
+    const fn = evalFn("[iter([lcon(%L)],{##: name},,)]");
+    assertEquals(fn.name, "iter");
+    assertEquals(fn.args[1].parts[0].type, "BracedString");
+  });
+});
+
+describe("Case-insensitive function names (grammar preserves case)", () => {
+  it("ADD(1,2) → name is 'ADD'", () => {
+    const fn = evalFn("[ADD(1,2)]");
+    assertEquals(fn.name, "ADD");
+  });
+
+  it("Strlen(x) → name is 'Strlen'", () => {
+    const fn = evalFn("[Strlen(x)]");
+    assertEquals(fn.name, "Strlen");
+  });
+});
+
+describe("Underscore-prefixed function names", () => {
+  it("_myfunc(x) → FunctionCall with name '_myfunc'", () => {
+    const fn = evalFn("[_myfunc(x)]");
+    assertEquals(fn.name, "_myfunc");
+  });
+});
+
+describe("Bare ( in argument (was broken before fix)", () => {
+  it("add(1,(2)) → second arg is Literal '(2)'", () => {
+    const fn = evalFn("[add(1,(2))]");
+    assertEquals(fn.args[1].parts[0].value, "(2)");
+  });
+
+  it("pemit(%#,(text)) → second arg contains literal (text)", () => {
+    const fn = evalFn("[pemit(%#,(text))]");
+    assertEquals(fn.args[1].parts[0].value, "(text)");
+  });
+
+  it("ansi(h,(bold text)) → literal (bold text) as arg", () => {
+    const fn = evalFn("[ansi(h,(bold text))]");
+    assertEquals(fn.args[1].parts[0].value, "(bold text)");
+  });
+});

package/node_modules/@ursamu/mushcode/tests/04-eval-blocks.test.ts

@@ -0,0 +1,110 @@
+// ============================================================================
+// 04 — Eval blocks  [ ... ]
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+describe("Basic eval blocks", () => {
+  it("[add(1,2)] → EvalBlock containing FunctionCall", () => {
+    const ast = mustParse("[add(1,2)]");
+    // Start always returns UserCommand; the eval block is its first part
+    assertEquals(ast.type, "UserCommand");
+    assertEquals(ast.parts[0].type, "EvalBlock");
+  });
+
+  it("[name(%#)] → EvalBlock with FunctionCall(name)", () => {
+    const ast = mustParse("[name(%#)]");
+    assertEquals(ast.parts[0].type, "EvalBlock");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "name");
+  });
+
+  it("text before eval: hello [name(%#)] → UserCommand with mixed parts", () => {
+    const ast = mustParse("hello [name(%#)]");
+    assertEquals(ast.type, "UserCommand");
+    const blocks = findAll(ast, "EvalBlock");
+    assertEquals(blocks.length, 1);
+  });
+});
+
+describe("Nested eval blocks", () => {
+  it("[[lwho()]] → outer EvalBlock wrapping inner EvalBlock", () => {
+    const ast = mustParse("[[lwho()]]");
+    assertEquals(ast.parts[0].type, "EvalBlock");
+    const inner = findAll(ast, "EvalBlock");
+    // outer + inner
+    assertEquals(inner.length >= 2, true);
+  });
+
+  it("[add([mul(2,3)],1)] → nested function in arg", () => {
+    const outer = findFirst(mustParse("[add([mul(2,3)],1)]"), "FunctionCall");
+    assertEquals(outer.name, "add");
+    const innerBlock = findFirst(outer.args[0], "EvalBlock");
+    assertEquals(innerBlock.type, "EvalBlock");
+    const mul = findFirst(innerBlock, "FunctionCall");
+    assertEquals(mul.name, "mul");
+  });
+});
+
+describe("Multiple eval blocks in sequence", () => {
+  it("[setq(0,hello)][r(0)] → two top-level EvalBlocks", () => {
+    const ast = mustParse("[setq(0,hello)][r(0)]");
+    assertEquals(ast.type, "UserCommand");
+    const blocks = findAll(ast, "EvalBlock");
+    assertEquals(blocks.length, 2);
+  });
+
+  it("Name: [name(%#)] (Loc: [loc(%#)]) → two blocks interleaved in text", () => {
+    const ast = mustParse("Name: [name(%#)] Loc: [loc(%#)]");
+    const blocks = findAll(ast, "EvalBlock");
+    assertEquals(blocks.length, 2);
+  });
+});
+
+describe("Eval block in AtCommand value", () => {
+  it("@pemit %#=Hello [name(%#)]! → EvalBlock in value", () => {
+    const ast = mustParse("@pemit %#=Hello [name(%#)]!");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "pemit");
+    const blocks = findAll(ast.value, "EvalBlock");
+    assertEquals(blocks.length, 1);
+  });
+});
+
+describe("Eval block in dollar pattern action", () => {
+  it("$+finger *:@pemit %#=[u(me/FN_FINGER,%0)] → EvalBlock in action", () => {
+    const ast = mustParse("$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]");
+    assertEquals(ast.type, "DollarPattern");
+    const blocks = findAll(ast, "EvalBlock");
+    assertEquals(blocks.length >= 1, true);
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "u");
+  });
+});
+
+describe("Eval blocks with substitutions", () => {
+  it("[r(%q0)] → EvalBlock with FunctionCall using register sub", () => {
+    const ast = mustParse("[r(%q0)]");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "r");
+    assertEquals(fn.args[0].parts[0].type, "Substitution");
+    assertEquals(fn.args[0].parts[0].code, "q0");  // %q0 → register named q0
+  });
+
+  it("[r(%qA)] → register %qA works in eval (was broken)", () => {
+    const ast = mustParse("[r(%qA)]");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.args[0].parts[0].code, "qA");
+  });
+});
+
+describe("Eval block containing only literal text", () => {
+  it("[hello] → EvalBlock with Literal parts", () => {
+    const ast = mustParse("[hello]");
+    assertEquals(ast.parts[0].type, "EvalBlock");
+    const lits = findAll(ast, "Literal");
+    assertEquals(lits[0].value, "hello");
+  });
+});

package/node_modules/@ursamu/mushcode/tests/05-braced-strings.test.ts

@@ -0,0 +1,119 @@
+// ============================================================================
+// 05 — Braced strings  { ... }
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+describe("Basic braced strings", () => {
+  it("{text} → BracedString with Literal", () => {
+    // Start returns UserCommand; the braced string is the first (and only) part
+    const ast = mustParse("{text}");
+    assertEquals(ast.parts[0].type, "BracedString");
+    assertEquals(ast.parts[0].parts[0].value, "text");
+  });
+
+  it("{} → empty BracedString", () => {
+    const ast = mustParse("{}");
+    assertEquals(ast.parts[0].type, "BracedString");
+    assertEquals(ast.parts[0].parts.length, 0);
+  });
+
+  it("{don't;split;this} → semicolons are literals inside braces", () => {
+    const ast = mustParse("{don't;split;this}");
+    assertEquals(ast.parts[0].type, "BracedString");
+    // Only one BracedString — the semicolons did not create a CommandList
+    assertEquals(findAll(ast, "CommandList").length, 0);
+  });
+
+  it("{a,b,c} → commas are literals inside braces", () => {
+    const ast = mustParse("{a,b,c}");
+    assertEquals(ast.parts[0].type, "BracedString");
+    // All text with commas coalesced into one Literal
+    assertEquals(findAll(ast, "Literal")[0].value, "a,b,c");
+  });
+});
+
+describe("Nested braces", () => {
+  it("{ outer { inner } more } → nested BracedStrings", () => {
+    const ast = mustParse("{ outer { inner } more }");
+    assertEquals(ast.parts[0].type, "BracedString");
+    const nested = findAll(ast.parts[0], "BracedString");
+    // outer BracedString + one inner
+    assertEquals(nested.length, 2);
+  });
+
+  it("{{{deep}}} → triple nesting", () => {
+    const ast = mustParse("{{{deep}}}");
+    const all = findAll(ast, "BracedString");
+    assertEquals(all.length, 3);
+  });
+});
+
+describe("Eval blocks still active inside braces", () => {
+  it("{[add(1,2)]} → EvalBlock inside BracedString", () => {
+    const ast = mustParse("{[add(1,2)]}");
+    assertEquals(ast.parts[0].type, "BracedString");
+    const block = findFirst(ast, "EvalBlock");
+    assertEquals(block.type, "EvalBlock");
+  });
+
+  it("{@pemit %#=Hello, %0!} → substitution inside brace", () => {
+    const ast = mustParse("{@pemit %#=Hello, %0!}");
+    const subs = findAll(ast, "Substitution");
+    assertEquals(subs.length >= 1, true);
+  });
+});
+
+describe("Braces in command list actions", () => {
+  it("@dolist lwho()={@pemit ##=Restart in 5 min.} → single command in brace", () => {
+    const ast = mustParse("@dolist lwho()={@pemit ##=Restart in 5 min.}");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "dolist");
+    // The value is a BracedString wrapping the @pemit command
+    const brace = findFirst(ast.value, "BracedString");
+    assertEquals(brace.type, "BracedString");
+  });
+
+  it("@switch x=1,{big},{small} → brace-protected command bodies", () => {
+    const ast = mustParse("@switch x=1,{big},{small}");
+    assertEquals(ast.type, "AtCommand");
+    const braces = findAll(ast.value, "BracedString");
+    assertEquals(braces.length, 2);
+  });
+});
+
+describe("Braces in function arguments protect commas", () => {
+  it("iter(list,{##: score},, ) → brace protects colon-space in template", () => {
+    const ast = mustParse("[iter(list,{##: score},,)]");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.name, "iter");
+    assertEquals(fn.args[1].parts[0].type, "BracedString");
+  });
+
+  it("f({a,b}) → single arg because comma is inside braces", () => {
+    const fn = findFirst(mustParse("[f({a,b})]"), "FunctionCall");
+    assertEquals(fn.args.length, 1);
+    assertEquals(fn.args[0].parts[0].type, "BracedString");
+  });
+});
+
+describe("Braces with special chars that would otherwise break parsing", () => {
+  it("{use \\; here} → escape inside brace", () => {
+    const ast = mustParse("{use \\; here}");
+    const esc = findAll(ast, "Escape");
+    assertEquals(esc.length, 1);
+    assertEquals(esc[0].char, ";");
+  });
+
+  it("{has = sign} → equals sign is literal inside brace", () => {
+    const ast = mustParse("{has = sign}");
+    assertEquals(ast.parts[0].type, "BracedString");
+    // should parse without treating = as command separator
+    const lits = findAll(ast.parts[0], "Literal");
+    // deno-lint-ignore no-explicit-any
+    const combined = lits.map((l) => (l as any).value as string).join("");
+    assertEquals(combined.includes("="), true);
+  });
+});

package/node_modules/@ursamu/mushcode/tests/06-commands.test.ts

@@ -0,0 +1,222 @@
+// ============================================================================
+// 06 — Commands: @commands, &attribute-set, user commands, command lists
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { mustParse, findAll, findFirst } from "./helpers.ts";
+
+// ── @commands ─────────────────────────────────────────────────────────────────
+
+describe("@commands — basic", () => {
+  it("@pemit %#=Hello → AtCommand(pemit), object=%#, value=Hello", () => {
+    const ast = mustParse("@pemit %#=Hello");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "pemit");
+    assertEquals(ast.switches.length, 0);
+    assertEquals(ast.object.parts[0].type, "Substitution");
+    assertEquals(ast.object.parts[0].code, "#");
+  });
+
+  it("@set me=SAFE → AtCommand(set), object=me, value=SAFE", () => {
+    const ast = mustParse("@set me=SAFE");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "set");
+    assertEquals(ast.object.parts[0].value, "me");
+  });
+
+  it("@examine → AtCommand with no body (object:null, value:null)", () => {
+    const ast = mustParse("@examine");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "examine");
+    assertEquals(ast.object, null);
+    assertEquals(ast.value, null);
+  });
+
+  it("@examine Wizard → AtCommand with object only, no =value", () => {
+    const ast = mustParse("@examine Wizard");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.object.parts[0].value, "Wizard");
+    assertEquals(ast.value, null);
+  });
+});
+
+describe("@commands — switches", () => {
+  it("@lock/enter me=flag^WIZARD → one switch 'enter'", () => {
+    const ast = mustParse("@lock/enter me=flag^WIZARD");
+    assertEquals(ast.type, "AtCommand");
+    assertEquals(ast.name, "lock");
+    assertEquals(ast.switches, ["enter"]);
+  });
+
+  it("@pemit/list/noeval %#=x → two switches", () => {
+    const ast = mustParse("@pemit/list/noeval %#=x");
+    assertEquals(ast.switches, ["list", "noeval"]);
+  });
+
+  it("@trigger me/ATTR=arg1,arg2 → no switches, object=me/ATTR", () => {
+    const ast = mustParse("@trigger me/ATTR=arg1,arg2");
+    assertEquals(ast.name, "trigger");
+    assertEquals(ast.switches.length, 0);
+  });
+});
+
+describe("@commands — complex objects and values", () => {
+  it("@pemit %#=[u(me/FN,%0)] → eval block in value", () => {
+    const ast = mustParse("@pemit %#=[u(me/FN,%0)]");
+    const blocks = findAll(ast.value, "EvalBlock");
+    assertEquals(blocks.length, 1);
+  });
+
+  it("@trigger #123/ATTR=hello → dbref object", () => {
+    const ast = mustParse("@trigger #123/ATTR=hello");
+    assertEquals(ast.name, "trigger");
+  });
+
+  it("@dolist [lwho()]={@pemit ##=Restart} → eval in object position", () => {
+    const ast = mustParse("@dolist [lwho()]={@pemit ##=Restart}");
+    assertEquals(ast.name, "dolist");
+    const block = findFirst(ast.object, "EvalBlock");
+    assertEquals(block.type, "EvalBlock");
+  });
+
+  it("@switch [gt(%0,10)]=1,{big},{small} → value has BracedStrings", () => {
+    const ast = mustParse("@switch [gt(%0,10)]=1,{big},{small}");
+    assertEquals(ast.name, "switch");
+    const braces = findAll(ast.value, "BracedString");
+    assertEquals(braces.length, 2);
+  });
+});
+
+// ── &attribute-set ────────────────────────────────────────────────────────────
+
+describe("&attribute-set commands", () => {
+  it("&DATA_SCORE me=100 → AttributeSet", () => {
+    const ast = mustParse("&DATA_SCORE me=100");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.attribute, "DATA_SCORE");
+    assertEquals(ast.value.parts[0].value, "100");
+  });
+
+  it("&FN_ADD me=[add(%0,%1)] → value is EvalBlock", () => {
+    const ast = mustParse("&FN_ADD me=[add(%0,%1)]");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.attribute, "FN_ADD");
+    const block = findFirst(ast.value, "EvalBlock");
+    assertEquals(block.type, "EvalBlock");
+  });
+
+  it("&CMD_FINGER Global=$+finger * → sets a dollar-pattern value", () => {
+    const ast = mustParse("&CMD_FINGER Global=$+finger *:@pemit %#=Hello");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.value.type, "DollarPattern");
+  });
+
+  it("&SCORE me (no =) → AttributeSet with value:null (clear form)", () => {
+    const ast = mustParse("&SCORE me");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.attribute, "SCORE");
+    assertEquals(ast.value, null);
+  });
+
+  it("&MY-ATTR me=x → hyphen in attribute name", () => {
+    const ast = mustParse("&MY-ATTR me=x");
+    assertEquals(ast.attribute, "MY-ATTR");
+  });
+});
+
+// ── RhostMUSH hidden attribute convention (_-prefix) ─────────────────────────
+
+describe("hidden attribute flag (_-prefix, RhostMUSH)", () => {
+  it("&PUBLIC_ATTR me=val → hidden:false", () => {
+    const ast = mustParse("&PUBLIC_ATTR me=val");
+    assertEquals(ast.hidden, false);
+  });
+
+  it("&_INTERNAL me=val → hidden:true", () => {
+    const ast = mustParse("&_INTERNAL me=val");
+    assertEquals(ast.type, "AttributeSet");
+    assertEquals(ast.hidden, true);
+  });
+
+  it("&_COR_STATE me=active → hidden:true (_COR_ system prefix)", () => {
+    const ast = mustParse("&_COR_STATE me=active");
+    assertEquals(ast.hidden, true);
+    assertEquals(ast.attribute, "_COR_STATE");
+  });
+
+  it("&_SECRET me (clear form) → hidden:true, value:null", () => {
+    const ast = mustParse("&_SECRET me");
+    assertEquals(ast.hidden, true);
+    assertEquals(ast.value, null);
+  });
+
+  it("&_FN_HELPER me=[add(%0,%1)] → hidden:true with eval value", () => {
+    const ast = mustParse("&_FN_HELPER me=[add(%0,%1)]");
+    assertEquals(ast.hidden, true);
+    assertEquals(ast.type, "AttributeSet");
+  });
+
+  it("hidden flag survives a command list", () => {
+    const ast = mustParse("&PUBLIC me=1;&_HIDDEN me=2");
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands[0].hidden, false);
+    assertEquals(ast.commands[1].hidden, true);
+  });
+});
+
+// ── User commands ─────────────────────────────────────────────────────────────
+
+describe("User / soft commands", () => {
+  it("say Hello → UserCommand", () => {
+    const ast = mustParse("say Hello");
+    assertEquals(ast.type, "UserCommand");
+  });
+
+  it("go north → UserCommand", () => {
+    const ast = mustParse("go north");
+    assertEquals(ast.type, "UserCommand");
+  });
+
+  it("+finger Bob → UserCommand starting with +", () => {
+    const ast = mustParse("+finger Bob");
+    assertEquals(ast.type, "UserCommand");
+  });
+
+  it("look → UserCommand", () => {
+    const ast = mustParse("look");
+    assertEquals(ast.type, "UserCommand");
+  });
+});
+
+// ── Command lists ─────────────────────────────────────────────────────────────
+
+describe("Command lists (semicolon-separated)", () => {
+  it("@pemit %#=Hi;@pemit %#=Bye → CommandList with two AtCommands", () => {
+    const ast = mustParse("@pemit %#=Hi;@pemit %#=Bye");
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands.length, 2);
+    assertEquals(ast.commands[0].type, "AtCommand");
+    assertEquals(ast.commands[1].type, "AtCommand");
+  });
+
+  it("say Hi;go north;look → CommandList with 3 commands", () => {
+    const ast = mustParse("say Hi;go north;look");
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands.length, 3);
+  });
+
+  it("single command → returned directly, not wrapped in CommandList", () => {
+    const ast = mustParse("@pemit %#=Hello");
+    assertEquals(ast.type, "AtCommand");
+  });
+
+  it("{cmd;cmd};cmd → brace protects inner semicolons from list split", () => {
+    const ast = mustParse("{cmd1;cmd2};cmd3");
+    assertEquals(ast.type, "CommandList");
+    assertEquals(ast.commands.length, 2);
+    // First command is a UserCommand whose only part is the BracedString
+    assertEquals(ast.commands[0].type, "UserCommand");
+    assertEquals(ast.commands[0].parts[0].type, "BracedString");
+  });
+});