@rhost/testkit 1.5.1 → 1.5.3

package/node_modules/@ursamu/mushcode/tests/lint.test.ts

@@ -0,0 +1,232 @@
+// ============================================================================
+// Lint — all four rules: positive and negative cases
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { parse } from "../parser/mod.ts";
+import type { ASTNode } from "../parser/mod.ts";
+import { lint, RULES } from "../src/lint/mod.ts";
+import type { Diagnostic } from "../src/lint/mod.ts";
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function p(text: string): ASTNode {
+  return parse(text, "Start");
+}
+
+function rulesOf(diags: Diagnostic[]): string[] {
+  return diags.map(d => d.rule);
+}
+
+// ── missing-wildcard ────────────────────────────────────────────────────────────
+
+describe("missing-wildcard", () => {
+  it("no diagnostic when wildcards match usage", () => {
+    const ast = p("$+finger *:@pemit %#=%0");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("no diagnostic when %1 is used and pattern has one wildcard", () => {
+    const ast = p("$say *:@pemit %#=%1");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("warns when %1 is used but pattern has no wildcards", () => {
+    const ast = p("$look:@pemit %#=%1");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "missing-wildcard");
+    assertEquals(diags[0].severity, "warning");
+  });
+
+  it("warns when %2 is used but pattern has only one wildcard", () => {
+    const ast = p("$cmd *:@pemit %#=%2");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "missing-wildcard");
+  });
+
+  it("no diagnostic for %0 even with no wildcards (%0 is always available)", () => {
+    const ast = p("$look:@pemit %#=%0");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("warns for ListenPattern too", () => {
+    const ast = p("^hello:@pemit %#=%1");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "missing-wildcard");
+  });
+
+  it("no false positive when action uses no positional subs", () => {
+    const ast = p("$look:@pemit %#=hello");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.length, 0);
+  });
+});
+
+// ── iter-var-outside-iter ─────────────────────────────────────────────────────
+
+describe("iter-var-outside-iter", () => {
+  it("## inside iter() — no diagnostic", () => {
+    const ast = p("[iter(lwho(),## )]");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("## inside map() — no diagnostic", () => {
+    const ast = p("[map(myattr,##)]");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("## inside @dolist — no diagnostic", () => {
+    const ast = p("@dolist lwho()={@pemit ##=hi}");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("## outside iter — warns", () => {
+    const ast = p("[pemit(%#,##)]");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "iter-var-outside-iter");
+    assertEquals(diags[0].severity, "warning");
+  });
+
+  it("#@ outside iter — warns", () => {
+    const ast = p("[pemit(%#,#@)]");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "iter-var-outside-iter");
+  });
+
+  it("bare ## in attribute value — warns", () => {
+    const ast = p("&ATTR me=##");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 1);
+  });
+
+  it("nested iter() — ## valid at both levels", () => {
+    const ast = p("[iter(iter(inner,##),##)]");
+    const diags = lint(ast, { rules: ["iter-var-outside-iter"] });
+    assertEquals(diags.length, 0);
+  });
+});
+
+// ── arg-count ──────────────────────────────────────────────────────────────────
+
+describe("arg-count", () => {
+  it("no diagnostic for correct arg counts", () => {
+    const ast = p("[add(1,2)]");
+    const diags = lint(ast, { rules: ["arg-count"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("warns when too few args", () => {
+    // div() requires exactly 2 args
+    const ast = p("[div(1)]");
+    const diags = lint(ast, { rules: ["arg-count"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "arg-count");
+    assertEquals(diags[0].severity, "warning");
+    assertEquals(diags[0].message.includes("at least"), true);
+  });
+
+  it("warns when too many args", () => {
+    // strlen() accepts only 1 arg
+    const ast = p("[strlen(foo,bar)]");
+    const diags = lint(ast, { rules: ["arg-count"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "arg-count");
+    assertEquals(diags[0].message.includes("at most"), true);
+  });
+
+  it("unknown function — no diagnostic", () => {
+    const ast = p("[myfunc(a,b,c)]");
+    const diags = lint(ast, { rules: ["arg-count"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("mid() with 3 args — no diagnostic", () => {
+    const ast = p("[mid(foo,1,2)]");
+    const diags = lint(ast, { rules: ["arg-count"] });
+    assertEquals(diags.length, 0);
+  });
+});
+
+// ── register-before-set ────────────────────────────────────────────────────────
+
+describe("register-before-set", () => {
+  it("no diagnostic when register is set before use", () => {
+    const ast = p("[setq(0,hello)][pemit(%#,%q0)]");
+    const diags = lint(ast, { rules: ["register-before-set"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("info diagnostic when %q0 used with no setq", () => {
+    const ast = p("[pemit(%#,%q0)]");
+    const diags = lint(ast, { rules: ["register-before-set"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "register-before-set");
+    assertEquals(diags[0].severity, "info");
+    assertEquals(diags[0].message.includes("%q0"), true);
+  });
+
+  it("r() read of unset register — info diagnostic", () => {
+    const ast = p("[r(0)]");
+    const diags = lint(ast, { rules: ["register-before-set"] });
+    assertEquals(diags.length, 1);
+    assertEquals(diags[0].rule, "register-before-set");
+  });
+
+  it("no diagnostic when r() matches setq()", () => {
+    const ast = p("[setq(foo,bar)][r(foo)]");
+    const diags = lint(ast, { rules: ["register-before-set"] });
+    assertEquals(diags.length, 0);
+  });
+
+  it("named register — no diagnostic when set", () => {
+    const ast = p("[setq(name,Alice)][pemit(%#,%qname)]");
+    const diags = lint(ast, { rules: ["register-before-set"] });
+    assertEquals(diags.length, 0);
+  });
+});
+
+// ── LintOptions: rules whitelist ───────────────────────────────────────────────
+
+describe("lint — options", () => {
+  it("runs all rules by default", () => {
+    // Pattern with no wildcards using %1 → missing-wildcard
+    // ## outside iter → iter-var-outside-iter
+    const ast = p("$look:@pemit %#=%1 ##");
+    const diags = lint(ast);
+    const rules = rulesOf(diags);
+    assertEquals(rules.includes("missing-wildcard"), true);
+    assertEquals(rules.includes("iter-var-outside-iter"), true);
+  });
+
+  it("whitelist: only runs specified rules", () => {
+    const ast = p("$look:@pemit %#=%1 ##");
+    const diags = lint(ast, { rules: ["missing-wildcard"] });
+    assertEquals(diags.every(d => d.rule === "missing-wildcard"), true);
+  });
+
+  it("RULES constant lists all rule ids", () => {
+    assertEquals(RULES.length, 4);
+    assertEquals(Array.from(RULES).includes("missing-wildcard"), true);
+    assertEquals(Array.from(RULES).includes("iter-var-outside-iter"), true);
+    assertEquals(Array.from(RULES).includes("arg-count"), true);
+    assertEquals(Array.from(RULES).includes("register-before-set"), true);
+  });
+
+  it("empty rules list produces no diagnostics", () => {
+    const ast = p("$look:@pemit %#=%1");
+    const diags = lint(ast, { rules: [] });
+    assertEquals(diags.length, 0);
+  });
+});

package/node_modules/@ursamu/mushcode/tests/print.test.ts

@@ -0,0 +1,204 @@
+// ============================================================================
+// Print — canonical softcode printer
+// ============================================================================
+
+import { assertEquals } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { parse } from "../parser/mod.ts";
+import type { ASTNode } from "../parser/mod.ts";
+import { print } from "../src/print/mod.ts";
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function roundtrip(text: string): string {
+  return print(parse(text, "Start"));
+}
+
+function roundtripLock(text: string): string {
+  return print(parse(text, "LockExpr"));
+}
+
+// ── Literals and leaves ────────────────────────────────────────────────────────
+
+describe("Print — leaves", () => {
+  it("Literal", () => {
+    assertEquals(roundtrip("hello world"), "hello world");
+  });
+
+  it("Escape → backslash + char", () => {
+    assertEquals(roundtrip("\\;"), "\\;");
+    assertEquals(roundtrip("\\["), "\\[");
+    assertEquals(roundtrip("\\\\"), "\\\\");
+  });
+
+  it("Substitution → % + code", () => {
+    assertEquals(roundtrip("%0"), "%0");
+    assertEquals(roundtrip("%#"), "%#");
+    assertEquals(roundtrip("%q0"), "%q0");
+  });
+
+  it("SpecialVar — ## #@ #$", () => {
+    assertEquals(roundtrip("##"), "##");
+    assertEquals(roundtrip("#@"), "#@");
+    assertEquals(roundtrip("#$"), "#$");
+  });
+
+  it("TagRef → #name", () => {
+    assertEquals(roundtrip("[tag(me,#mytag)]"), "[tag(me,#mytag)]");
+    // Standalone TagRef in text
+    const node: ASTNode = { type: "TagRef", name: "alpha" };
+    assertEquals(print(node), "#alpha");
+  });
+});
+
+// ── Expression containers ──────────────────────────────────────────────────────
+
+describe("Print — EvalBlock and BracedString", () => {
+  it("EvalBlock wraps in []", () => {
+    assertEquals(roundtrip("[add(1,2)]"), "[add(1,2)]");
+  });
+
+  it("BracedString wraps in {}", () => {
+    assertEquals(roundtrip("{hello}"), "{hello}");
+  });
+
+  it("nested EvalBlock inside BracedString", () => {
+    assertEquals(roundtrip("{[add(1,2)]}"), "{[add(1,2)]}");
+  });
+});
+
+// ── FunctionCall ───────────────────────────────────────────────────────────────
+
+describe("Print — FunctionCall", () => {
+  it("no args", () => {
+    assertEquals(roundtrip("[rand()]"), "[rand()]");
+  });
+
+  it("single arg", () => {
+    assertEquals(roundtrip("[strlen(hello)]"), "[strlen(hello)]");
+  });
+
+  it("multiple args, comma-separated", () => {
+    assertEquals(roundtrip("[add(1,2)]"), "[add(1,2)]");
+    assertEquals(roundtrip("[mid(foo,1,2)]"), "[mid(foo,1,2)]");
+  });
+
+  it("nested function calls", () => {
+    assertEquals(roundtrip("[add(mul(2,3),1)]"), "[add(mul(2,3),1)]");
+  });
+});
+
+// ── Commands ───────────────────────────────────────────────────────────────────
+
+describe("Print — AtCommand", () => {
+  it("basic @pemit with object and value", () => {
+    assertEquals(roundtrip("@pemit %#=hello"), "@pemit %#=hello");
+  });
+
+  it("AtCommand with switch", () => {
+    assertEquals(roundtrip("@pemit/noeval %#=hello"), "@pemit/noeval %#=hello");
+  });
+
+  it("AtCommand without value", () => {
+    assertEquals(roundtrip("@trigger me/GO"), "@trigger me/GO");
+  });
+
+  it("@set with value", () => {
+    assertEquals(roundtrip("@set %#=WIZARD"), "@set %#=WIZARD");
+  });
+});
+
+describe("Print — AttributeSet", () => {
+  it("basic &ATTR obj=val", () => {
+    assertEquals(roundtrip("&MYATTR me=hello world"), "&MYATTR me=hello world");
+  });
+
+  it("attribute with eval block value", () => {
+    assertEquals(roundtrip("&FINGER me=[u(me/FN_FINGER)]"), "&FINGER me=[u(me/FN_FINGER)]");
+  });
+});
+
+// ── CommandList ────────────────────────────────────────────────────────────────
+
+describe("Print — CommandList", () => {
+  it("compact mode (default) joins with ;", () => {
+    const ast = parse("@pemit %#=a;@pemit %#=b", "Start");
+    assertEquals(print(ast), "@pemit %#=a;@pemit %#=b");
+  });
+
+  it("pretty mode joins with ;\\n", () => {
+    const ast = parse("@pemit %#=a;@pemit %#=b", "Start");
+    assertEquals(print(ast, { mode: "pretty" }), "@pemit %#=a;\n@pemit %#=b");
+  });
+});
+
+// ── Dollar and Listen patterns ─────────────────────────────────────────────────
+
+describe("Print — patterns", () => {
+  it("DollarPattern round-trips", () => {
+    assertEquals(roundtrip("$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]"),
+      "$+finger *:@pemit %#=[u(me/FN_FINGER,%0)]");
+  });
+
+  it("ListenPattern round-trips", () => {
+    assertEquals(roundtrip("^hello *:@pemit %#=Hi!"),
+      "^hello *:@pemit %#=Hi!");
+  });
+
+  it("PatternAlts with semicolon separator", () => {
+    // Pattern alternatives joined by ;
+    const text = "$look;+look:look";
+    assertEquals(roundtrip(text), text);
+  });
+});
+
+// ── Lock expressions ───────────────────────────────────────────────────────────
+
+describe("Print — lock expressions", () => {
+  it("me", () => {
+    assertEquals(roundtripLock("me"), "me");
+  });
+
+  it("dbref", () => {
+    assertEquals(roundtripLock("#123"), "#123");
+  });
+
+  it("flag check", () => {
+    assertEquals(roundtripLock("flag^WIZARD"), "flag^WIZARD");
+  });
+
+  it("player name check", () => {
+    assertEquals(roundtripLock("=Admin"), "=Admin");
+  });
+
+  it("attr check", () => {
+    assertEquals(roundtripLock("attr^LOCKED"), "attr^LOCKED");
+  });
+
+  it("type check", () => {
+    assertEquals(roundtripLock("type^PLAYER"), "type^PLAYER");
+  });
+
+  it("LockAnd — & separates operands", () => {
+    assertEquals(roundtripLock("flag^WIZARD&flag^ADMIN"), "flag^WIZARD&flag^ADMIN");
+  });
+
+  it("LockOr — | separates operands", () => {
+    assertEquals(roundtripLock("flag^WIZARD|flag^ADMIN"), "flag^WIZARD|flag^ADMIN");
+  });
+
+  it("LockNot — prefix !", () => {
+    assertEquals(roundtripLock("!flag^WIZARD"), "!flag^WIZARD");
+  });
+
+  it("LockOr inside LockAnd gets parens", () => {
+    // (a|b)&c — the OR branch needs parens to preserve precedence
+    const result = roundtripLock("(flag^WIZARD|me)&flag^ADMIN");
+    assertEquals(result, "(flag^WIZARD|me)&flag^ADMIN");
+  });
+
+  it("LockNot wrapping compound expression gets parens", () => {
+    const result = roundtripLock("!(flag^WIZARD|me)");
+    assertEquals(result, "!(flag^WIZARD|me)");
+  });
+});

package/node_modules/@ursamu/mushcode/tests/traverse.test.ts

@@ -0,0 +1,211 @@
+// ============================================================================
+// Traverse — walk, transform, findAll, findFirst, findFirstOrNull
+// ============================================================================
+
+import { assertEquals, assertThrows } from "jsr:@std/assert@^1";
+import { describe, it } from "jsr:/@std/testing@^1/bdd";
+import { parse } from "../parser/mod.ts";
+import type { ASTNode } from "../parser/mod.ts";
+import {
+  walk,
+  transform,
+  findAll,
+  findFirst,
+  findFirstOrNull,
+} from "../src/traverse/mod.ts";
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function p(text: string): ASTNode {
+  return parse(text, "Start");
+}
+
+// ── walk ───────────────────────────────────────────────────────────────────────
+
+describe("walk — enter/leave hooks", () => {
+  it("visits every node depth-first", () => {
+    const ast = p("[add(1,2)]");
+    const visited: string[] = [];
+    walk(ast, { enter(n) { visited.push(n.type); } });
+    // Must visit UserCommand, EvalBlock, FunctionCall, and two Arg+Literal nodes
+    const unique = [...new Set(visited)];
+    assertEquals(unique.includes("UserCommand"), true);
+    assertEquals(unique.includes("EvalBlock"), true);
+    assertEquals(unique.includes("FunctionCall"), true);
+  });
+
+  it("leave is called after children", () => {
+    const ast = p("[f(x)]");
+    const log: string[] = [];
+    walk(ast, {
+      enter(n) { log.push(`enter:${n.type}`); },
+      leave(n) { log.push(`leave:${n.type}`); },
+    });
+    const enterIdx  = log.indexOf("enter:FunctionCall");
+    const leaveIdx  = log.indexOf("leave:FunctionCall");
+    const argIdx    = log.indexOf("enter:Arg");
+    assertEquals(enterIdx < argIdx, true, "enter:FunctionCall before enter:Arg");
+    assertEquals(argIdx < leaveIdx, true, "enter:Arg before leave:FunctionCall");
+  });
+
+  it("returning false from enter skips children (leave not called)", () => {
+    const ast = p("[f(x)]");
+    const visited: string[] = [];
+    walk(ast, {
+      enter(n) {
+        visited.push(n.type);
+        if (n.type === "FunctionCall") return false;
+      },
+      leave(n) { visited.push(`leave:${n.type}`); },
+    });
+    assertEquals(visited.includes("Arg"), false, "Arg (child of FunctionCall) skipped");
+    assertEquals(visited.includes("leave:FunctionCall"), false, "leave not called when false returned");
+  });
+
+  it("walk on a leaf node (Literal) fires enter+leave once with no children", () => {
+    const leaf: ASTNode = { type: "Literal", value: "hello" };
+    const log: string[] = [];
+    walk(leaf, { enter(n) { log.push(`e:${n.type}`); }, leave(n) { log.push(`l:${n.type}`); } });
+    assertEquals(log, ["e:Literal", "l:Literal"]);
+  });
+
+  it("walk over CommandList visits all commands", () => {
+    const ast = p("cmd1;cmd2;cmd3");
+    const cmds: string[] = [];
+    walk(ast, {
+      enter(n) {
+        if (n.type === "UserCommand") cmds.push(n.type);
+      },
+    });
+    assertEquals(cmds.length, 3);
+  });
+});
+
+// ── findAll ────────────────────────────────────────────────────────────────────
+
+describe("findAll", () => {
+  it("collects all FunctionCall nodes", () => {
+    const ast = p("[add(mul(2,3),4)]");
+    const fns = findAll(ast, "FunctionCall");
+    assertEquals(fns.length, 2);
+    const names = fns.map(n => n.name as string);
+    assertEquals(names.includes("add"), true);
+    assertEquals(names.includes("mul"), true);
+  });
+
+  it("returns empty array when type not found", () => {
+    const ast = p("plain text");
+    assertEquals(findAll(ast, "FunctionCall"), []);
+  });
+
+  it("finds nested EvalBlocks", () => {
+    const ast = p("[[f()]]");
+    const evals = findAll(ast, "EvalBlock");
+    assertEquals(evals.length >= 1, true);
+  });
+
+  it("finds TagRef nodes", () => {
+    const ast = p("[tag(me,#mytag)]");
+    const refs = findAll(ast, "TagRef");
+    assertEquals(refs.length, 1);
+    assertEquals(refs[0].name, "mytag");
+  });
+
+  it("finds multiple Substitution nodes", () => {
+    const ast = p("%0 %1 %2");
+    const subs = findAll(ast, "Substitution");
+    assertEquals(subs.length, 3);
+  });
+});
+
+// ── findFirst / findFirstOrNull ────────────────────────────────────────────────
+
+describe("findFirst / findFirstOrNull", () => {
+  it("findFirst returns the first matching node", () => {
+    const ast = p("[add(1,2)]");
+    const fn = findFirst(ast, "FunctionCall");
+    assertEquals(fn.type, "FunctionCall");
+    assertEquals(fn.name, "add");
+  });
+
+  it("findFirst throws when not found", () => {
+    const ast = p("plain text");
+    assertThrows(
+      () => findFirst(ast, "FunctionCall"),
+      Error,
+      'No node of type "FunctionCall" found',
+    );
+  });
+
+  it("findFirstOrNull returns null when not found", () => {
+    const ast = p("plain text");
+    assertEquals(findFirstOrNull(ast, "FunctionCall"), null);
+  });
+
+  it("findFirstOrNull returns the node when found", () => {
+    const ast = p("[f()]");
+    const fn = findFirstOrNull(ast, "FunctionCall");
+    assertEquals(fn?.type, "FunctionCall");
+  });
+});
+
+// ── transform ─────────────────────────────────────────────────────────────────
+
+describe("transform", () => {
+  it("returns the same reference when no changes made", () => {
+    const ast = p("hello");
+    const out = transform(ast, () => undefined);
+    assertEquals(out, ast);
+  });
+
+  it("replaces a node", () => {
+    const ast = p("[#mytag]");
+    const out = transform(ast, (n) => {
+      if (n.type === "TagRef") {
+        return { type: "Literal", value: `<tag:${n.name as string}>` };
+      }
+    });
+    const literals = findAll(out, "Literal");
+    assertEquals(literals.some(l => (l.value as string) === "<tag:mytag>"), true);
+    // Original tree is unmodified
+    assertEquals(findAll(ast, "TagRef").length, 1);
+  });
+
+  it("removes array items when fn returns null", () => {
+    const ast = p("[add(1,2)]");
+    // Remove all Arg nodes (the children of FunctionCall) — result has empty args array
+    const out = transform(ast, (n) => {
+      if (n.type === "Arg") return null;
+    });
+    const fn = findFirst(out, "FunctionCall");
+    assertEquals((fn.args as ASTNode[]).length, 0);
+  });
+
+  it("top-down: replacement's children are recursed (not original's)", () => {
+    // Replace FunctionCall with a new FunctionCall that has different args;
+    // make sure the new child is visited, not the old one
+    const ast = p("[old(x)]");
+    const visited: string[] = [];
+    transform(ast, (n) => {
+      visited.push(n.type);
+      if (n.type === "FunctionCall" && n.name === "old") {
+        return {
+          type: "FunctionCall",
+          name: "new",
+          args: [{ type: "Arg", parts: [{ type: "Literal", value: "y" }] }],
+        } as ASTNode;
+      }
+    });
+    // "new" FunctionCall replacement is entered; "old" args never visited
+    assertEquals(visited.filter(t => t === "FunctionCall").length, 1);
+  });
+
+  it("does not mutate the original tree", () => {
+    const ast = p("[add(1,2)]");
+    const originalStr = JSON.stringify(ast);
+    transform(ast, (n) => {
+      if (n.type === "Literal") return { type: "Literal", value: "X" };
+    });
+    assertEquals(JSON.stringify(ast), originalStr);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhost/testkit",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "SDK for programmatically testing MUSHcode against a RhostMUSH server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,9 @@
     "SECURITY.md",
     "ROADMAP.md"
   ],
+  "bundledDependencies": [
+    "@ursamu/mushcode"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/lcanady/rhost-testkit.git"
@@ -95,6 +98,12 @@
     "testPathIgnorePatterns": [],
     "moduleNameMapper": {
       "^@ursamu/mushcode$": "<rootDir>/scripts/mushcode-compat.js"
+    },
+    "coverageThreshold": {
+      "global": {
+        "lines": 80,
+        "statements": 80
+      }
     }
   }
 }