glitchcode-cli 0.1.1

package/src/workflow/builtin/swarm-mode.js

@@ -0,0 +1,140 @@
+export const meta = {
+  name: 'swarm-mode',
+  description: 'GlassesCat Swarm — dispatches a task to 3 models in parallel (ultra/standard/lite), compares results, and returns the best solution with a diff analysis.',
+  whenToUse: 'Use when a task requires high quality and you want the best result from multiple model perspectives. Ideal for code generation, refactoring, and complex debugging.',
+  phases: [
+    { title: "Analyze", detail: "Analyze the task and decide the evaluation criteria" },
+    { title: "Swarm", detail: "Dispatch to 3 models in parallel — each produces a full solution" },
+    { title: "Judge", detail: "Compare all solutions, rank them, explain why one is best" },
+    { title: "Deliver", detail: "Return the winning solution with a summary of differences" },
+  ],
+}
+
+phase("Analyze")
+const TASK = (typeof args === "string" && args.trim()) || ""
+if (!TASK) return { error: "No task provided. Pass a task description as args." }
+
+const EVAL_SHAPE = {
+  type: "object", required: ["criteria"],
+  properties: {
+    criteria: { type: "array", minItems: 3, maxItems: 6, items: {
+      type: "object", required: ["name", "weight"],
+      properties: {
+        name: { type: "string", description: "Criterion name (correctness, performance, readability, security, etc.)" },
+        weight: { type: "number", description: "Importance 1-10" },
+      },
+    }},
+  },
+}
+
+const analysis = await agent(
+  "You are a senior architect. Analyze the following task and define 3-5 evaluation criteria to judge solutions against.\n" +
+  "Task: " + TASK + "\n" +
+  "Return an array of criteria with name and weight (1-10).",
+  { label: "analyze", phase: "Analyze", schema: EVAL_SHAPE }
+)
+const criteria = analysis?.criteria || [
+  { name: "correctness", weight: 10 },
+  { name: "readability", weight: 7 },
+  { name: "performance", weight: 6 },
+]
+
+log("Evaluation criteria: " + criteria.map(c => c.name + "(" + c.weight + ")").join(", "))
+
+phase("Swarm")
+
+const SOLUTION_SHAPE = {
+  type: "object", required: ["solution", "explanation", "confidence"],
+  properties: {
+    solution: { type: "string", description: "Complete solution (code, text, or structured answer)" },
+    explanation: { type: "string", description: "Step-by-step reasoning for this solution" },
+    confidence: { type: "number", description: "Confidence score 1-10" },
+    caveats: { type: "array", items: { type: "string" }, description: "Potential issues or edge cases" },
+  },
+}
+
+const models = ["ultra", "standard", "lite"]
+
+const solutions = await parallel(
+  models.map(model => () =>
+    agent(
+      "You are an expert developer. Solve the following task completely and thoroughly.\n" +
+      "Task: " + TASK + "\n\n" +
+      "Provide your best solution with detailed explanation.",
+      {
+        label: "swarm-" + model,
+        phase: "Swarm",
+        model: model,
+        schema: SOLUTION_SHAPE,
+      }
+    )
+  )
+)
+
+const results = models.map((m, i) => ({ model: m, result: solutions[i] }))
+const succeeded = results.filter(r => r.result !== null && r.result.solution)
+
+log("Swarm complete: " + succeeded.length + "/" + models.length + " models produced solutions")
+
+if (succeeded.length === 0) {
+  return { error: "All models failed to produce a solution.", results: [] }
+}
+
+phase("Judge")
+
+const JUDGE_SHAPE = {
+  type: "object", required: ["winner", "ranking", "reasoning"],
+  properties: {
+    winner: { type: "string", description: "Model name of the winning solution" },
+    ranking: { type: "array", items: {
+      type: "object", required: ["model", "score", "strengths", "weaknesses"],
+      properties: {
+        model: { type: "string" },
+        score: { type: "number", description: "Overall score 1-10" },
+        strengths: { type: "array", items: { type: "string" } },
+        weaknesses: { type: "array", items: { type: "string" } },
+      },
+    }},
+    reasoning: { type: "string", description: "Detailed comparison explaining the winner" },
+  },
+}
+
+const judgePrompt = "You are a senior technical judge. Compare the following " + succeeded.length + " solutions to the task.\n\n" +
+  "Task: " + TASK + "\n\n" +
+  "Evaluation criteria:\n" + criteria.map(c => "- " + c.name + " (weight: " + c.weight + "/10)").join("\n") + "\n\n" +
+  succeeded.map((r, i) =>
+    "--- Solution " + (i+1) + " (" + r.model + ") ---\n" +
+    "Solution: " + r.result.solution + "\n" +
+    "Explanation: " + r.result.explanation + "\n" +
+    "Confidence: " + r.result.confidence + "/10\n" +
+    "Caveats: " + (r.result.caveats || []).join(", ")
+  ).join("\n\n") + "\n\n" +
+  "Rank the solutions by quality. Select the winner and explain your reasoning."
+
+const verdict = await agent(judgePrompt, { label: "judge", phase: "Judge", schema: JUDGE_SHAPE })
+const winner = succeeded.find(r => r.model === (verdict?.winner || succeeded[0].model)) || succeeded[0]
+
+phase("Deliver")
+
+const deltaRows = succeeded.length > 1 ? succeeded.filter(r => r.model !== winner.model).map(r => {
+  const diff = r.result.solution !== winner.result.solution ? "DIFFERS" : "SAME"
+  return "- " + r.model + ": " + diff + " (confidence " + r.result.confidence + "/10)"
+}).join("\n") : "- Only one solution produced"
+
+return {
+  task: TASK,
+  winner: winner.model,
+  solution: winner.result.solution,
+  explanation: winner.result.explanation,
+  verdict: verdict?.reasoning || "",
+  comparison: {
+    criteria: criteria.map(c => c.name),
+    ranking: verdict?.ranking || [{ model: winner.model, score: 10, strengths: [], weaknesses: [] }],
+    solutionDiff: deltaRows,
+  },
+  stats: {
+    modelsAttempted: models.length,
+    modelsSucceeded: succeeded.length,
+    finalConfidence: winner.result.confidence || 0,
+  },
+}

package/src/workflow/builtin.ts

@@ -0,0 +1,65 @@
+export * as BuiltinWorkflow from "./builtin"
+
+// `with { type: "text" }` makes Bun inline the .js file's SOURCE as a string
+// (not import it as a module) and embeds it into the compiled binary via
+// `bun build --compile` (mirrors the `with { type: "file" }` asset pattern in
+// script/build.ts) — so the built-in script ships with the binary. The Bun
+// runtime and bundler both honour this, but tsgo resolves the .js as a real
+// module and flags TS1192 ("no default export"); the suppression is scoped to
+// this single import. A `Bun.file(...).text()` fallback is intentionally NOT
+// used: it reads the real filesystem at runtime, which does not exist inside a
+// compiled standalone binary.
+// @ts-expect-error TS1192: import-attribute text loader, resolved by Bun not tsgo
+import DEEP_RESEARCH_SCRIPT from "./builtin/deep-research.js" with { type: "text" }
+// @ts-expect-error TS1192
+import SWARM_MODE_SCRIPT from "./builtin/swarm-mode.js" with { type: "text" }
+// @ts-expect-error TS1192
+import MODEL_ROUTER_SCRIPT from "./builtin/model-router.js" with { type: "text" }
+// @ts-expect-error TS1192
+import SELF_HEALING_SCRIPT from "./builtin/self-healing.js" with { type: "text" }
+import { parseMeta } from "./meta"
+
+export type Entry = {
+  name: string
+  description: string
+  whenToUse?: string
+  phases?: { title: string; detail?: string }[]
+  script: string
+}
+
+// Built-in workflow scripts shipped with the binary. Each is parsed ONCE at
+// module load (meta is static data, not executed). Add new built-ins here.
+// `file` is carried so a malformed meta names the offending script — this throw
+// runs at module init, so a broken built-in fails the whole app boot; the path
+// tells the user which one.
+const SCRIPTS: { file: string; script: string }[] = [
+  { file: "deep-research.js", script: DEEP_RESEARCH_SCRIPT },
+  { file: "swarm-mode.js", script: SWARM_MODE_SCRIPT },
+  { file: "model-router.js", script: MODEL_ROUTER_SCRIPT },
+  { file: "self-healing.js", script: SELF_HEALING_SCRIPT },
+]
+
+// Null-prototype so the registry is a self-evidently closed set: a lookup like
+// get("constructor")/get("toString") returns undefined, not an inherited
+// Object.prototype member.
+const REGISTRY: Record<string, Entry> = Object.create(null)
+for (const { file, script } of SCRIPTS) {
+  const parsed = parseMeta(script)
+  if (!parsed.ok) throw new Error(`built-in workflow ${file} failed to parse meta: ${parsed.error}`)
+  const meta = parsed.meta
+  REGISTRY[meta.name] = {
+    name: meta.name,
+    description: meta.description,
+    whenToUse: meta.whenToUse,
+    phases: meta.phases,
+    script,
+  }
+}
+
+export function list(): Entry[] {
+  return Object.values(REGISTRY).sort((a, b) => a.name.localeCompare(b.name))
+}
+
+export function get(name: string): Entry | undefined {
+  return REGISTRY[name]
+}

package/src/workflow/events.ts

@@ -0,0 +1,72 @@
+import { BusEvent } from "@/bus/bus-event"
+import { SessionID } from "@/session/schema"
+import z from "zod"
+
+export const WorkflowPhase = BusEvent.define(
+  "workflow.phase",
+  z.object({ sessionID: SessionID.zod, runID: z.string(), title: z.string() }),
+)
+
+export const WorkflowLog = BusEvent.define(
+  "workflow.log",
+  z.object({ sessionID: SessionID.zod, runID: z.string(), message: z.string() }),
+)
+
+export const WorkflowStarted = BusEvent.define(
+  "workflow.started",
+  z.object({ sessionID: SessionID.zod, runID: z.string(), name: z.string() }),
+)
+
+export const WorkflowFinished = BusEvent.define(
+  "workflow.finished",
+  z.object({
+    sessionID: SessionID.zod,
+    runID: z.string(),
+    status: z.enum(["completed", "failed", "cancelled"]),
+    error: z.string().optional(),
+  }),
+)
+
+// agent() collapses every failure path to bare null (over-cap, spawn-reject,
+// timeout, actor-error, no-deliverable). The script can detect failure but not
+// WHY — operators end up grep-mining 25GB of bus chatter to triage. This event
+// emits the reason without changing agent()'s null return contract: existing
+// scripts work unchanged; new consumers (drivers, /workflows view, tests) can
+// subscribe to count failures by reason. Backward-compatible / additive only.
+export const WorkflowAgentFailed = BusEvent.define(
+  "workflow.agent_failed",
+  z.object({
+    sessionID: SessionID.zod,
+    runID: z.string(),
+    /** The child actor's id; absent when no spawn happened (over-cap path). */
+    actorID: z.string().optional(),
+    /** AgentOpts.agentType (defaulted to "general" by the spawn code). */
+    agentType: z.string(),
+    /** AgentOpts.label, observability tag (e.g. "port:bun_sys/fd.rs"). */
+    label: z.string().optional(),
+    /** Phase title at failure time, either AgentOpts.phase or run.currentPhase. */
+    phase: z.string().optional(),
+    reason: z.enum(["over-cap", "spawn-reject", "timeout", "actor-error", "no-deliverable"]),
+    /** For actor-error: the outcome.error message if available. */
+    errorMessage: z.string().optional(),
+  }),
+)
+
+// A child workflow run (started via the guest workflow() primitive) reached a
+// non-success terminal for a RUNTIME reason (its agents failed, deadline, or it
+// was cancelled). workflow() still resolves to null (never-throw, like agent()),
+// so the orchestrator script continues; this event carries the child runID +
+// status so operators can triage without grep-mining bus chatter. Structural
+// faults (cycle/depth/unknown-name) do NOT emit this — they propagate loud and
+// fail the parent run instead. Additive / backward-compatible, mirrors WorkflowAgentFailed.
+export const WorkflowChildFailed = BusEvent.define(
+  "workflow.child_failed",
+  z.object({
+    sessionID: SessionID.zod,
+    runID: z.string(), // the PARENT (orchestrator) run
+    childRunID: z.string(),
+    name: z.string(), // the child workflow name, or "inline"
+    status: z.enum(["failed", "cancelled"]),
+    error: z.string().optional(),
+  }),
+)

package/src/workflow/meta.ts

@@ -0,0 +1,335 @@
+// Parses the mandatory `export const meta = { ... }` literal from a workflow
+// script WITHOUT executing the script body — and, critically, WITHOUT executing
+// the literal either. The literal is parsed as DATA by a small recursive-descent
+// reader (objects/arrays/strings/numbers/booleans/null only), so listing/preview
+// is side-effect-free and cannot reach the host realm. Anything that isn't a
+// pure data literal (calls, property access, operators, functions, spreads,
+// templates) fails to parse and is rejected.
+//
+// Why not `new Function`/`eval`: that runs the literal in the HOST realm,
+// outside the QuickJS sandbox — a meta like
+//   { name: (globalThis.process.mainModule.require('child_process').execSync('id'),'x') }
+// would execute arbitrary host code. Why not jsonc-parser: the real meta uses
+// JS object syntax with UNQUOTED keys (`{ name: "x", phases: [{ title: "a" }] }`)
+// and single quotes, which strict/lenient JSONC rejects (verified empirically).
+// A purpose-built data reader handles that syntax while remaining pure data.
+//
+// The meta statement is replaced with an equal-length blank so the body's line
+// numbers are preserved for stack traces.
+
+export type WorkflowMeta = {
+  name: string
+  description: string
+  whenToUse?: string
+  phases?: { title: string; detail?: string }[]
+  model?: string
+}
+
+export type ParseResult =
+  | { ok: true; meta: WorkflowMeta; body: string }
+  | { ok: false; error: string }
+
+const META_START_RE = /export\s+const\s+meta\s*=\s*/
+
+export function parseMeta(script: string): ParseResult {
+  const start = META_START_RE.exec(script)
+  if (!start) {
+    return { ok: false, error: "workflow script must start with `export const meta = { ... }`" }
+  }
+  const open = script.indexOf("{", start.index + start[0].length)
+  if (open === -1) {
+    return { ok: false, error: "workflow script must start with `export const meta = { ... }`" }
+  }
+  const close = findBalancedClose(script, open)
+  if (close === -1) {
+    return { ok: false, error: "could not locate a balanced meta object literal" }
+  }
+  const literal = script.slice(open, close + 1)
+  const parsed = parseDataLiteral(literal)
+  if (!parsed.ok) return { ok: false, error: `meta is not a valid object literal: ${parsed.error}` }
+  const meta = parsed.value
+  if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return { ok: false, error: "meta must be an object" }
+  const m = meta as Record<string, unknown>
+  if (typeof m.name !== "string" || !m.name) return { ok: false, error: "meta.name (non-empty string) is required" }
+  if (typeof m.description !== "string" || !m.description)
+    return { ok: false, error: "meta.description (non-empty string) is required" }
+  const endIndex = close + 1 + (script[close + 1] === ";" ? 1 : 0)
+  const matched = script.slice(start.index, endIndex)
+  const body = script.slice(0, start.index) + matched.replace(/[^\n]/g, " ") + script.slice(endIndex)
+  return { ok: true, meta: m as WorkflowMeta, body }
+}
+
+// Scans from the `{` at `open`, counting brace depth while ignoring braces that
+// appear inside string literals (single/double/backtick, respecting backslash
+// escapes) or comments (`//` line, `/* */` block). Comment handling mirrors
+// `skipTrivia` so a brace inside a meta comment (`{ name: "n" // }` ) is not
+// miscounted. Returns the index of the matching `}` that closes depth to 0, or -1.
+function findBalancedClose(script: string, open: number): number {
+  let depth = 0
+  let quote = ""
+  for (let i = open; i < script.length; i++) {
+    const ch = script[i]
+    if (quote) {
+      if (ch === "\\") {
+        i++
+        continue
+      }
+      if (ch === quote) quote = ""
+      continue
+    }
+    if (ch === "/" && script[i + 1] === "/") {
+      i += 2
+      while (i < script.length && script[i] !== "\n") i++
+      continue
+    }
+    if (ch === "/" && script[i + 1] === "*") {
+      i += 2
+      while (i < script.length && !(script[i] === "*" && script[i + 1] === "/")) i++
+      i++ // land on the `/` of `*/`; loop's i++ steps past it
+      continue
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch
+      continue
+    }
+    if (ch === "{") depth++
+    else if (ch === "}") {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+// ---------------------------------------------------------------------------
+// A tiny recursive-descent reader for the JS object-literal DATA subset. It
+// PARSES, never evaluates: there is no `new Function`/`eval`/`vm` and no host
+// code runs. Accepts objects, arrays, double/single-quoted strings (with
+// standard escapes), numbers, `true`/`false`/`null`, identifier or quoted keys,
+// and trailing commas. Anything else (a call `()`, member access `.`/`[]` as an
+// expression, operators, `function`/`=>`, `...`, backtick templates) is a parse
+// error -> rejected. This is strictly a superset-free of code execution.
+// ---------------------------------------------------------------------------
+
+type DataResult = { ok: true; value: unknown } | { ok: false; error: string }
+
+// Real metas are ~2 levels deep (object -> phases[] -> phase object). A cap of
+// 100 is generous for any legitimate meta while preventing pathologically deep
+// input (e.g. `[[[...]]]` 50k deep) from overflowing the native call stack with
+// a `RangeError`. The cap throws `ParseFail`, so `parseDataLiteral`'s catch
+// converts it to `{ ok: false }` — keeping the documented return contract
+// (callers branch on `parsed.ok` and do not try/catch a thrown exception).
+const MAX_DEPTH = 100
+
+function parseDataLiteral(text: string): DataResult {
+  const reader = { text, pos: 0, depth: 0 }
+  // `try` is justified here: the recursive reader signals malformed input by
+  // throwing a tagged error which we convert to a result. (No host execution.)
+  try {
+    skipTrivia(reader)
+    const value = readValue(reader)
+    skipTrivia(reader)
+    if (reader.pos !== reader.text.length) throw new ParseFail(`unexpected token at offset ${reader.pos}`)
+    return { ok: true, value }
+  } catch (e) {
+    if (e instanceof ParseFail) return { ok: false, error: e.message }
+    throw e
+  }
+}
+
+class ParseFail extends Error {}
+
+type Reader = { text: string; pos: number; depth: number }
+
+// Skip whitespace plus `//` line and `/* */` block comments.
+function skipTrivia(r: Reader): void {
+  for (;;) {
+    const ch = r.text[r.pos]
+    if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v") {
+      r.pos++
+      continue
+    }
+    if (ch === "/" && r.text[r.pos + 1] === "/") {
+      r.pos += 2
+      while (r.pos < r.text.length && r.text[r.pos] !== "\n") r.pos++
+      continue
+    }
+    if (ch === "/" && r.text[r.pos + 1] === "*") {
+      r.pos += 2
+      while (r.pos < r.text.length && !(r.text[r.pos] === "*" && r.text[r.pos + 1] === "/")) r.pos++
+      if (r.pos >= r.text.length) throw new ParseFail("unterminated comment")
+      r.pos += 2
+      continue
+    }
+    return
+  }
+}
+
+function readValue(r: Reader): unknown {
+  const ch = r.text[r.pos]
+  if (ch === undefined) throw new ParseFail("unexpected end of input")
+  if (ch === "{") return readObject(r)
+  if (ch === "[") return readArray(r)
+  if (ch === '"' || ch === "'") return readString(r)
+  if (ch === "-" || (ch >= "0" && ch <= "9")) return readNumber(r)
+  if (matchKeyword(r, "true")) return true
+  if (matchKeyword(r, "false")) return false
+  if (matchKeyword(r, "null")) return null
+  throw new ParseFail(`unexpected token at offset ${r.pos} (only data literals are allowed)`)
+}
+
+function readObject(r: Reader): Record<string, unknown> {
+  if (++r.depth > MAX_DEPTH) throw new ParseFail("meta nesting too deep")
+  r.pos++ // consume `{`
+  const obj: Record<string, unknown> = {}
+  skipTrivia(r)
+  if (r.text[r.pos] === "}") {
+    r.pos++
+    r.depth--
+    return obj
+  }
+  for (;;) {
+    skipTrivia(r)
+    const key = readKey(r)
+    skipTrivia(r)
+    if (r.text[r.pos] !== ":") throw new ParseFail(`expected ':' after key '${key}' at offset ${r.pos}`)
+    r.pos++ // consume `:`
+    skipTrivia(r)
+    obj[key] = readValue(r)
+    skipTrivia(r)
+    const sep = r.text[r.pos]
+    if (sep === ",") {
+      r.pos++
+      skipTrivia(r)
+      if (r.text[r.pos] === "}") {
+        // trailing comma
+        r.pos++
+        r.depth--
+        return obj
+      }
+      continue
+    }
+    if (sep === "}") {
+      r.pos++
+      r.depth--
+      return obj
+    }
+    throw new ParseFail(`expected ',' or '}' at offset ${r.pos}`)
+  }
+}
+
+function readArray(r: Reader): unknown[] {
+  if (++r.depth > MAX_DEPTH) throw new ParseFail("meta nesting too deep")
+  r.pos++ // consume `[`
+  const arr: unknown[] = []
+  skipTrivia(r)
+  if (r.text[r.pos] === "]") {
+    r.pos++
+    r.depth--
+    return arr
+  }
+  for (;;) {
+    skipTrivia(r)
+    arr.push(readValue(r))
+    skipTrivia(r)
+    const sep = r.text[r.pos]
+    if (sep === ",") {
+      r.pos++
+      skipTrivia(r)
+      if (r.text[r.pos] === "]") {
+        // trailing comma
+        r.pos++
+        r.depth--
+        return arr
+      }
+      continue
+    }
+    if (sep === "]") {
+      r.pos++
+      r.depth--
+      return arr
+    }
+    throw new ParseFail(`expected ',' or ']' at offset ${r.pos}`)
+  }
+}
+
+// Object key: an identifier (`name`, `$a`, `_b`, `a1`) or a quoted string.
+// No computed keys (`[expr]`), no numeric keys — those aren't legitimate meta.
+function readKey(r: Reader): string {
+  const ch = r.text[r.pos]
+  if (ch === '"' || ch === "'") return readString(r)
+  if (ch !== undefined && (/[A-Za-z_$]/.test(ch))) {
+    const startPos = r.pos
+    r.pos++
+    while (r.pos < r.text.length && /[A-Za-z0-9_$]/.test(r.text[r.pos])) r.pos++
+    return r.text.slice(startPos, r.pos)
+  }
+  throw new ParseFail(`expected a property name at offset ${r.pos}`)
+}
+
+function readString(r: Reader): string {
+  const quote = r.text[r.pos]
+  r.pos++ // consume opening quote
+  let out = ""
+  for (;;) {
+    const ch = r.text[r.pos]
+    if (ch === undefined || ch === "\n") throw new ParseFail("unterminated string")
+    if (ch === "\\") {
+      const esc = r.text[r.pos + 1]
+      r.pos += 2
+      if (esc === "n") out += "\n"
+      else if (esc === "t") out += "\t"
+      else if (esc === "r") out += "\r"
+      else if (esc === "b") out += "\b"
+      else if (esc === "f") out += "\f"
+      else if (esc === "v") out += "\v"
+      else if (esc === "0") out += "\0"
+      else if (esc === "u") {
+        const hex = r.text.slice(r.pos, r.pos + 4)
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) throw new ParseFail("invalid \\u escape")
+        out += String.fromCharCode(parseInt(hex, 16))
+        r.pos += 4
+      } else if (esc === undefined) throw new ParseFail("unterminated string")
+      else out += esc // \\ \" \' \/ and any other escaped char -> literal
+      continue
+    }
+    if (ch === quote) {
+      r.pos++
+      return out
+    }
+    out += ch
+    r.pos++
+  }
+}
+
+function readNumber(r: Reader): number {
+  const startPos = r.pos
+  if (r.text[r.pos] === "-") r.pos++
+  while (r.pos < r.text.length && /[0-9]/.test(r.text[r.pos])) r.pos++
+  if (r.text[r.pos] === ".") {
+    r.pos++
+    while (r.pos < r.text.length && /[0-9]/.test(r.text[r.pos])) r.pos++
+  }
+  if (r.text[r.pos] === "e" || r.text[r.pos] === "E") {
+    r.pos++
+    if (r.text[r.pos] === "+" || r.text[r.pos] === "-") r.pos++
+    while (r.pos < r.text.length && /[0-9]/.test(r.text[r.pos])) r.pos++
+  }
+  const raw = r.text.slice(startPos, r.pos)
+  const n = Number(raw)
+  if (!Number.isFinite(n)) throw new ParseFail(`invalid number '${raw}'`)
+  return n
+}
+
+// Matches a bare keyword only when it is not followed by an identifier char
+// (so `truefoo` is not read as `true`).
+function matchKeyword(r: Reader, word: string): boolean {
+  if (r.text.startsWith(word, r.pos)) {
+    const after = r.text[r.pos + word.length]
+    if (after === undefined || !/[A-Za-z0-9_$]/.test(after)) {
+      r.pos += word.length
+      return true
+    }
+  }
+  return false
+}