@rohal12/spindle-lsp 0.15.9 → 0.15.10

package/dist/bin.js

@@ -55,7 +55,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = false ? pkg.version : "0.15.9";
+    VERSION = false ? pkg.version : "0.15.10";
   }
 });
 
@@ -31245,6 +31245,7 @@ var init_text = __esm({
 });
 
 // src/core/parsing/passage-parser.ts
+import { createRequire as createCompilerRequire } from "node:module";
 function parsePassageHeader(rawLine, lineNumber) {
   const line = withoutCr(rawLine);
   const bomLength = lineNumber === 0 && line.charCodeAt(0) === 65279 ? 1 : 0;
@@ -31276,7 +31277,8 @@ function parsePassageHeader(rawLine, lineNumber) {
     try {
       meta3 = JSON.parse(raw);
     } catch {
-      return null;
+      const { parseTwee } = createCompilerRequire(import.meta.url)("@rohal12/twee-ts");
+      if (parseTwee(line.slice(bomLength)).passages.length !== 1) return null;
     }
   }
   const headerRange = {
@@ -31303,8 +31305,11 @@ function isReservedPassageName(name) {
 function isScriptOrStylesheetPassage(passage) {
   return passage.tags?.some((t) => CODE_PASSAGE_TAGS.has(t)) ?? false;
 }
+function isRuntimePassage(passage) {
+  return passage.name !== "StoryTitle" && passage.name !== "StoryData" && !isScriptOrStylesheetPassage(passage) && !passage.tags?.includes("Twine.private");
+}
 function isMarkupPassage(passage) {
-  return !(passage.name !== void 0 && NON_MARKUP_PASSAGES.has(passage.name)) && !isScriptOrStylesheetPassage(passage);
+  return isRuntimePassage(passage) && !(passage.name !== void 0 && NON_MARKUP_PASSAGES.has(passage.name));
 }
 var SPECIAL_PASSAGES, CODE_PASSAGE_TAGS, RESERVED_PASSAGE_NAMES, NON_MARKUP_PASSAGES;
 var init_passage_parser = __esm({
@@ -31501,834 +31506,1506 @@ var init_passage_index = __esm({
   }
 });
 
-// src/core/workspace/macro-registry.ts
-function applySupplement(info, entry) {
-  for (const field of ["description", "parameters", "parameterDocs", "children", "parents", "skipArgs"]) {
-    if (entry[field] !== void 0) Object.assign(info, { [field]: entry[field] });
+// src/core/parsing/argument-lexer.ts
+function lexArguments(source) {
+  let from = 0;
+  return splitArgs(source).map((text3) => {
+    const start = source.indexOf(text3, from);
+    from = start + text3.length;
+    return classifyArgument(text3, start);
+  });
+}
+function classifyArgument(text3, start = 0) {
+  const base = { text: text3, start, end: start + text3.length };
+  if (readQuoted(text3, 0)?.end === text3.length) return { ...base, type: 0 /* String */ };
+  if (text3 === "null") return { ...base, type: 3 /* Null */ };
+  if (text3 === "undefined") return { ...base, type: 10 /* Undefined */ };
+  if (text3 === "true" || text3 === "false") return { ...base, type: 2 /* Boolean */ };
+  if (text3 === "NaN") return { ...base, type: 9 /* NaN */ };
+  if (text3 !== "" && !Number.isNaN(Number(text3))) return { ...base, type: 1 /* Number */ };
+  if (/^[$_@%]\w+(?:\.\w+)*$/.test(text3)) {
+    return { ...base, type: 4 /* Variable */, sigil: text3[0], path: text3.slice(1).split(".") };
   }
-  if (entry.container !== void 0) info.block = entry.container;
+  if (text3.startsWith("[[") && text3.endsWith("]]")) return { ...base, type: 5 /* Link */ };
+  if (/^\[[<>]?img\[/i.test(text3) && text3.endsWith("]]")) return { ...base, type: 6 /* Image */ };
+  return { ...base, type: /^[-\w]+$/.test(text3) ? 8 /* Bareword */ : 7 /* Expression */ };
 }
-var MacroRegistry;
-var init_macro_registry2 = __esm({
-  "src/core/workspace/macro-registry.ts"() {
+var init_argument_lexer = __esm({
+  "src/core/parsing/argument-lexer.ts"() {
     "use strict";
     init_tooling();
-    init_config_loader();
-    MacroRegistry = class {
-      macros = /* @__PURE__ */ new Map();
-      /** Entries as they were before the current user config was applied (undefined = absent). */
-      configSnapshot = /* @__PURE__ */ new Map();
-      /** Tier 3: macros discovered from Story.defineMacro() calls, keyed by lowercase name. */
-      discovered = /* @__PURE__ */ new Map();
-      /** Called after the set of macros or their metadata changed. */
-      onChange;
-      /** Tier 4: user config entries, kept so they can be re-applied over discovered macros. */
-      configEntries = /* @__PURE__ */ new Map();
-      /**
-       * Load the built-in macros: name, block, sub-macros, flags and typed
-       * parameters, from Spindle's tooling API (the release the LSP is built on).
-       * This is the base layer the other tiers overlay.
-       */
-      loadBuiltins() {
-        for (const m of builtinMacros) {
-          this.macros.set(m.name.toLowerCase(), {
-            name: m.name,
-            block: m.block,
-            subMacros: [...m.subMacros],
-            storeVar: m.storeVar,
-            interpolate: m.interpolate,
-            merged: m.merged,
-            source: m.source === "builtin" ? "builtin" : "user",
-            parameterDefs: m.parameters
-          });
-        }
-      }
-      /**
-       * Overlay supplement data onto the registry.
-       * Supplements provide descriptions, parameters, children, parents, skipArgs.
-       * The `container` field maps to `block` on MacroInfo.
-       */
-      loadSupplements(supplements) {
-        this.mergeEntries(supplements);
-        this.onChange?.();
-      }
-      /**
-       * Overlay user config onto the registry.
-       * Same format as supplements; applied last so it wins.
-       *
-       * Replaces any previously loaded config: entries from the last call are
-       * reverted first, so macros removed from the config disappear (or fall
-       * back to their builtin/supplement definition).
-       */
-      loadConfig(config2) {
-        config2 = normalizeMacroEntries(config2);
-        for (const [key, previous2] of this.configSnapshot) {
-          if (previous2) {
-            this.macros.set(key, previous2);
-          } else {
-            this.macros.delete(key);
-          }
-        }
-        this.configSnapshot.clear();
-        this.configEntries.clear();
-        for (const rawKey of Object.keys(config2)) {
-          const key = rawKey.toLowerCase();
-          if (!this.configSnapshot.has(key)) {
-            const existing = this.macros.get(key);
-            this.configSnapshot.set(key, existing ? { ...existing } : void 0);
-          }
-          this.configEntries.set(key, { ...this.configEntries.get(key), ...config2[rawKey] });
-        }
-        this.mergeEntries(config2);
-        this.onChange?.();
-      }
-      /**
-       * Replace the set of macros discovered from Story.defineMacro() calls.
-       * Previously discovered definitions that are no longer present are dropped,
-       * restoring whatever the other tiers define for that name.
-       *
-       * Each sub-macro becomes a known macro that may only appear inside its
-       * parent. Whether a macro is a block is the tooling API's reading of the
-       * definition (`discoverMacros`).
-       */
-      setDiscoveredMacros(macros) {
-        this.discovered.clear();
-        for (const m of macros) {
-          this.discovered.set(m.name.toLowerCase(), {
-            name: m.name,
-            block: m.block,
-            subMacros: m.subMacros,
-            storeVar: m.storeVar,
-            interpolate: m.interpolate,
-            merged: m.merged,
-            description: m.description,
-            source: "user",
-            parameterDefs: m.parameters
-          });
-        }
-        for (const m of [...this.discovered.values()]) {
-          for (const sub of m.subMacros ?? []) {
-            const key = sub.toLowerCase();
-            const existing = this.discovered.get(key);
-            if (existing) {
-              existing.parents = [...existing.parents ?? [], m.name];
-            } else {
-              this.discovered.set(key, { name: sub, block: false, subMacros: [], source: "user", parents: [m.name] });
-            }
-          }
-        }
-        this.onChange?.();
-      }
-      /** Add or replace a single macro entry. */
-      addMacro(info) {
-        const key = info.name.toLowerCase();
-        const existing = this.macros.get(key);
-        this.macros.set(key, {
-          name: info.name,
-          block: info.block ?? existing?.block ?? false,
-          subMacros: info.subMacros ?? existing?.subMacros ?? [],
-          source: info.source ?? existing?.source ?? "user",
-          storeVar: info.storeVar ?? existing?.storeVar,
-          interpolate: info.interpolate ?? existing?.interpolate,
-          merged: info.merged ?? existing?.merged,
-          description: info.description ?? existing?.description,
-          parameters: info.parameters ?? existing?.parameters,
-          parameterDefs: info.parameterDefs ?? existing?.parameterDefs,
-          parameterDocs: info.parameterDocs ?? existing?.parameterDocs,
-          children: info.children ?? existing?.children,
-          parents: info.parents ?? existing?.parents,
-          skipArgs: info.skipArgs ?? existing?.skipArgs
-        });
-        this.onChange?.();
-      }
-      /** Get a macro by name (case-insensitive). */
-      getMacro(name) {
-        return this.resolve(name.toLowerCase());
-      }
-      /** A project's explicit schema takes precedence over runtime signature metadata. */
-      hasConfiguredParameters(name) {
-        return this.configEntries.get(name.toLowerCase())?.parameters !== void 0;
-      }
-      /** Check if a macro is a block (container) macro. */
-      isBlock(name) {
-        return this.getMacro(name)?.block ?? false;
-      }
-      /** Check if a macro is a sub-macro (has parents). */
-      isSubMacro(name) {
-        const info = this.getMacro(name);
-        return info?.parents != null && info.parents.length > 0;
-      }
-      /** The macros as the tooling API reads them (`passagePieces`, `validateStoryMarkup`). */
-      toolingMacros() {
-        return this.getAllMacros().map((m) => ({
-          name: m.name,
-          block: m.block,
-          subMacros: m.subMacros,
-          storeVar: m.storeVar,
-          interpolate: m.interpolate,
-          parameters: m.parameterDefs
-        }));
-      }
-      /** Get all registered macros. */
-      getAllMacros() {
-        const keys = /* @__PURE__ */ new Set([...this.macros.keys(), ...this.discovered.keys()]);
-        return Array.from(keys, (key) => this.resolve(key));
-      }
-      /**
-       * Compose the effective entry for a lowercase key: builtins/supplements/
-       * config (stored in `macros`), overlaid by discovered metadata, with user
-       * config re-applied on top so it keeps precedence.
-       */
-      resolve(key) {
-        const base = this.macros.get(key);
-        const found = this.discovered.get(key);
-        if (!found) return base;
-        const info = {
-          name: found.name,
-          block: found.block ?? false,
-          subMacros: found.subMacros ?? [],
-          source: "user",
-          storeVar: found.storeVar,
-          interpolate: found.interpolate,
-          merged: found.merged,
-          description: found.description,
-          // A definition replaces the macro it names, parameters included
-          parameterDefs: found.parameterDefs,
-          parents: found.parents
-        };
-        const config2 = this.configEntries.get(key);
-        if (config2) applySupplement(info, config2);
-        return info;
-      }
-      /** Merge a set of supplement/config entries into the registry. */
-      mergeEntries(entries) {
-        for (const [rawKey, entry] of Object.entries(entries)) {
-          const key = rawKey.toLowerCase();
-          const existing = this.macros.get(key);
-          if (existing) {
-            applySupplement(existing, entry);
-          } else {
-            this.macros.set(key, {
-              name: entry.name ?? rawKey,
-              block: entry.container ?? false,
-              subMacros: [],
-              source: "user",
-              description: entry.description,
-              parameters: entry.parameters,
-              parameterDocs: entry.parameterDocs,
-              children: entry.children,
-              parents: entry.parents,
-              skipArgs: entry.skipArgs
-            });
-          }
-        }
-      }
-    };
   }
 });
 
-// src/core/parsing/executable-refs.ts
-function collectVariableReferences2(markup) {
-  if (!markup.isMarkup) return [];
-  return variableReferences(markup.content, markup.doc.context.macros, { all: true }).map((ref2) => ({
-    sigil: ref2.sigil,
-    name: ref2.name,
-    path: [ref2.name, ...ref2.path].join("."),
-    start: ref2.start,
-    end: ref2.end
-  }));
+// src/core/parsing/parameter-validator.ts
+function isAlwaysArg(arg) {
+  return arg.type === 4 /* Variable */ || arg.type === 7 /* Expression */;
 }
-var init_executable_refs = __esm({
-  "src/core/parsing/executable-refs.ts"() {
-    "use strict";
-    init_tooling();
+function findParameterType(name) {
+  for (const pt2 of parameterTypes) {
+    if (pt2.name.includes(name)) return pt2;
   }
-});
-
-// src/core/markup/passage-markup.ts
-var PassageMarkup, DocumentMarkup;
-var init_passage_markup = __esm({
-  "src/core/markup/passage-markup.ts"() {
-    "use strict";
-    init_tooling();
-    init_passage_parser();
-    init_text();
-    PassageMarkup = class {
-      constructor(doc, passage, bodyStart, bodyEnd) {
-        this.doc = doc;
-        this.passage = passage;
-        this.bodyStart = bodyStart;
-        this.bodyEnd = bodyEnd;
-        const raw = doc.text.slice(bodyStart, bodyEnd);
-        this.isMarkup = isMarkupPassage(passage);
-        if (raw.includes("\r\n")) {
-          const map2 = [];
-          let content2 = "";
-          for (let i2 = 0; i2 < raw.length; i2++) {
-            if (raw[i2] === "\r" && raw[i2 + 1] === "\n") continue;
-            map2.push(bodyStart + i2);
-            content2 += raw[i2];
-          }
-          map2.push(bodyEnd);
-          this.content = content2;
-          this.toDoc = Int32Array.from(map2);
-        } else {
-          this.content = raw;
-          this.toDoc = null;
-        }
-      }
-      doc;
-      passage;
-      bodyStart;
-      bodyEnd;
-      /** The body, LF-normalized: the text the tooling API analyzes. */
-      content;
-      /** Whether Spindle reads the body as story markup (see isMarkupPassage). */
-      isMarkup;
-      /** For each `content` offset, its offset in the document; null when the body has no CRLF. */
-      toDoc;
-      cachedTokens;
-      cachedPairing;
-      cachedPieces;
-      cachedDeclarations;
-      /** The document offset of `contentOffset`. */
-      docOffset(contentOffset) {
-        if (!this.toDoc) return this.bodyStart + contentOffset;
-        return this.toDoc[Math.min(Math.max(contentOffset, 0), this.toDoc.length - 1)];
-      }
-      /**
-       * The document offset just past the character before `contentEnd`: where an
-       * exclusive end maps to. (`docOffset()` of an end that sits before a line
-       * break would land behind the `\r` of a CRLF.)
-       */
-      docEnd(contentEnd) {
-        return contentEnd <= 0 ? this.docOffset(0) : this.docOffset(contentEnd - 1) + 1;
-      }
-      /** The `content` offset of a document offset (the nearest one at or after it). */
-      contentOffset(docOffset) {
-        if (!this.toDoc) return Math.min(Math.max(docOffset - this.bodyStart, 0), this.content.length);
-        let low = 0;
-        let high = this.toDoc.length - 1;
-        while (low < high) {
-          const mid = low + high >> 1;
-          if (this.toDoc[mid] < docOffset) low = mid + 1;
-          else high = mid;
-        }
-        return low;
-      }
-      /** The document position of `contentOffset`. */
-      position(contentOffset) {
-        return offsetToPosition(this.docOffset(contentOffset), this.doc.lineStarts);
-      }
-      /** The document range of `[start, end)` in `content` offsets. */
-      range(start, end) {
-        return offsetsToRange(this.docOffset(start), end > start ? this.docEnd(end) : this.docOffset(start), this.doc.lineStarts);
-      }
-      /** The flat tokens and the malformed tags; none for a passage that is not markup. */
-      get tokenization() {
-        return this.cachedTokens ??= this.isMarkup ? tokenizeMarkupTolerant(this.content) : { tokens: [], errors: [] };
-      }
-      get tokens() {
-        return this.tokenization.tokens;
-      }
-      /** The tree of paired tokens, and what does not pair. */
-      get pairing() {
-        return this.cachedPairing ??= pairMarkup(this.tokens, {
-          isBlock: (name) => this.doc.context.isBlock(name),
-          source: this.content
-        });
-      }
-      /** What the markup runs and names, and where (see `passagePieces`). */
-      get pieces() {
-        return this.cachedPieces ??= this.isMarkup ? passagePieces(this.content, this.doc.context.macros) : [];
-      }
-      /** The declarations of a StoryVariables / StoryTransients passage. */
-      get declarations() {
-        return this.cachedDeclarations ??= parseDeclarations(this.content, this.passage.name === "StoryTransients" ? "%" : "$");
+  return null;
+}
+function lexFormat(formatString) {
+  let pos = 0;
+  const lexed = [];
+  let iter = 0;
+  for (; ; ) {
+    if (++iter > LEX_LIMIT) throw new Error("Format lex iteration limit exceeded");
+    if (pos >= formatString.length) break;
+    const ch = formatString[pos];
+    if (wsRe.test(ch)) {
+      pos++;
+    } else if (ch === "&") {
+      pos++;
+      const next = formatString[pos];
+      if (next === "+") {
+        pos++;
+        lexed.push({ kind: 3 /* AndNext */ });
+      } else {
+        throw new Error(`Lex: Expected '+' after '&', found '${next ?? "EOF"}'`);
       }
-    };
-    DocumentMarkup = class {
-      constructor(uri, text3, passages, context) {
-        this.uri = uri;
-        this.text = text3;
-        this.context = context;
-        this.lineStarts = buildLineStarts(text3);
-        this.passages = passages.map((passage, i2) => {
-          const bodyStart = this.lineStarts[passage.headerEnd.end.line + 1] ?? text3.length;
-          const next = passages[i2 + 1];
-          const bodyEnd = next ? this.lineStarts[next.range.start.line] : text3.length;
-          return new PassageMarkup(this, passage, Math.min(bodyStart, bodyEnd), bodyEnd);
-        });
+    } else if (ch === "|") {
+      pos++;
+      const next = formatString[pos];
+      if (next === "+") {
+        pos++;
+        lexed.push({ kind: 4 /* MaybeNext */ });
+      } else if (next === void 0) {
+        throw new Error("Lex: Expected content after '|'");
+      } else if (wsRe.test(next)) {
+        pos++;
+        lexed.push({ kind: 5 /* Or */ });
+      } else if (identStartRe.test(next) || quoteRe.test(next)) {
+        lexed.push({ kind: 5 /* Or */ });
+      } else {
+        throw new Error(`Lex: Invalid character after '|': '${next}'`);
       }
-      uri;
-      text;
-      context;
-      lineStarts;
-      passages;
-      /** The passage that contains `position`. */
-      passageAt(position) {
-        for (let i2 = this.passages.length - 1; i2 >= 0; i2--) {
-          if (this.passages[i2].passage.range.start.line <= position.line) return this.passages[i2];
+    } else if (quoteRe.test(ch)) {
+      const quoted = readQuoted(formatString, pos);
+      if (!quoted) throw new Error("Lex: Unterminated string literal");
+      pos = quoted.end;
+      lexed.push({ kind: 1 /* Literal */, value: quoted.value });
+    } else if (ch === "(" || ch === ")") {
+      pos++;
+      lexed.push({ kind: 2 /* Group */, open: ch === "(" });
+    } else if (identStartRe.test(ch)) {
+      const start = pos;
+      pos++;
+      while (pos < formatString.length) {
+        if (++iter > LEX_LIMIT) throw new Error("Format lex identifier iteration limit exceeded");
+        const c = formatString[pos];
+        if (identStopRe.test(c) || c === void 0) break;
+        if (identStartRe.test(c)) {
+          pos++;
+        } else if (digitRe.test(c)) {
+          throw new Error(`Lex: Digit '${c}' not allowed in parameter type name`);
+        } else {
+          throw new Error(`Lex: Invalid character '${c}' in parameter type name`);
         }
-        return void 0;
       }
-    };
-  }
-});
-
-// src/core/workspace/declaration-check.ts
-function readDeclarations(content2, sigil) {
-  const passage = PASSAGE[sigil];
-  const lines = content2.replace(/\r\n/g, "\n").split("\n");
-  const header = lines.findIndex((line) => /^?::/.test(line));
-  const text3 = (header === -1 ? lines : lines.slice(0, header)).join("\n");
-  const { declarations, errors } = parseDeclarations(text3.replace(/\r/g, " "), sigil);
-  const problems = [];
-  for (const error48 of errors) {
-    if (error48.code === "duplicate-declaration") continue;
-    const [start, end] = lineSpan(text3, error48.offset);
-    if (isUnjudged(text3.slice(start, end))) continue;
-    let message = `${passage}: ${error48.message}`;
-    if (error48.code === "invalid-declaration" && COMMENT_START.test(text3.slice(error48.offset, error48.end))) {
-      message += `. ${passage} has no comment syntax.`;
-    } else if (!message.endsWith(".")) {
-      message += ".";
+      const ident = formatString.slice(start, pos);
+      const pt2 = findParameterType(ident);
+      if (pt2 === null) throw new Error(`Lex: Unknown parameter type '${ident}'`);
+      lexed.push({ kind: 0 /* Type */, type: pt2 });
+    } else if (ch === "." && formatString[pos + 1] === "." && formatString[pos + 2] === ".") {
+      pos += 3;
+      lexed.push({ kind: 6 /* Repeat */ });
+    } else {
+      throw new Error(`Lex: Unexpected character '${ch}'`);
     }
-    problems.push({ message, start, end });
   }
-  return { text: text3, declarations, problems: problems.sort((a, b) => a.start - b.start) };
-}
-function isUnjudged(line) {
-  return line.includes("\r") || line.includes("\xA0");
-}
-function lineSpan(text3, offset2) {
-  const lineStart = text3.lastIndexOf("\n", offset2 - 1) + 1;
-  const lineEnd = text3.indexOf("\n", offset2);
-  const line = text3.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd);
-  const start = lineStart + line.length - line.trimStart().length;
-  return [start, lineStart + line.trimEnd().length];
+  return lexed;
 }
-var PASSAGE, COMMENT_START;
-var init_declaration_check = __esm({
-  "src/core/workspace/declaration-check.ts"() {
-    "use strict";
-    init_tooling();
-    PASSAGE = { "$": "StoryVariables", "%": "StoryTransients" };
-    COMMENT_START = /^(?:\/\/|\/\*|<!--|#)/;
+function parseFormat(formatString) {
+  const tokens2 = lexFormat(formatString);
+  if (tokens2.length === 0) return null;
+  let index = 0;
+  let iter = 0;
+  function infixBp(kind) {
+    switch (kind) {
+      case 5 /* Or */:
+        return [9, 10];
+      case 3 /* AndNext */:
+        return [4, 5];
+      case 4 /* MaybeNext */:
+        return [2, 3];
+      default:
+        return null;
+    }
   }
-});
-
-// src/core/workspace/variable-tracker.ts
-function standaloneMarkup(uri, text3) {
-  const index = new PassageIndex();
-  index.rebuild(uri, text3);
-  return new DocumentMarkup(uri, text3, index.getPassagesInDocument(uri), BUILTIN_CONTEXT);
+  function prefixBp(kind) {
+    switch (kind) {
+      case 4 /* MaybeNext */:
+        return 3;
+      case 6 /* Repeat */:
+        return 8;
+      default:
+        throw new Error(`Parse: Unexpected prefix operator kind ${kind}`);
+    }
+  }
+  function isPrefixOp(t) {
+    return t.kind === 4 /* MaybeNext */ || t.kind === 6 /* Repeat */;
+  }
+  function isValue(t) {
+    return t.kind === 0 /* Type */ || t.kind === 1 /* Literal */;
+  }
+  function exprBp(minBp) {
+    if (++iter > PARSE_LIMIT) throw new Error("Format parse iteration limit exceeded");
+    const cur = tokens2[index];
+    if (!cur) throw new Error("Parse: Unexpected end of format string");
+    index++;
+    let lhs;
+    if (isPrefixOp(cur)) {
+      const rBp = prefixBp(cur.kind);
+      const rhs = exprBp(rBp);
+      lhs = { kind: cur.kind, right: rhs };
+    } else if (cur.kind === 2 /* Group */) {
+      const g = cur;
+      if (!g.open) throw new Error("Parse: Unexpected closing parenthesis");
+      lhs = exprBp(0);
+      const closing = tokens2[index];
+      if (!closing || closing.kind !== 2 /* Group */ || closing.open) {
+        throw new Error("Parse: Expected closing parenthesis");
+      }
+      index++;
+    } else if (isValue(cur)) {
+      lhs = cur;
+    } else {
+      throw new Error("Parse: Expected value or prefix operator");
+    }
+    for (; ; ) {
+      if (++iter > PARSE_LIMIT) throw new Error("Format parse operator iteration limit exceeded");
+      const op = tokens2[index];
+      if (!op) break;
+      const bp = infixBp(op.kind);
+      if (bp === null) break;
+      const [lBp, rBp] = bp;
+      if (lBp < minBp) break;
+      index++;
+      const rhs = exprBp(rBp);
+      lhs = { kind: op.kind, left: lhs, right: rhs };
+    }
+    return lhs;
+  }
+  return exprBp(0);
 }
-function usagesOf(byUri, name) {
-  const results = [];
-  for (const usages of byUri.values()) {
-    for (const u of usages) {
-      if (u.baseName === name) results.push({ uri: u.uri, range: u.range });
+function slotAccepts(leaf) {
+  return (arg) => crawlValidate(leaf, [arg], 0).status === 2 /* Success */;
+}
+function describeFormat(format) {
+  const cap = (list3) => list3.slice(0, DESCRIBE_ALTERNATIVE_LIMIT);
+  const join5 = (lefts, rights) => cap(lefts.flatMap((l) => rights.map((r) => [...l, ...r])));
+  switch (format.kind) {
+    case 0 /* Type */:
+      return [[{ label: format.type.name[0], optional: false, repeat: false, accepts: slotAccepts(format) }]];
+    case 1 /* Literal */:
+      return [[{ label: `'${format.value}'`, optional: false, repeat: false, accepts: slotAccepts(format) }]];
+    case 3 /* AndNext */:
+      return join5(describeFormat(format.left), describeFormat(format.right));
+    case 4 /* MaybeNext */: {
+      const rights = describeFormat(format.right).map(
+        (seq) => seq.map((slot) => ({ ...slot, optional: true }))
+      );
+      return join5(format.left ? describeFormat(format.left) : [[]], rights);
     }
+    case 5 /* Or */:
+      return cap([...describeFormat(format.left), ...describeFormat(format.right)]);
+    case 6 /* Repeat */:
+      return describeFormat(format.right).map(
+        (seq) => seq.map((slot) => ({ ...slot, optional: true, repeat: true }))
+      );
   }
-  return results;
 }
-var BUILTIN_CONTEXT, ARRAY_MEMBERS, DeclarationSet, VariableTracker;
-var init_variable_tracker = __esm({
-  "src/core/workspace/variable-tracker.ts"() {
+function passageSlots(format) {
+  const single = (passage) => ({ slots: [passage], variable: false, unsafe: false });
+  switch (format.kind) {
+    case 0 /* Type */:
+      return single(format.type.name.includes("passage"));
+    case 1 /* Literal */:
+      return single(false);
+    case 6 /* Repeat */: {
+      const child = passageSlots(format.right);
+      return { slots: [], variable: true, unsafe: child.unsafe || child.slots.includes(true), restFrom: 0 };
+    }
+    case 5 /* Or */:
+      return mergePassageSlots(passageSlots(format.left), passageSlots(format.right));
+    case 3 /* AndNext */:
+    case 4 /* MaybeNext */: {
+      const left = format.left ? passageSlots(format.left) : { slots: [], variable: false, unsafe: false };
+      const right = passageSlots(format.right);
+      return {
+        slots: [...left.slots, ...right.slots],
+        variable: left.variable || right.variable || format.kind === 4 /* MaybeNext */,
+        restFrom: left.restFrom ?? (right.restFrom === void 0 ? void 0 : left.slots.length + right.restFrom),
+        // A variable-width prefix can move every position that follows it.
+        // Refuse rather than attributing an ordinary string to a passage.
+        unsafe: left.unsafe || right.unsafe || left.variable && right.slots.length > 0 && (left.slots.includes(true) || right.slots.includes(true))
+      };
+    }
+  }
+}
+function mergePassageSlots(left, right) {
+  const repeatedConflict = (repeated, other) => repeated.restFrom !== void 0 && other.slots.some((passage, i2) => passage && i2 >= repeated.restFrom);
+  return {
+    slots: Array.from({ length: Math.max(left.slots.length, right.slots.length) }, (_2, i2) => left.slots[i2] === true || right.slots[i2] === true),
+    variable: left.variable || right.variable || left.slots.length !== right.slots.length,
+    restFrom: left.restFrom === void 0 ? right.restFrom : right.restFrom === void 0 ? left.restFrom : Math.min(left.restFrom, right.restFrom),
+    unsafe: left.unsafe || right.unsafe || left.slots.some((passage, i2) => right.slots[i2] !== void 0 && passage !== right.slots[i2]) || repeatedConflict(left, right) || repeatedConflict(right, left)
+  };
+}
+function makeError(status, message, argIndex, rank = 0) {
+  return {
+    status,
+    rank,
+    argIndex,
+    errors: [{ message, argIndex }],
+    warnings: []
+  };
+}
+function makeSuccess(argIndex, rank, warnings = []) {
+  return { status: 2 /* Success */, rank, argIndex, errors: [], warnings };
+}
+function isFail(s) {
+  return s === 1 /* Failure */ || s === 0 /* NotFound */;
+}
+function crawlValidate(format, args2, startIndex, state) {
+  const memo2 = /* @__PURE__ */ new Map();
+  function append(left, right) {
+    return { ...right, rank: left.rank + right.rank, warnings: left.warnings.concat(right.warnings) };
+  }
+  function follow(left, right) {
+    return left.flatMap((matched) => isFail(matched.status) ? [matched] : crawl(right, matched.argIndex).map((result2) => append(matched, result2)));
+  }
+  function crawl(fmt, argIdx) {
+    let positions = memo2.get(fmt);
+    if (!positions) memo2.set(fmt, positions = /* @__PURE__ */ new Map());
+    const cached2 = positions.get(argIdx);
+    if (cached2) return cached2;
+    if (positions.size >= VALIDATE_LIMIT) {
+      throw new Error(`Validation iteration limit exceeded at argument ${argIdx}`);
+    }
+    const unique = /* @__PURE__ */ new Map();
+    for (const result2 of match2(fmt, argIdx)) {
+      const key = isFail(result2.status) ? "failure" : result2.argIndex;
+      const previous2 = unique.get(key);
+      if (!previous2 || key === "failure" && result2.rank > previous2.rank) unique.set(key, result2);
+    }
+    const results2 = [...unique.values()];
+    positions.set(argIdx, results2);
+    return results2;
+  }
+  function match2(fmt, argIdx) {
+    switch (fmt.kind) {
+      case 4 /* MaybeNext */: {
+        const left = fmt.left ? crawl(fmt.left, argIdx) : [makeSuccess(argIdx, 0)];
+        return [...follow(left, fmt.right), ...left];
+      }
+      case 3 /* AndNext */: {
+        return follow(crawl(fmt.left, argIdx), fmt.right);
+      }
+      case 5 /* Or */: {
+        return [...crawl(fmt.left, argIdx), ...crawl(fmt.right, argIdx)];
+      }
+      case 6 /* Repeat */: {
+        const matches = [];
+        const pending = [makeSuccess(argIdx, 0)];
+        const reached = /* @__PURE__ */ new Set();
+        while (pending.length > 0) {
+          const matched = pending.pop();
+          if (reached.has(matched.argIndex)) continue;
+          reached.add(matched.argIndex);
+          matches.push(matched);
+          const items = crawl(fmt.right, matched.argIndex);
+          for (let i2 = items.length - 1; i2 >= 0; i2--) {
+            const item = items[i2];
+            if (!isFail(item.status) && !reached.has(item.argIndex)) pending.push(append(matched, item));
+          }
+        }
+        return matches.sort((left, right) => right.argIndex - left.argIndex);
+      }
+      case 1 /* Literal */: {
+        const arg = args2[argIdx];
+        if (arg === void 0) {
+          return [makeError(0 /* NotFound */, `Expected literal '${fmt.value}' but no argument found`, argIdx)];
+        }
+        if (isAlwaysArg(arg)) {
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
+        }
+        const argText = arg.type === 0 /* String */ ? readQuoted(arg.text, 0)?.value : arg.text;
+        if (argText === fmt.value) {
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
+        }
+        if (fmt.value === "null" && arg.type === 3 /* Null */ || fmt.value === "undefined" && arg.type === 10 /* Undefined */ || fmt.value === "true" && arg.type === 2 /* Boolean */ && arg.text === "true" || fmt.value === "false" && arg.type === 2 /* Boolean */ && arg.text === "false" || fmt.value === "NaN" && arg.type === 9 /* NaN */) {
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
+        }
+        return [makeError(1 /* Failure */, `Expected literal '${fmt.value}'`, argIdx, CORRECT_TYPE_RANK)];
+      }
+      case 0 /* Type */: {
+        const arg = args2[argIdx];
+        const typeDef = fmt.type;
+        if (arg === void 0) {
+          return [makeError(
+            0 /* NotFound */,
+            `Expected type '${typeDef.name[0]}' but no argument found`,
+            argIdx
+          )];
+        }
+        if (isAlwaysArg(arg)) {
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
+        }
+        const result2 = typeDef.validate(arg, args2, argIdx, state);
+        if (result2 instanceof TypeError2) {
+          return [{
+            status: 1 /* Failure */,
+            rank: 0,
+            argIndex: argIdx,
+            errors: [{ message: result2.message, argIndex: argIdx }],
+            warnings: []
+          }];
+        }
+        if (result2 instanceof TypeWarning) {
+          return [makeSuccess(argIdx + 1, CORRECT_RANK, [
+            { message: result2.message, argIndex: argIdx }
+          ])];
+        }
+        return [makeSuccess(argIdx + 1, CORRECT_RANK)];
+      }
+    }
+  }
+  const results = crawl(format, startIndex);
+  return results.find((result2) => !isFail(result2.status) && result2.argIndex === args2.length) ?? results.reduce((best, result2) => result2.rank > best.rank ? result2 : best);
+}
+var TypeError2, TypeWarning, parameterTypes, LEX_LIMIT, wsRe, identStartRe, identStopRe, quoteRe, digitRe, PARSE_LIMIT, DESCRIBE_ALTERNATIVE_LIMIT, VALIDATE_LIMIT, CORRECT_TYPE_RANK, CORRECT_RANK, Parameters;
+var init_parameter_validator = __esm({
+  "src/core/parsing/parameter-validator.ts"() {
     "use strict";
     init_tooling();
-    init_executable_refs();
-    init_passage_markup();
-    init_text();
-    init_passage_index();
-    init_declaration_check();
-    BUILTIN_CONTEXT = { macros: builtinMacros, isBlock: isBlockMacro };
-    ARRAY_MEMBERS = /* @__PURE__ */ new Set([
-      ...Object.getOwnPropertyNames(Array.prototype),
-      ...Object.getOwnPropertyNames(Object.prototype),
-      "at",
-      "flat",
-      "flatMap",
-      "includes",
-      "findLast",
-      "findLastIndex",
-      "toReversed",
-      "toSorted",
-      "toSpliced",
-      "with"
-    ]);
-    DeclarationSet = class {
-      constructor(sigil) {
-        this.sigil = sigil;
+    init_argument_lexer();
+    TypeError2 = class {
+      constructor(message) {
+        this.message = message;
       }
-      sigil;
-      present = false;
-      declared = /* @__PURE__ */ new Map();
-      /** Every declaration, including earlier defaults for the same binding. */
-      occurrences = [];
-      /** Lines Spindle rejects. */
-      problems = [];
-      /** The names declared, with the range of sigil and name of the first. */
-      names = /* @__PURE__ */ new Map();
-      clear() {
-        this.present = false;
-        this.declared.clear();
-        this.occurrences.length = 0;
-        this.problems = [];
-        this.names.clear();
+      message;
+    };
+    TypeWarning = class {
+      constructor(message) {
+        this.message = message;
       }
-      /** Read the passage `content`, which starts at line `contentStartLine` of the document `uri`. */
-      read(content2, contentStartLine, uri) {
-        this.clear();
-        this.present = true;
-        const { text: text3, declarations, problems } = readDeclarations(content2, this.sigil);
-        const lineStarts = buildLineStarts(text3);
-        const position = (offset2) => {
-          const { line, character } = offsetToPosition(offset2, lineStarts);
-          return { line: contentStartLine + line, character };
-        };
-        for (const problem of problems) {
-          this.problems.push({ message: problem.message, range: { start: position(problem.start), end: position(problem.end) } });
+      message;
+    };
+    parameterTypes = [
+      {
+        name: ["bool", "boolean"],
+        validate(arg) {
+          return arg.type === 2 /* Boolean */ ? null : new TypeError2("Argument is not a boolean");
         }
-        for (const declaration of declarations) {
-          const { name, schema } = declaration;
-          const declarationRange = { start: position(declaration.nameStart - 1), end: position(declaration.nameEnd) };
-          const declared = { name, sigil: this.sigil, declarationRange };
-          if (uri !== void 0) declared.declarationUri = uri;
-          if (schema) {
-            if (schema.type !== "null") declared.type = schema.type;
-            if (schema.fields && schema.fields.size > 0) declared.fields = [...schema.fields.keys()];
+      },
+      {
+        name: ["null"],
+        validate(arg) {
+          return arg.type === 3 /* Null */ ? null : new TypeError2("Argument is not 'null'");
+        }
+      },
+      {
+        name: ["undefined"],
+        validate(arg) {
+          return arg.type === 10 /* Undefined */ ? null : new TypeError2("Argument is not 'undefined'");
+        }
+      },
+      {
+        name: ["number"],
+        validate(arg) {
+          return arg.type === 1 /* Number */ ? null : new TypeError2("Argument is not a number");
+        }
+      },
+      {
+        name: ["NaN"],
+        validate(arg) {
+          return arg.type === 9 /* NaN */ ? null : new TypeError2("Argument is not 'NaN'");
+        }
+      },
+      {
+        name: ["link"],
+        validate(arg) {
+          return arg.type === 5 /* Link */ ? null : new TypeError2("Argument is not a link");
+        }
+      },
+      {
+        name: ["image"],
+        validate(arg) {
+          return arg.type === 6 /* Image */ ? null : new TypeError2("Argument is not an image");
+        }
+      },
+      {
+        name: ["bareword"],
+        validate(arg) {
+          return arg.type === 8 /* Bareword */ ? null : new TypeError2("Argument is not a bareword");
+        }
+      },
+      {
+        name: ["string"],
+        validate(arg) {
+          return arg.type === 0 /* String */ ? null : new TypeError2("Argument is not a quoted string");
+        }
+      },
+      {
+        name: ["text"],
+        validate(arg) {
+          const t = arg.type;
+          if (t === 8 /* Bareword */ || t === 0 /* String */ || t === 2 /* Boolean */ || t === 3 /* Null */ || t === 9 /* NaN */ || t === 1 /* Number */) {
+            return null;
           }
-          this.declared.set(name, declared);
-          this.occurrences.push(declared);
-          if (!this.names.has(name)) this.names.set(name, declarationRange);
+          return new TypeError2("Argument is not text");
+        }
+      },
+      {
+        name: ["var"],
+        validate(arg) {
+          return arg.type === 4 /* Variable */ ? null : new TypeError2("Argument is not a variable");
+        }
+      },
+      {
+        // The story variable a form control binds to: `$name` or `"$name"`.
+        // Spindle strips the quotes and the `$` sigil from the first argument
+        // and reads the rest as a dot path into the story variables.
+        name: ["receiver"],
+        validate(arg) {
+          let name;
+          if (arg.type === 0 /* String */) {
+            name = arg.text.slice(1, -1);
+          } else if (arg.type === 8 /* Bareword */) {
+            name = arg.text;
+          }
+          if (name === void 0) {
+            return new TypeError2("Argument is not a variable receiver");
+          }
+          if (/^[_@%]/.test(name)) {
+            return new TypeError2(`Variable receiver must be a story variable ($name), got '${name}'`);
+          }
+          if (!/^(?:\$\w|[A-Za-z_])[\w$]*(?:\.[\w$]+)*$/.test(name)) {
+            return new TypeError2(`Argument is not a valid variable receiver: '${name}'`);
+          }
+          return null;
+        }
+      },
+      {
+        name: ["passage"],
+        validate(arg, _args, _index, state) {
+          let passageName;
+          if (arg.type === 0 /* String */) {
+            const target = passageTarget(arg.text);
+            if (target.kind === "name") passageName = target.name;
+          } else if (arg.type === 8 /* Bareword */) {
+            passageName = arg.text;
+          } else if (arg.type === 1 /* Number */) {
+            passageName = arg.text;
+          } else if (arg.type === 9 /* NaN */) {
+            passageName = "NaN";
+          }
+          if (passageName !== void 0) {
+            if (state && state.passages.length > 0) {
+              if (!state.passages.includes(passageName)) {
+                return new TypeWarning(`Nonexistent passage: "${passageName}"`);
+              }
+            }
+            return null;
+          }
+          return new TypeError2("Argument is not an acceptable passage");
         }
       }
-    };
-    VariableTracker = class {
-      variables = new DeclarationSet("$");
-      transients = new DeclarationSet("%");
-      /** Per-URI list of variable usages. */
-      usagesByUri = /* @__PURE__ */ new Map();
-      /** Per-URI list of transient variable usages. */
-      transientUsagesByUri = /* @__PURE__ */ new Map();
+    ];
+    LEX_LIMIT = 1e3;
+    wsRe = /\s/;
+    identStartRe = /[a-zA-Z]/;
+    identStopRe = /[|&+\-\s)(]/;
+    quoteRe = /['"]/;
+    digitRe = /[0-9]/;
+    PARSE_LIMIT = 2e3;
+    DESCRIBE_ALTERNATIVE_LIMIT = 16;
+    VALIDATE_LIMIT = 2e3;
+    CORRECT_TYPE_RANK = 1;
+    CORRECT_RANK = 2;
+    Parameters = class {
+      variants;
+      constructor(variants) {
+        this.variants = variants.map((s) => ({
+          formatString: s,
+          format: parseFormat(s)
+        }));
+      }
       /**
-       * Parse the StoryVariables passage content for declarations.
-       * Each line like `$name = value` becomes a declaration.
+       * Describe every argument position of every schema variant. Alternatives
+       * (`|`) and optional positions (`|+`) become separate sequences; an empty
+       * schema is the empty sequence. Variants whose format cannot be parsed
+       * contribute nothing.
        */
-      parseStoryVariables(content2, contentStartLine = 0, uri) {
-        this.variables.read(content2, contentStartLine, uri);
-      }
-      /** Forget StoryVariables declarations, e.g. after the passage was removed. */
-      clearStoryVariables() {
-        this.variables.clear();
-      }
-      /** Forget StoryTransients declarations, e.g. after the passage was removed. */
-      clearStoryTransients() {
-        this.transients.clear();
+      describe() {
+        const sequences = [];
+        for (const variant of this.variants) {
+          if (variant.format === null) sequences.push([]);
+          else sequences.push(...describeFormat(variant.format));
+        }
+        return sequences;
       }
       /**
-       * Parse the StoryTransients passage content for declarations.
-       * Each line like `%name = value` becomes a declaration.
+       * Passage positions that have the same role in every schema alternative.
+       * Unlike describe(), this walks the whole tree without truncating branches.
+       * Repeated or conflicting passage roles return null so callers can refuse
+       * an unsafe rename; actual argument spans and values remain Spindle's job.
        */
-      parseStoryTransients(content2, contentStartLine = 0, uri) {
-        this.transients.read(content2, contentStartLine, uri);
+      passagePositions() {
+        const summary = this.variants.map((variant) => variant.format ? passageSlots(variant.format) : { slots: [], variable: false, unsafe: false }).reduce(mergePassageSlots, { slots: [], variable: false, unsafe: false });
+        return summary.unsafe ? null : summary.slots.flatMap((passage, i2) => passage ? [i2] : []);
       }
       /**
-       * Scan a document for variable usages: the `$` and `%` references in the
-       * markup of its passages (see `collectVariableReferences`). The workspace
-       * passes the `markup` it reads the document with, which knows the project's
-       * macros and widgets; without it the built-in macros decide.
+       * Validate an array of Arg tokens against these parameter variants.
+       * Selects the best-matching variant by rank.
        */
-      scanDocument(uri, text3, markup = standaloneMarkup(uri, text3)) {
-        this.removeDocument(uri);
-        const usages = [];
-        const transientUsages = [];
-        for (const passage of markup.passages) {
-          for (const ref2 of collectVariableReferences2(passage)) {
-            const usage = {
-              uri,
-              baseName: ref2.name,
-              fullName: ref2.path,
-              range: passage.range(ref2.start, ref2.end)
-            };
-            (ref2.sigil === "$" ? usages : transientUsages).push(usage);
+      validate(args2, stateInfo) {
+        if (this.variants.length === 0) {
+          if (args2.length === 0) {
+            return { variantIndex: null, errors: [], warnings: [] };
           }
+          return {
+            variantIndex: null,
+            errors: [{ message: "Expected no arguments", argIndex: 0 }],
+            warnings: []
+          };
         }
-        if (usages.length > 0) this.usagesByUri.set(uri, usages);
-        if (transientUsages.length > 0) this.transientUsagesByUri.set(uri, transientUsages);
-      }
-      /** Forget the usages recorded for a document, e.g. after it was deleted. */
-      removeDocument(uri) {
-        this.usagesByUri.delete(uri);
-        this.transientUsagesByUri.delete(uri);
-      }
-      /** Get all declared variables. */
-      getDeclared() {
-        return this.variables.declared;
-      }
-      /** Get all usages of a variable by base name. */
-      getUsages(name) {
-        return usagesOf(this.usagesByUri, name);
-      }
-      /** Every declaration location of a story or transient binding, in source order. */
-      getDeclarations(name, sigil) {
-        const declarations = sigil === "$" ? this.variables : this.transients;
-        return declarations.occurrences.flatMap((d) => d.name === name && d.declarationUri !== void 0 && d.declarationRange ? [{ uri: d.declarationUri, range: d.declarationRange }] : []);
-      }
-      /** The executable usage or declaration containing the cursor, in source coordinates. */
-      referenceAt(uri, position) {
-        const contains = (range2) => (position.line > range2.start.line || position.line === range2.start.line && position.character >= range2.start.character) && (position.line < range2.end.line || position.line === range2.end.line && position.character <= range2.end.character);
-        let atEnd = null;
-        for (const [sigil, usages, declarations] of [
-          ["$", this.usagesByUri.get(uri), this.variables.occurrences],
-          ["%", this.transientUsagesByUri.get(uri), this.transients.occurrences]
-        ]) {
-          const candidates = (usages ?? []).map((u) => ({ name: u.baseName, range: u.range }));
-          for (const declaration of declarations) {
-            if (declaration.declarationUri === uri && declaration.declarationRange) candidates.push({ name: declaration.name, range: declaration.declarationRange });
+        let bestIndex = null;
+        let bestRank = -Infinity;
+        let bestErrors = [];
+        let bestWarnings = [];
+        let bestIsClean = false;
+        for (let i2 = 0; i2 < this.variants.length; i2++) {
+          const variant = this.variants[i2];
+          if (variant.format === null) {
+            if (args2.length === 0) {
+              if (!bestIsClean || 0 > bestRank) {
+                bestIndex = i2;
+                bestRank = 0;
+                bestErrors = [];
+                bestWarnings = [];
+                bestIsClean = true;
+              }
+            } else {
+              if (!bestIsClean && bestIndex === null) {
+                bestIndex = i2;
+                bestRank = -1;
+                bestErrors = [{ message: "Expected no arguments", argIndex: 0 }];
+                bestWarnings = [];
+              }
+            }
+            continue;
           }
-          for (const candidate of candidates) {
-            if (!contains(candidate.range)) continue;
-            const symbol2 = { sigil, ...candidate };
-            if (position.line !== candidate.range.end.line || position.character < candidate.range.end.character) return symbol2;
-            atEnd ??= symbol2;
+          const result2 = crawlValidate(variant.format, args2, 0, stateInfo);
+          let errors = result2.errors;
+          if (result2.errors.length === 0 && result2.argIndex < args2.length) {
+            errors = [
+              {
+                message: `Too many arguments: expected ${result2.argIndex}, got ${args2.length}`,
+                argIndex: result2.argIndex
+              }
+            ];
           }
-        }
-        return atEnd;
-      }
-      /** Whether a StoryVariables passage has been parsed. */
-      hasStoryVariables() {
-        return this.variables.present;
-      }
-      /** Get all declared transient variables. */
-      getDeclaredTransient() {
-        return this.transients.declared;
-      }
-      /** Get all usages of a transient variable by base name. */
-      getTransientUsages(name) {
-        return usagesOf(this.transientUsagesByUri, name);
-      }
-      /** Whether a StoryTransients passage has been parsed. */
-      hasStoryTransients() {
-        return this.transients.present;
-      }
-      /**
-       * Get `$var.member` / `%var.member` accesses in a document where `var` is
-       * declared with an array literal default and `member` is not a property
-       * that JavaScript arrays have (so the access always yields undefined).
-       */
-      getArrayMemberAccesses(uri) {
-        const results = [];
-        const sources = [
-          ["$", this.usagesByUri.get(uri), this.variables.declared],
-          ["%", this.transientUsagesByUri.get(uri), this.transients.declared]
-        ];
-        for (const [sigil, usages, declared] of sources) {
-          for (const u of usages ?? []) {
-            const member = u.fullName.split(".")[1];
-            if (member === void 0) continue;
-            if (declared.get(u.baseName)?.type !== "array") continue;
-            if (ARRAY_MEMBERS.has(member) || /^(0|[1-9]\d*)$/.test(member) && Number(member) < 4294967295) continue;
-            results.push({ sigil, name: u.baseName, member, range: u.range });
+          const rank = result2.rank;
+          const isClean = errors.length === 0;
+          if (isClean && (!bestIsClean || rank > bestRank)) {
+            bestIndex = i2;
+            bestRank = rank;
+            bestErrors = [];
+            bestWarnings = result2.warnings;
+            bestIsClean = true;
+          } else if (!isClean && !bestIsClean && rank > bestRank) {
+            bestIndex = i2;
+            bestRank = rank;
+            bestErrors = errors;
+            bestWarnings = result2.warnings;
+          } else if (bestIndex === null) {
+            bestIndex = i2;
+            bestRank = rank;
+            bestErrors = errors;
+            bestWarnings = result2.warnings;
+            bestIsClean = isClean;
           }
         }
-        return results;
-      }
-      /** StoryVariables lines that stop Spindle from starting. */
-      getInvalidDeclarations() {
-        return this.variables.problems;
+        return {
+          variantIndex: bestIndex,
+          errors: bestErrors,
+          warnings: bestWarnings
+        };
       }
       /**
-       * StoryTransients lines that stop Spindle from starting, and the names it
-       * declares that StoryVariables declares too.
+       * Whether all variants are empty (accept no arguments).
        */
-      getInvalidTransientDeclarations() {
-        const collisions = [];
-        if (this.variables.present) {
-          for (const [name, range2] of this.transients.names) {
-            if (!this.variables.names.has(name)) continue;
-            collisions.push({
-              message: `StoryTransients: Variable "${name}" is already declared in StoryVariables. Names must be unique across scopes.`,
-              range: range2
-            });
-          }
-        }
-        return [...this.transients.problems, ...collisions].sort((a, b) => a.range.start.line - b.range.start.line);
+      isEmpty() {
+        if (this.variants.length === 0) return true;
+        return !this.variants.some((v2) => v2.format !== null);
       }
     };
   }
 });
 
-// src/core/markup/tokens.ts
-function* markupTokens(passage) {
-  yield* passage.tokens;
-  for (const piece of passage.pieces) {
-    if (piece.kind === "text") yield* piece.tokens;
-  }
-}
-function* macroTokens(passage) {
-  for (const token of markupTokens(passage)) {
-    if (token.type === "macro") yield token;
-  }
-}
-var init_tokens = __esm({
-  "src/core/markup/tokens.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/markup/widgets.ts
-function widgetSources(passages, macros) {
-  const sources = /* @__PURE__ */ new Map();
-  for (const passage of passages) {
-    if (!passage.isMarkup) continue;
-    const { name, tags } = passage.passage;
-    for (const definition2 of widgetDefinitions([{ name, tags, content: passage.content }], macros)) {
-      sources.set(definition2, passage);
-    }
+// src/core/workspace/macro-registry.ts
+function applySupplement(info, entry) {
+  for (const field of ["description", "parameters", "parameterDocs", "children", "parents", "skipArgs"]) {
+    if (entry[field] !== void 0) Object.assign(info, { [field]: entry[field] });
   }
-  return sources;
+  if (entry.container !== void 0) info.block = entry.container;
 }
-var init_widgets = __esm({
-  "src/core/markup/widgets.ts"() {
-    "use strict";
-    init_tooling();
-  }
-});
-
-// src/core/workspace/widget-registry.ts
-var WidgetRegistry;
-var init_widget_registry = __esm({
-  "src/core/workspace/widget-registry.ts"() {
+var MacroRegistry;
+var init_macro_registry2 = __esm({
+  "src/core/workspace/macro-registry.ts"() {
     "use strict";
     init_tooling();
-    init_tokens();
-    init_widgets();
-    WidgetRegistry = class {
-      /** Widgets keyed by lower-cased name; Spindle resolves widgets case-insensitively. */
-      widgets = /* @__PURE__ */ new Map();
-      /** Half-typed declarations remain discoverable in the editor, without replacing effective widgets. */
-      incomplete = /* @__PURE__ */ new Map();
-      /** Per-URI set of lower-cased macro names opened in that document. */
-      invokedByUri = /* @__PURE__ */ new Map();
+    init_parameter_validator();
+    init_config_loader();
+    MacroRegistry = class {
+      macros = /* @__PURE__ */ new Map();
+      /** Entries as they were before the current user config was applied (undefined = absent). */
+      configSnapshot = /* @__PURE__ */ new Map();
+      /** Tier 3: macros discovered from Story.defineMacro() calls, keyed by lowercase name. */
+      discovered = /* @__PURE__ */ new Map();
+      /** Called after the set of macros or their metadata changed. */
+      onChange;
+      /** Tier 4: user config entries, kept so they can be re-applied over discovered macros. */
+      configEntries = /* @__PURE__ */ new Map();
       /**
-       * Read the widget definitions of `passages` (all of them, in workspace
-       * order). Public tooling selects the closed definitions in runtime phase
-       * order, preserving their identities so the original source is retained.
+       * Load the built-in macros: name, block, sub-macros, flags and typed
+       * parameters, from Spindle's tooling API (the release the LSP is built on).
+       * This is the base layer the other tiers overlay.
        */
-      scan(passages, macros) {
-        this.widgets.clear();
-        this.incomplete.clear();
-        const sources = widgetSources(passages, [...macros]);
-        const effective = new Set(effectiveWidgetDefinitions([...sources.keys()]));
-        for (const [definition2, markup] of sources) {
-          const widget = {
-            tooling: definition2,
-            name: definition2.name,
-            params: definition2.params,
-            uri: markup.passage.uri,
-            range: markup.range(definition2.start, definition2.end),
-            nameRange: markup.range(definition2.nameStart, definition2.nameEnd),
-            block: definition2.block
-          };
-          const key = definition2.name.toLowerCase();
-          if (effective.has(definition2)) this.widgets.set(key, widget);
-          else if (definition2.closeStart === void 0) this.incomplete.set(key, widget);
+      loadBuiltins() {
+        for (const m of builtinMacros) {
+          this.macros.set(m.name.toLowerCase(), {
+            name: m.name,
+            block: m.block,
+            subMacros: [...m.subMacros],
+            storeVar: m.storeVar,
+            interpolate: m.interpolate,
+            merged: m.merged,
+            source: m.source === "builtin" ? "builtin" : "user",
+            parameterDefs: m.parameters
+          });
         }
       }
-      /** The effective definition, or an incomplete declaration while its first definition is being typed. */
-      getWidget(name) {
-        const key = name.toLowerCase();
-        return this.widgets.get(key) ?? this.incomplete.get(key);
-      }
-      /** Get the effective registered definitions, excluding incomplete editor declarations. */
-      getAllWidgets() {
-        return Array.from(this.widgets.values());
+      /**
+       * Overlay supplement data onto the registry.
+       * Supplements provide descriptions, parameters, children, parents, skipArgs.
+       * The `container` field maps to `block` on MacroInfo.
+       */
+      loadSupplements(supplements) {
+        this.mergeEntries(supplements);
+        this.onChange?.();
       }
-      /** The effective widget whose declared name contains the cursor. */
-      definitionAt(uri, position) {
-        return this.getAllWidgets().find((widget) => {
-          const { start, end } = widget.nameRange;
-          return widget.uri === uri && position.line === start.line && position.character >= start.character && position.character <= end.character;
-        });
+      /**
+       * Overlay user config onto the registry.
+       * Same format as supplements; applied last so it wins.
+       *
+       * Replaces any previously loaded config: entries from the last call are
+       * reverted first, so macros removed from the config disappear (or fall
+       * back to their builtin/supplement definition).
+       */
+      loadConfig(config2) {
+        config2 = normalizeMacroEntries(config2);
+        for (const [key, previous2] of this.configSnapshot) {
+          if (previous2) {
+            this.macros.set(key, previous2);
+          } else {
+            this.macros.delete(key);
+          }
+        }
+        this.configSnapshot.clear();
+        this.configEntries.clear();
+        for (const rawKey of Object.keys(config2)) {
+          const key = rawKey.toLowerCase();
+          if (!this.configSnapshot.has(key)) {
+            const existing = this.macros.get(key);
+            this.configSnapshot.set(key, existing ? { ...existing } : void 0);
+          }
+          this.configEntries.set(key, { ...this.configEntries.get(key), ...config2[rawKey] });
+        }
+        this.mergeEntries(config2);
+        this.onChange?.();
       }
       /**
-       * Record the macros opened in a document (its tags and those in the labels
-       * and attribute values that hold markup), replacing any previous record for
-       * that URI. Spindle resolves widget names case-insensitively, so names are
-       * stored lower-cased.
+       * Replace the set of macros discovered from Story.defineMacro() calls.
+       * Previously discovered definitions that are no longer present are dropped,
+       * restoring whatever the other tiers define for that name.
+       *
+       * Each sub-macro becomes a known macro that may only appear inside its
+       * parent. Whether a macro is a block is the tooling API's reading of the
+       * definition (`discoverMacros`).
        */
-      recordInvocations(uri, passages) {
-        const names = /* @__PURE__ */ new Set();
-        for (const passage of passages) {
-          for (const macro of macroTokens(passage)) {
-            if (!macro.isClose) names.add(macro.name.toLowerCase());
+      setDiscoveredMacros(macros) {
+        this.discovered.clear();
+        for (const m of macros) {
+          this.discovered.set(m.name.toLowerCase(), {
+            name: m.name,
+            block: m.block,
+            subMacros: m.subMacros,
+            storeVar: m.storeVar,
+            interpolate: m.interpolate,
+            merged: m.merged,
+            description: m.description,
+            source: "user",
+            parameterDefs: m.parameters
+          });
+        }
+        for (const m of [...this.discovered.values()]) {
+          for (const sub of m.subMacros ?? []) {
+            const key = sub.toLowerCase();
+            const existing = this.discovered.get(key);
+            if (existing) {
+              existing.parents = [...existing.parents ?? [], m.name];
+            } else {
+              this.discovered.set(key, { name: sub, block: false, subMacros: [], source: "user", parents: [m.name] });
+            }
           }
         }
-        this.invokedByUri.set(uri, names);
+        this.onChange?.();
       }
-      /** Forget all recorded invocations. */
-      clearInvocations() {
-        this.invokedByUri.clear();
+      /** Add or replace a single macro entry. */
+      addMacro(info) {
+        const key = info.name.toLowerCase();
+        const existing = this.macros.get(key);
+        this.macros.set(key, {
+          name: info.name,
+          block: info.block ?? existing?.block ?? false,
+          subMacros: info.subMacros ?? existing?.subMacros ?? [],
+          source: info.source ?? existing?.source ?? "user",
+          storeVar: info.storeVar ?? existing?.storeVar,
+          interpolate: info.interpolate ?? existing?.interpolate,
+          merged: info.merged ?? existing?.merged,
+          description: info.description ?? existing?.description,
+          parameters: info.parameters ?? existing?.parameters,
+          parameterDefs: info.parameterDefs ?? existing?.parameterDefs,
+          parameterDocs: info.parameterDocs ?? existing?.parameterDocs,
+          children: info.children ?? existing?.children,
+          parents: info.parents ?? existing?.parents,
+          skipArgs: info.skipArgs ?? existing?.skipArgs
+        });
+        this.onChange?.();
       }
-      /** Whether any recorded document invokes the widget `{name}`. */
-      isInvoked(name) {
-        const key = name.toLowerCase();
-        for (const names of this.invokedByUri.values()) {
-          if (names.has(key)) return true;
+      /** Get a macro by name (case-insensitive). */
+      getMacro(name) {
+        return this.resolve(name.toLowerCase());
+      }
+      /** A project's explicit schema takes precedence over runtime signature metadata. */
+      hasConfiguredParameters(name) {
+        return this.configEntries.get(name.toLowerCase())?.parameters !== void 0;
+      }
+      /** Check if a macro is a block (container) macro. */
+      isBlock(name) {
+        return this.getMacro(name)?.block ?? false;
+      }
+      /** Check if a macro is a sub-macro (has parents). */
+      isSubMacro(name) {
+        const info = this.getMacro(name);
+        return info?.parents != null && info.parents.length > 0;
+      }
+      /** The macros as the tooling API reads them (`passagePieces`, `validateStoryMarkup`). */
+      toolingMacros() {
+        return this.getAllMacros().map((m) => ({
+          name: m.name,
+          block: m.block,
+          subMacros: m.subMacros,
+          storeVar: m.storeVar,
+          interpolate: m.interpolate,
+          parameters: m.parameterDefs,
+          widget: this.configuredToolingParameters(m.name)
+        }));
+      }
+      /** Whether an invoked configured schema prevents a safe passage rename. */
+      hasUnsafeConfiguredPassages(name) {
+        const positions = this.configuredPassagePositions(name);
+        if (positions === void 0) return false;
+        if (positions === null) return true;
+        const definitions = this.getMacro(name)?.parameterDefs;
+        if (!definitions?.length) return false;
+        const runtimePositions = definitions.flatMap((parameter, i2) => parameter.type === "passage" || parameter.holds === "passage" ? [i2] : []);
+        if (definitions.some((parameter) => parameter.type === "options" || parameter.type === "names" || parameter.type === "text" || parameter.type === "separator")) {
+          return positions.length > 0 || runtimePositions.length > 0;
+        }
+        return positions.length !== runtimePositions.length || positions.some((position, i2) => position !== runtimePositions[i2]);
+      }
+      configuredPassagePositions(name) {
+        const parameters = this.configEntries.get(name.toLowerCase())?.parameters;
+        if (parameters === void 0) return void 0;
+        try {
+          return new Parameters(parameters).passagePositions();
+        } catch {
+          return null;
+        }
+      }
+      configuredToolingParameters(name) {
+        const positions = this.configuredPassagePositions(name);
+        if (!positions?.length || this.getMacro(name)?.parameterDefs?.length) return void 0;
+        const params = Array.from({ length: positions.at(-1) + 1 }, (_2, i2) => `arg${i2}`);
+        return { params, holds: Object.fromEntries(positions.map((i2) => [params[i2], "passage"])) };
+      }
+      /** Get all registered macros. */
+      getAllMacros() {
+        const keys = /* @__PURE__ */ new Set([...this.macros.keys(), ...this.discovered.keys()]);
+        return Array.from(keys, (key) => this.resolve(key));
+      }
+      /**
+       * Compose the effective entry for a lowercase key: builtins/supplements/
+       * config (stored in `macros`), overlaid by discovered metadata, with user
+       * config re-applied on top so it keeps precedence.
+       */
+      resolve(key) {
+        const base = this.macros.get(key);
+        const found = this.discovered.get(key);
+        if (!found) return base;
+        const info = {
+          name: found.name,
+          block: found.block ?? false,
+          subMacros: found.subMacros ?? [],
+          source: "user",
+          storeVar: found.storeVar,
+          interpolate: found.interpolate,
+          merged: found.merged,
+          description: found.description,
+          // A definition replaces the macro it names, parameters included
+          parameterDefs: found.parameterDefs,
+          parents: found.parents
+        };
+        const config2 = this.configEntries.get(key);
+        if (config2) applySupplement(info, config2);
+        return info;
+      }
+      /** Merge a set of supplement/config entries into the registry. */
+      mergeEntries(entries) {
+        for (const [rawKey, entry] of Object.entries(entries)) {
+          const key = rawKey.toLowerCase();
+          const existing = this.macros.get(key);
+          if (existing) {
+            applySupplement(existing, entry);
+          } else {
+            this.macros.set(key, {
+              name: entry.name ?? rawKey,
+              block: entry.container ?? false,
+              subMacros: [],
+              source: "user",
+              description: entry.description,
+              parameters: entry.parameters,
+              parameterDocs: entry.parameterDocs,
+              children: entry.children,
+              parents: entry.parents,
+              skipArgs: entry.skipArgs
+            });
+          }
         }
-        return false;
       }
     };
   }
 });
 
-// src/core/markup/markup-index.ts
-function sameHeaders(a, b) {
-  return a.length === b.length && a.every((p, i2) => p === b[i2]);
+// src/core/parsing/executable-refs.ts
+function collectVariableReferences2(markup) {
+  if (!markup.isMarkup) return [];
+  return variableReferences(markup.content, markup.doc.context.macros, { all: true }).map((ref2) => ({
+    sigil: ref2.sigil,
+    name: ref2.name,
+    path: [ref2.name, ...ref2.path].join("."),
+    start: ref2.start,
+    end: ref2.end
+  }));
 }
-var MarkupIndex;
-var init_markup_index = __esm({
-  "src/core/markup/markup-index.ts"() {
+var init_executable_refs = __esm({
+  "src/core/parsing/executable-refs.ts"() {
     "use strict";
-    init_passage_markup();
-    MarkupIndex = class {
-      constructor(sources) {
-        this.sources = sources;
-      }
-      sources;
-      cache = /* @__PURE__ */ new Map();
-      context;
-      /** The markup of document `uri`, or undefined if it is not open. */
-      get(uri) {
-        const text3 = this.sources.text(uri);
-        if (text3 === void 0) return void 0;
-        const kept3 = this.cache.get(uri);
-        const passages = this.sources.passages(uri);
-        if (kept3 && kept3.text === text3 && sameHeaders(kept3.passages.map((p) => p.passage), passages)) return kept3;
-        this.context ??= this.sources.context();
-        const fresh = new DocumentMarkup(uri, text3, passages, this.context);
-        this.cache.set(uri, fresh);
-        return fresh;
-      }
-      /** The macros or widgets changed: every document's markup is read again on demand. */
-      invalidate() {
-        this.cache.clear();
-        this.context = void 0;
-      }
-    };
+    init_tooling();
   }
 });
 
-// src/core/workspace/spindle-version.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname2, join as join3, resolve as resolve4 } from "node:path";
-import { fileURLToPath } from "node:url";
-function parseSpindleVersion(text3) {
-  const m = /^\s*v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?\s*$/.exec(text3);
-  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : void 0;
+// src/core/markup/passage-markup.ts
+var PassageMarkup, DocumentMarkup;
+var init_passage_markup = __esm({
+  "src/core/markup/passage-markup.ts"() {
+    "use strict";
+    init_tooling();
+    init_passage_parser();
+    init_text();
+    PassageMarkup = class {
+      constructor(doc, passage, bodyStart, bodyEnd) {
+        this.doc = doc;
+        this.passage = passage;
+        this.bodyStart = bodyStart;
+        this.bodyEnd = bodyEnd;
+        const raw = doc.text.slice(bodyStart, bodyEnd);
+        this.isMarkup = isMarkupPassage(passage);
+        if (raw.includes("\r\n")) {
+          const map2 = [];
+          let content2 = "";
+          for (let i2 = 0; i2 < raw.length; i2++) {
+            if (raw[i2] === "\r" && raw[i2 + 1] === "\n") continue;
+            map2.push(bodyStart + i2);
+            content2 += raw[i2];
+          }
+          map2.push(bodyEnd);
+          this.content = content2;
+          this.toDoc = Int32Array.from(map2);
+        } else {
+          this.content = raw;
+          this.toDoc = null;
+        }
+      }
+      doc;
+      passage;
+      bodyStart;
+      bodyEnd;
+      /** The body, LF-normalized: the text the tooling API analyzes. */
+      content;
+      /** Whether Spindle reads the body as story markup (see isMarkupPassage). */
+      isMarkup;
+      /** For each `content` offset, its offset in the document; null when the body has no CRLF. */
+      toDoc;
+      cachedTokens;
+      cachedPairing;
+      cachedPieces;
+      cachedDeclarations;
+      /** The document offset of `contentOffset`. */
+      docOffset(contentOffset) {
+        if (!this.toDoc) return this.bodyStart + contentOffset;
+        return this.toDoc[Math.min(Math.max(contentOffset, 0), this.toDoc.length - 1)];
+      }
+      /**
+       * The document offset just past the character before `contentEnd`: where an
+       * exclusive end maps to. (`docOffset()` of an end that sits before a line
+       * break would land behind the `\r` of a CRLF.)
+       */
+      docEnd(contentEnd) {
+        return contentEnd <= 0 ? this.docOffset(0) : this.docOffset(contentEnd - 1) + 1;
+      }
+      /** The `content` offset of a document offset (the nearest one at or after it). */
+      contentOffset(docOffset) {
+        if (!this.toDoc) return Math.min(Math.max(docOffset - this.bodyStart, 0), this.content.length);
+        let low = 0;
+        let high = this.toDoc.length - 1;
+        while (low < high) {
+          const mid = low + high >> 1;
+          if (this.toDoc[mid] < docOffset) low = mid + 1;
+          else high = mid;
+        }
+        return low;
+      }
+      /** The document position of `contentOffset`. */
+      position(contentOffset) {
+        return offsetToPosition(this.docOffset(contentOffset), this.doc.lineStarts);
+      }
+      /** The document range of `[start, end)` in `content` offsets. */
+      range(start, end) {
+        return offsetsToRange(this.docOffset(start), end > start ? this.docEnd(end) : this.docOffset(start), this.doc.lineStarts);
+      }
+      /** The flat tokens and the malformed tags; none for a passage that is not markup. */
+      get tokenization() {
+        return this.cachedTokens ??= this.isMarkup ? tokenizeMarkupTolerant(this.content) : { tokens: [], errors: [] };
+      }
+      get tokens() {
+        return this.tokenization.tokens;
+      }
+      /** The tree of paired tokens, and what does not pair. */
+      get pairing() {
+        return this.cachedPairing ??= pairMarkup(this.tokens, {
+          isBlock: (name) => this.doc.context.isBlock(name),
+          source: this.content
+        });
+      }
+      /** What the markup runs and names, and where (see `passagePieces`). */
+      get pieces() {
+        return this.cachedPieces ??= this.isMarkup ? passagePieces(this.content, this.doc.context.macros) : [];
+      }
+      /** The declarations of a StoryVariables / StoryTransients passage. */
+      get declarations() {
+        return this.cachedDeclarations ??= parseDeclarations(this.content, this.passage.name === "StoryTransients" ? "%" : "$");
+      }
+    };
+    DocumentMarkup = class {
+      constructor(uri, text3, passages, context) {
+        this.uri = uri;
+        this.text = text3;
+        this.context = context;
+        this.lineStarts = buildLineStarts(text3);
+        this.passages = passages.map((passage, i2) => {
+          const bodyStart = this.lineStarts[passage.headerEnd.end.line + 1] ?? text3.length;
+          const next = passages[i2 + 1];
+          const bodyEnd = next ? this.lineStarts[next.range.start.line] : text3.length;
+          return new PassageMarkup(this, passage, Math.min(bodyStart, bodyEnd), bodyEnd);
+        });
+      }
+      uri;
+      text;
+      context;
+      lineStarts;
+      passages;
+      /** The passage that contains `position`. */
+      passageAt(position) {
+        for (let i2 = this.passages.length - 1; i2 >= 0; i2--) {
+          if (this.passages[i2].passage.range.start.line <= position.line) return this.passages[i2];
+        }
+        return void 0;
+      }
+    };
+  }
+});
+
+// src/core/workspace/declaration-check.ts
+function readDeclarations(content2, sigil) {
+  const passage = PASSAGE[sigil];
+  const lines = content2.replace(/\r\n/g, "\n").split("\n");
+  const header = lines.findIndex((line) => /^?::/.test(line));
+  const text3 = (header === -1 ? lines : lines.slice(0, header)).join("\n");
+  const { declarations, errors } = parseDeclarations(text3.replace(/\r/g, " "), sigil);
+  const problems = [];
+  for (const error48 of errors) {
+    if (error48.code === "duplicate-declaration") continue;
+    const [start, end] = lineSpan(text3, error48.offset);
+    if (isUnjudged(text3.slice(start, end))) continue;
+    let message = `${passage}: ${error48.message}`;
+    if (error48.code === "invalid-declaration" && COMMENT_START.test(text3.slice(error48.offset, error48.end))) {
+      message += `. ${passage} has no comment syntax.`;
+    } else if (!message.endsWith(".")) {
+      message += ".";
+    }
+    problems.push({ message, start, end });
+  }
+  return { text: text3, declarations, problems: problems.sort((a, b) => a.start - b.start) };
+}
+function isUnjudged(line) {
+  return line.includes("\r") || line.includes("\xA0");
+}
+function lineSpan(text3, offset2) {
+  const lineStart = text3.lastIndexOf("\n", offset2 - 1) + 1;
+  const lineEnd = text3.indexOf("\n", offset2);
+  const line = text3.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd);
+  const start = lineStart + line.length - line.trimStart().length;
+  return [start, lineStart + line.trimEnd().length];
+}
+var PASSAGE, COMMENT_START;
+var init_declaration_check = __esm({
+  "src/core/workspace/declaration-check.ts"() {
+    "use strict";
+    init_tooling();
+    PASSAGE = { "$": "StoryVariables", "%": "StoryTransients" };
+    COMMENT_START = /^(?:\/\/|\/\*|<!--|#)/;
+  }
+});
+
+// src/core/workspace/variable-tracker.ts
+function standaloneMarkup(uri, text3) {
+  const index = new PassageIndex();
+  index.rebuild(uri, text3);
+  return new DocumentMarkup(uri, text3, index.getPassagesInDocument(uri), BUILTIN_CONTEXT);
+}
+function usagesOf(byUri, name) {
+  const results = [];
+  for (const usages of byUri.values()) {
+    for (const u of usages) {
+      if (u.baseName === name) results.push({ uri: u.uri, range: u.range });
+    }
+  }
+  return results;
+}
+var BUILTIN_CONTEXT, ARRAY_MEMBERS, DeclarationSet, VariableTracker;
+var init_variable_tracker = __esm({
+  "src/core/workspace/variable-tracker.ts"() {
+    "use strict";
+    init_tooling();
+    init_executable_refs();
+    init_passage_markup();
+    init_text();
+    init_passage_index();
+    init_declaration_check();
+    BUILTIN_CONTEXT = { macros: builtinMacros, isBlock: isBlockMacro };
+    ARRAY_MEMBERS = /* @__PURE__ */ new Set([
+      ...Object.getOwnPropertyNames(Array.prototype),
+      ...Object.getOwnPropertyNames(Object.prototype),
+      "at",
+      "flat",
+      "flatMap",
+      "includes",
+      "findLast",
+      "findLastIndex",
+      "toReversed",
+      "toSorted",
+      "toSpliced",
+      "with"
+    ]);
+    DeclarationSet = class {
+      constructor(sigil) {
+        this.sigil = sigil;
+      }
+      sigil;
+      present = false;
+      declared = /* @__PURE__ */ new Map();
+      /** Every declaration, including earlier defaults for the same binding. */
+      occurrences = [];
+      /** Lines Spindle rejects. */
+      problems = [];
+      /** The names declared, with the range of sigil and name of the first. */
+      names = /* @__PURE__ */ new Map();
+      clear() {
+        this.present = false;
+        this.declared.clear();
+        this.occurrences.length = 0;
+        this.problems = [];
+        this.names.clear();
+      }
+      /** Read the passage `content`, which starts at line `contentStartLine` of the document `uri`. */
+      read(content2, contentStartLine, uri) {
+        this.clear();
+        this.present = true;
+        const { text: text3, declarations, problems } = readDeclarations(content2, this.sigil);
+        const lineStarts = buildLineStarts(text3);
+        const position = (offset2) => {
+          const { line, character } = offsetToPosition(offset2, lineStarts);
+          return { line: contentStartLine + line, character };
+        };
+        for (const problem of problems) {
+          this.problems.push({ message: problem.message, range: { start: position(problem.start), end: position(problem.end) } });
+        }
+        for (const declaration of declarations) {
+          const { name, schema } = declaration;
+          const declarationRange = { start: position(declaration.nameStart - 1), end: position(declaration.nameEnd) };
+          const declared = { name, sigil: this.sigil, declarationRange };
+          if (uri !== void 0) declared.declarationUri = uri;
+          if (schema) {
+            if (schema.type !== "null") declared.type = schema.type;
+            if (schema.fields && schema.fields.size > 0) declared.fields = [...schema.fields.keys()];
+          }
+          this.declared.set(name, declared);
+          this.occurrences.push(declared);
+          if (!this.names.has(name)) this.names.set(name, declarationRange);
+        }
+      }
+    };
+    VariableTracker = class {
+      variables = new DeclarationSet("$");
+      transients = new DeclarationSet("%");
+      /** Per-URI list of variable usages. */
+      usagesByUri = /* @__PURE__ */ new Map();
+      /** Per-URI list of transient variable usages. */
+      transientUsagesByUri = /* @__PURE__ */ new Map();
+      /**
+       * Parse the StoryVariables passage content for declarations.
+       * Each line like `$name = value` becomes a declaration.
+       */
+      parseStoryVariables(content2, contentStartLine = 0, uri) {
+        this.variables.read(content2, contentStartLine, uri);
+      }
+      /** Forget StoryVariables declarations, e.g. after the passage was removed. */
+      clearStoryVariables() {
+        this.variables.clear();
+      }
+      /** Forget StoryTransients declarations, e.g. after the passage was removed. */
+      clearStoryTransients() {
+        this.transients.clear();
+      }
+      /**
+       * Parse the StoryTransients passage content for declarations.
+       * Each line like `%name = value` becomes a declaration.
+       */
+      parseStoryTransients(content2, contentStartLine = 0, uri) {
+        this.transients.read(content2, contentStartLine, uri);
+      }
+      /**
+       * Scan a document for variable usages: the `$` and `%` references in the
+       * markup of its passages (see `collectVariableReferences`). The workspace
+       * passes the `markup` it reads the document with, which knows the project's
+       * macros and widgets; without it the built-in macros decide.
+       */
+      scanDocument(uri, text3, markup = standaloneMarkup(uri, text3)) {
+        this.removeDocument(uri);
+        const usages = [];
+        const transientUsages = [];
+        for (const passage of markup.passages) {
+          for (const ref2 of collectVariableReferences2(passage)) {
+            const usage = {
+              uri,
+              baseName: ref2.name,
+              fullName: ref2.path,
+              range: passage.range(ref2.start, ref2.end)
+            };
+            (ref2.sigil === "$" ? usages : transientUsages).push(usage);
+          }
+        }
+        if (usages.length > 0) this.usagesByUri.set(uri, usages);
+        if (transientUsages.length > 0) this.transientUsagesByUri.set(uri, transientUsages);
+      }
+      /** Forget the usages recorded for a document, e.g. after it was deleted. */
+      removeDocument(uri) {
+        this.usagesByUri.delete(uri);
+        this.transientUsagesByUri.delete(uri);
+      }
+      /** Get all declared variables. */
+      getDeclared() {
+        return this.variables.declared;
+      }
+      /** Get all usages of a variable by base name. */
+      getUsages(name) {
+        return usagesOf(this.usagesByUri, name);
+      }
+      /** Every declaration location of a story or transient binding, in source order. */
+      getDeclarations(name, sigil) {
+        const declarations = sigil === "$" ? this.variables : this.transients;
+        return declarations.occurrences.flatMap((d) => d.name === name && d.declarationUri !== void 0 && d.declarationRange ? [{ uri: d.declarationUri, range: d.declarationRange }] : []);
+      }
+      /** The executable usage or declaration containing the cursor, in source coordinates. */
+      referenceAt(uri, position) {
+        const contains = (range2) => (position.line > range2.start.line || position.line === range2.start.line && position.character >= range2.start.character) && (position.line < range2.end.line || position.line === range2.end.line && position.character <= range2.end.character);
+        let atEnd = null;
+        for (const [sigil, usages, declarations] of [
+          ["$", this.usagesByUri.get(uri), this.variables.occurrences],
+          ["%", this.transientUsagesByUri.get(uri), this.transients.occurrences]
+        ]) {
+          const candidates = (usages ?? []).map((u) => ({ name: u.baseName, range: u.range }));
+          for (const declaration of declarations) {
+            if (declaration.declarationUri === uri && declaration.declarationRange) candidates.push({ name: declaration.name, range: declaration.declarationRange });
+          }
+          for (const candidate of candidates) {
+            if (!contains(candidate.range)) continue;
+            const symbol2 = { sigil, ...candidate };
+            if (position.line !== candidate.range.end.line || position.character < candidate.range.end.character) return symbol2;
+            atEnd ??= symbol2;
+          }
+        }
+        return atEnd;
+      }
+      /** Whether a StoryVariables passage has been parsed. */
+      hasStoryVariables() {
+        return this.variables.present;
+      }
+      /** Get all declared transient variables. */
+      getDeclaredTransient() {
+        return this.transients.declared;
+      }
+      /** Get all usages of a transient variable by base name. */
+      getTransientUsages(name) {
+        return usagesOf(this.transientUsagesByUri, name);
+      }
+      /** Whether a StoryTransients passage has been parsed. */
+      hasStoryTransients() {
+        return this.transients.present;
+      }
+      /**
+       * Get `$var.member` / `%var.member` accesses in a document where `var` is
+       * declared with an array literal default and `member` is not a property
+       * that JavaScript arrays have (so the access always yields undefined).
+       */
+      getArrayMemberAccesses(uri) {
+        const results = [];
+        const sources = [
+          ["$", this.usagesByUri.get(uri), this.variables.declared],
+          ["%", this.transientUsagesByUri.get(uri), this.transients.declared]
+        ];
+        for (const [sigil, usages, declared] of sources) {
+          for (const u of usages ?? []) {
+            const member = u.fullName.split(".")[1];
+            if (member === void 0) continue;
+            if (declared.get(u.baseName)?.type !== "array") continue;
+            if (ARRAY_MEMBERS.has(member) || /^(0|[1-9]\d*)$/.test(member) && Number(member) < 4294967295) continue;
+            results.push({ sigil, name: u.baseName, member, range: u.range });
+          }
+        }
+        return results;
+      }
+      /** StoryVariables lines that stop Spindle from starting. */
+      getInvalidDeclarations() {
+        return this.variables.problems;
+      }
+      /**
+       * StoryTransients lines that stop Spindle from starting, and the names it
+       * declares that StoryVariables declares too.
+       */
+      getInvalidTransientDeclarations() {
+        const collisions = [];
+        if (this.variables.present) {
+          for (const [name, range2] of this.transients.names) {
+            if (!this.variables.names.has(name)) continue;
+            collisions.push({
+              message: `StoryTransients: Variable "${name}" is already declared in StoryVariables. Names must be unique across scopes.`,
+              range: range2
+            });
+          }
+        }
+        return [...this.transients.problems, ...collisions].sort((a, b) => a.range.start.line - b.range.start.line);
+      }
+    };
+  }
+});
+
+// src/core/markup/tokens.ts
+function* markupTokens(passage) {
+  yield* passage.tokens;
+  for (const piece of passage.pieces) {
+    if (piece.kind === "text") yield* piece.tokens;
+  }
+}
+function* macroTokens(passage) {
+  for (const token of markupTokens(passage)) {
+    if (token.type === "macro") yield token;
+  }
+}
+var init_tokens = __esm({
+  "src/core/markup/tokens.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/markup/widgets.ts
+function widgetSources(passages, macros) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const passage of passages) {
+    if (!passage.isMarkup) continue;
+    const { name, tags } = passage.passage;
+    for (const definition2 of widgetDefinitions([{ name, tags, content: passage.content }], macros)) {
+      sources.set(definition2, passage);
+    }
+  }
+  return sources;
+}
+var init_widgets = __esm({
+  "src/core/markup/widgets.ts"() {
+    "use strict";
+    init_tooling();
+  }
+});
+
+// src/core/workspace/widget-registry.ts
+var WidgetRegistry;
+var init_widget_registry = __esm({
+  "src/core/workspace/widget-registry.ts"() {
+    "use strict";
+    init_tooling();
+    init_tokens();
+    init_widgets();
+    WidgetRegistry = class {
+      /** Widgets keyed by lower-cased name; Spindle resolves widgets case-insensitively. */
+      widgets = /* @__PURE__ */ new Map();
+      /** Half-typed declarations remain discoverable in the editor, without replacing effective widgets. */
+      incomplete = /* @__PURE__ */ new Map();
+      /** Per-URI set of lower-cased macro names opened in that document. */
+      invokedByUri = /* @__PURE__ */ new Map();
+      /**
+       * Read the widget definitions of `passages` (all of them, in workspace
+       * order). Public tooling selects the closed definitions in runtime phase
+       * order, preserving their identities so the original source is retained.
+       */
+      scan(passages, macros) {
+        this.widgets.clear();
+        this.incomplete.clear();
+        const sources = widgetSources(passages, [...macros]);
+        const effective = new Set(effectiveWidgetDefinitions([...sources.keys()]));
+        for (const [definition2, markup] of sources) {
+          const widget = {
+            tooling: definition2,
+            name: definition2.name,
+            params: definition2.params,
+            uri: markup.passage.uri,
+            range: markup.range(definition2.start, definition2.end),
+            nameRange: markup.range(definition2.nameStart, definition2.nameEnd),
+            block: definition2.block
+          };
+          const key = definition2.name.toLowerCase();
+          if (effective.has(definition2)) this.widgets.set(key, widget);
+          else if (definition2.closeStart === void 0) this.incomplete.set(key, widget);
+        }
+      }
+      /** The effective definition, or an incomplete declaration while its first definition is being typed. */
+      getWidget(name) {
+        const key = name.toLowerCase();
+        return this.widgets.get(key) ?? this.incomplete.get(key);
+      }
+      /** Get the effective registered definitions, excluding incomplete editor declarations. */
+      getAllWidgets() {
+        return Array.from(this.widgets.values());
+      }
+      /** The effective widget whose declared name contains the cursor. */
+      definitionAt(uri, position) {
+        return this.getAllWidgets().find((widget) => {
+          const { start, end } = widget.nameRange;
+          return widget.uri === uri && position.line === start.line && position.character >= start.character && position.character <= end.character;
+        });
+      }
+      /**
+       * Record the macros opened in a document (its tags and those in the labels
+       * and attribute values that hold markup), replacing any previous record for
+       * that URI. Spindle resolves widget names case-insensitively, so names are
+       * stored lower-cased.
+       */
+      recordInvocations(uri, passages) {
+        const names = /* @__PURE__ */ new Set();
+        for (const passage of passages) {
+          for (const macro of macroTokens(passage)) {
+            if (!macro.isClose) names.add(macro.name.toLowerCase());
+          }
+        }
+        this.invokedByUri.set(uri, names);
+      }
+      /** Forget all recorded invocations. */
+      clearInvocations() {
+        this.invokedByUri.clear();
+      }
+      /** Whether any recorded document invokes the widget `{name}`. */
+      isInvoked(name) {
+        const key = name.toLowerCase();
+        for (const names of this.invokedByUri.values()) {
+          if (names.has(key)) return true;
+        }
+        return false;
+      }
+    };
+  }
+});
+
+// src/core/markup/markup-index.ts
+function sameHeaders(a, b) {
+  return a.length === b.length && a.every((p, i2) => p === b[i2]);
+}
+var MarkupIndex;
+var init_markup_index = __esm({
+  "src/core/markup/markup-index.ts"() {
+    "use strict";
+    init_passage_markup();
+    MarkupIndex = class {
+      constructor(sources) {
+        this.sources = sources;
+      }
+      sources;
+      cache = /* @__PURE__ */ new Map();
+      context;
+      /** The markup of document `uri`, or undefined if it is not open. */
+      get(uri) {
+        const text3 = this.sources.text(uri);
+        if (text3 === void 0) return void 0;
+        const kept3 = this.cache.get(uri);
+        const passages = this.sources.passages(uri);
+        if (kept3 && kept3.text === text3 && sameHeaders(kept3.passages.map((p) => p.passage), passages)) return kept3;
+        this.context ??= this.sources.context();
+        const fresh = new DocumentMarkup(uri, text3, passages, this.context);
+        this.cache.set(uri, fresh);
+        return fresh;
+      }
+      /** The macros or widgets changed: every document's markup is read again on demand. */
+      invalidate() {
+        this.cache.clear();
+        this.context = void 0;
+      }
+    };
+  }
+});
+
+// src/core/workspace/spindle-version.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname2, join as join3, resolve as resolve4 } from "node:path";
+import { fileURLToPath } from "node:url";
+function parseSpindleVersion(text3) {
+  const m = /^\s*v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?\s*$/.exec(text3);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : void 0;
 }
 function atLeast(version2, minimum) {
   const min = parseSpindleVersion(minimum);
@@ -32924,1065 +33601,470 @@ var init_macro_supplements = __esm({
           { name: "variable", documentation: "Variable to watch for changes." }
         ]
       },
-      unwatch: {
-        name: "unwatch",
-        description: "Stops watching a variable.\n\nUsage: `{unwatch $var}`",
-        parameters: ["...text"],
-        parameterDocs: [
-          { name: "variable", documentation: "Variable to stop watching." }
-        ]
-      },
-      unless: {
-        name: "unless",
-        container: true,
-        description: "Conditionally displays its contents when the expression is falsy. The inverse of `{if}`.\n\nUsage:\n\n```\n{unless condition}\n  ...\n{/unless}\n```",
-        parameters: ["...text"],
-        parameterDocs: [
-          { name: "condition", documentation: "Expression; the contents show when it is falsy." }
-        ]
-      }
-    };
-  }
-});
-
-// src/core/workspace/workspace-model.ts
-import { EventEmitter as EventEmitter2 } from "node:events";
-function storyInitMacros(content2) {
-  return passagePieces(content2, builtinMacros).flatMap((piece) => piece.kind === "code" && piece.goal === "statements" ? discoverMacros(piece.code) : []);
-}
-var WorkspaceModel;
-var init_workspace_model = __esm({
-  "src/core/workspace/workspace-model.ts"() {
-    "use strict";
-    init_tooling();
-    init_document_store();
-    init_passage_index();
-    init_macro_registry2();
-    init_variable_tracker();
-    init_widget_registry();
-    init_markup_index();
-    init_macro_sources();
-    init_story_format();
-    init_spindle_version();
-    init_macro_supplements();
-    WorkspaceModel = class extends EventEmitter2 {
-      documents;
-      passages;
-      _macros;
-      get macros() {
-        this.ensureCurrent();
-        return this._macros;
-      }
-      _variables;
-      get variables() {
-        this.ensureCurrent();
-        return this._variables;
-      }
-      _widgets;
-      get widgets() {
-        this.ensureCurrent();
-        return this._widgets;
-      }
-      /** Every document's markup, read through Spindle's tooling API. */
-      _markup;
-      get markup() {
-        this.ensureCurrent();
-        return this._markup;
-      }
-      /** True after initialize() has completed (full workspace scan done). */
-      initialized = false;
-      /** The story format declared by StoryData, updated with the passages. */
-      format = UNDECLARED_STORY_FORMAT;
-      /**
-       * The Spindle the project targets: the version installed under the
-       * workspace root, else StoryData's `format-version`. Only a version below
-       * {@link MINIMUM_SPINDLE_VERSION} matters (it is reported, not emulated).
-       */
-      _target;
-      get target() {
-        this.ensureCurrent();
-        return this._target;
-      }
-      workspaceRoot;
-      /** The version installed under the workspace root, read at startup and on refresh(). */
-      installedVersion;
-      /** The `format-version` StoryData declares. */
-      declaredVersion;
-      analysisPending = false;
-      debounceTimer = null;
-      DEBOUNCE_MS = 200;
-      /** Bound listeners for cleanup in dispose(). */
-      onDocumentChanged;
-      onDocumentOpened;
-      onDocumentClosed;
-      constructor(config2) {
-        super();
-        this.documents = new DocumentStore();
-        this.passages = new PassageIndex();
-        this._macros = new MacroRegistry();
-        this.macros.onChange = () => this.markup?.invalidate();
-        this._variables = new VariableTracker();
-        this._widgets = new WidgetRegistry();
-        this._markup = new MarkupIndex({
-          text: (uri) => this.documents.getText(uri),
-          passages: (uri) => this.passages.getPassagesInDocument(uri),
-          context: () => ({
-            macros: this.toolingMacros(),
-            isBlock: (name) => this.isContainer(name)
-          })
-        });
-        this.workspaceRoot = config2?.workspaceRoot;
-        this.installedVersion = this.workspaceRoot ? readInstalledSpindleVersion(this.workspaceRoot) : void 0;
-        this._target = resolveSpindleTarget(this.installedVersion);
-        this.macros.loadBuiltins();
-        this.macros.loadSupplements(macro_supplements_default);
-        this.onDocumentChanged = (uri) => this.handleDocumentChange(uri);
-        this.onDocumentOpened = (uri) => this.handleDocumentChange(uri);
-        this.onDocumentClosed = (uri) => this.handleDocumentClose(uri);
-        this.documents.on("documentChanged", this.onDocumentChanged);
-        this.documents.on("documentOpened", this.onDocumentOpened);
-        this.documents.on("documentClosed", this.onDocumentClosed);
-      }
-      /**
-       * Initialize the workspace in CLI/batch mode.
-       * Loads all file contents, builds indices, and emits 'modelReady'.
-       */
-      initialize(fileContents) {
-        this.documents.removeListener("documentOpened", this.onDocumentOpened);
-        this.documents.removeListener("documentChanged", this.onDocumentChanged);
-        for (const [uri, text3] of fileContents) {
-          this.documents.open(uri, text3);
-        }
-        this.documents.on("documentOpened", this.onDocumentOpened);
-        this.documents.on("documentChanged", this.onDocumentChanged);
-        this.rebuildAll();
-        this.initialized = true;
-        if (this.debounceTimer) clearTimeout(this.debounceTimer);
-        this.debounceTimer = null;
-        this.emit("modelReady");
-      }
-      /**
-       * Re-run cross-document analysis and schedule 'modelReady', e.g. after
-       * the macro configuration changed without any document changing.
-       */
-      refresh() {
-        if (this.workspaceRoot) this.installedVersion = readInstalledSpindleVersion(this.workspaceRoot);
-        this.analysisPending = true;
-        this.ensureCurrent();
-        this.scheduleModelReady();
-      }
-      /**
-       * Whether `{name}` opens a container that needs a `{/name}` closing tag:
-       * a block macro, or a block widget (one whose body renders `{@children}`).
-       * Like Spindle's set of block macros, either source makes a name a block.
-       */
-      isContainer(name) {
-        return this.macros.isBlock(name) || (this.widgets.getWidget(name)?.block ?? false);
-      }
-      /**
-       * Whether document `uri` declares any passage. A Twee document with no
-       * `::` header holds no passage (the compiler ignores text outside one), so
-       * there is no markup in it for any consumer to read.
-       */
-      hasPassages(uri) {
-        return this.passages.getPassagesInDocument(uri).length > 0;
-      }
-      /**
-       * The story format named by the project's StoryData passage (trimmed), or
-       * undefined if no StoryData passage names one.
-       */
-      get storyFormat() {
-        this.ensureCurrent();
-        return this.format.name;
-      }
-      /**
-       * Whether Spindle semantics apply to this project. False only if a
-       * StoryData passage names another story format (SugarCube, Harlowe, ...)
-       * and none names Spindle; a missing or unreadable StoryData counts as
-       * Spindle.
-       */
-      isSpindleProject() {
-        this.ensureCurrent();
-        return this.format.isSpindle;
-      }
-      /** Clean up listeners and timers. */
-      dispose() {
-        this.documents.removeListener("documentChanged", this.onDocumentChanged);
-        this.documents.removeListener("documentOpened", this.onDocumentOpened);
-        this.documents.removeListener("documentClosed", this.onDocumentClosed);
-        if (this.debounceTimer) {
-          clearTimeout(this.debounceTimer);
-          this.debounceTimer = null;
-        }
-        this.removeAllListeners();
-      }
-      /** Index local headers immediately; defer expensive cross-document analysis. */
-      handleDocumentChange(uri) {
-        const text3 = this.documents.getText(uri);
-        if (text3 !== void 0 && !isMacroSource(uri)) {
-          this.passages.rebuild(uri, text3);
-        }
-        this.analysisPending = true;
-        this.updateStoryFormat();
-        this.emit("documentChanged", uri);
-        this.emit("passagesUpdated", uri);
-        this.scheduleModelReady();
-      }
-      /** Remove local indices immediately and schedule cross-document analysis. */
-      handleDocumentClose(uri) {
-        this.passages.remove(uri);
-        this._variables.removeDocument(uri);
-        this.analysisPending = true;
-        this.updateStoryFormat();
-        this.emit("documentClosed", uri);
-        this.emit("passagesUpdated", uri);
-        this.scheduleModelReady();
-      }
-      /** Rebuild all indices from scratch. */
-      rebuildAll() {
-        for (const uri of this.documents.getUris()) {
-          const text3 = this.documents.getText(uri);
-          if (text3 !== void 0 && !isMacroSource(uri)) {
-            this.passages.rebuild(uri, text3);
-          }
-        }
-        this.analysisPending = true;
-        this.ensureCurrent();
-      }
-      /** Finish pending cross-document work once, before a feature reads the indices. */
-      ensureCurrent() {
-        if (!this.analysisPending) return;
-        this.analysisPending = false;
-        this.refreshDiscoveredMacros();
-        this.cascade();
-        this.updateStoryFormat();
-      }
-      /**
-       * Re-read the story format from the StoryData passages after the passage
-       * index changed, emitting 'storyFormatChanged' if it differs. Listeners
-       * that read the analysis indices finish pending analysis through getters.
-       */
-      updateStoryFormat() {
-        const format = resolveStoryFormat(storyDataFormats(
-          this.passages.getAllPassages(),
-          (uri) => this.documents.getText(uri)
-        ));
-        if (format.name === this.format.name && format.isSpindle === this.format.isSpindle) return;
-        this.format = format;
-        this.emit("storyFormatChanged", format);
-      }
-      /**
-       * Re-run static macro discovery over the workspace and replace the
-       * registry's discovered tier (dropping definitions whose source is gone).
-       *
-       * Sources scanned for Story.defineMacro({...}) calls:
-       *  - `{do}` blocks in StoryInit passages
-       *  - passages tagged `script` (Story JavaScript)
-       *  - JavaScript/TypeScript documents in the workspace
-       */
-      refreshDiscoveredMacros() {
-        const found = [];
-        const init = [];
-        for (const uri of this.documents.getUris().sort()) {
-          const text3 = this.documents.getText(uri);
-          if (!text3) continue;
-          if (isMacroSource(uri)) {
-            found.push(...discoverMacros(text3));
-            continue;
-          }
-          let lines;
-          for (const passage of this.passages.getPassagesInDocument(uri)) {
-            const isStoryInit = passage.name === "StoryInit";
-            const isScript = passage.tags?.includes("script") ?? false;
-            if (!isStoryInit && !isScript) continue;
-            lines ??= text3.split("\n");
-            const content2 = lines.slice(passage.headerEnd.end.line + 1, passage.range.end.line + 1).join("\n");
-            if (isScript) found.push(...discoverMacros(content2));
-            else init.push(...storyInitMacros(content2));
-          }
-        }
-        this.macros.setDiscoveredMacros([...found, ...init]);
-      }
-      /**
-       * Cascade: rescan variables and widgets based on current passages.
-       * Called after any passage index update.
-       *
-       * The markup of every document is read again (the macros may have changed),
-       * the widgets are defined from it, and then the variable usages and widget
-       * invocations are read from the same markup, which pairs its tags with the
-       * widgets just defined.
-       */
-      cascade() {
-        this.markup.invalidate();
-        this.declaredVersion = storyDataFormatVersion(this.passages.getAllPassages(), (uri) => this.documents.getText(uri));
-        this._target = resolveSpindleTarget(this.installedVersion, this.declaredVersion);
-        const declarations = (name) => {
-          const passage = this.passages.getPassage(name);
-          return passage ? this.markup.get(passage.uri)?.passages.find((p) => p.passage === passage) : void 0;
-        };
-        const variables = declarations("StoryVariables");
-        if (variables) this.variables.parseStoryVariables(variables.content, variables.passage.headerEnd.end.line + 1, variables.doc.uri);
-        else this.variables.clearStoryVariables();
-        const transients = declarations("StoryTransients");
-        if (transients) this.variables.parseStoryTransients(transients.content, transients.passage.headerEnd.end.line + 1, transients.doc.uri);
-        else this.variables.clearStoryTransients();
-        const readDocuments = () => this.documents.getUris().flatMap((uri) => {
-          const markup = isMacroSource(uri) ? void 0 : this.markup.get(uri);
-          return markup ? [markup] : [];
-        });
-        const markups = /* @__PURE__ */ new Map();
-        for (const doc of readDocuments()) for (const passage of doc.passages) markups.set(passage.passage, passage);
-        this.widgets.scan(
-          this.passages.getAllPassages().flatMap((passage) => markups.get(passage) ?? []),
-          this.macros.toolingMacros()
-        );
-        this.markup.invalidate();
-        this.widgets.clearInvocations();
-        for (const doc of readDocuments()) {
-          this.variables.scanDocument(doc.uri, doc.text, doc);
-          this.widgets.recordInvocations(doc.uri, doc.passages);
-        }
-      }
-      /** All runtime metadata, with real macros taking precedence over widgets. */
-      toolingMacros() {
-        const macros = this.macros.toolingMacros();
-        return [...macros, ...this.widgets.getAllWidgets().filter((widget) => !this.macros.getMacro(widget.name)).map((widget) => ({ name: widget.name, block: widget.block, subMacros: [], widget: widget.tooling }))];
-      }
-      /** Coalesce analysis and diagnostics across a burst of document changes. */
-      scheduleModelReady() {
-        if (this.debounceTimer) {
-          clearTimeout(this.debounceTimer);
-        }
-        this.debounceTimer = setTimeout(() => {
-          this.debounceTimer = null;
-          this.ensureCurrent();
-          this.emit("modelReady");
-        }, this.DEBOUNCE_MS);
-      }
-    };
-  }
-});
-
-// src/core/diagnostic-codes.ts
-function getSeverity(code) {
-  return severityMap[code];
-}
-var DiagnosticCode, severityMap;
-var init_diagnostic_codes = __esm({
-  "src/core/diagnostic-codes.ts"() {
-    "use strict";
-    DiagnosticCode = {
-      /** The Spindle the project targets is older than the oldest one supported. */
-      UnsupportedSpindleVersion: "SP001",
-      /** `unknown-macro`: a macro that is none of the built-in, configured or defined ones. */
-      UndefinedMacro: "SP100",
-      /** `unclosed-block`, `mismatched-closer`, `stray-closer` of a macro. */
-      MalformedContainer: "SP101",
-      /** Tags of an HTML element Spindle cannot read or pair. */
-      MalformedElement: "SP102",
-      /** A closing tag that closes no macro (`{/set}`), or is malformed (`{/}`, `{/if x}`). */
-      IllegalClosingTag: "SP104",
-      /** `unclosed-link`, `unclosed-expression`, `unclosed-macro`: a `[[`, `{$` or `{name` that is never ended. */
-      UnclosedMarkup: "SP105",
-      /** `code-syntax`: JavaScript that does not parse. */
-      CodeSyntaxError: "SP106",
-      /** `misplaced-branch` (`{else}` outside `{if}`), and a macro outside the parents it needs. */
-      InvalidChildren: "SP107",
-      /** A configured parameter schema rejects the arguments (macros Spindle declares nothing for). */
-      ExpectedNoArguments: "SP108",
-      /** `argument-error`: arguments that do not have their parameters' forms. */
-      ParameterTypeError: "SP109",
-      ParameterWarning: "SP110",
-      TooManyArguments: "SP111",
-      /** `unquoted-passage-name`: `{goto Kitchen}`, which throws a ReferenceError. */
-      UnquotedPassageName: "SP113",
-      ChildMaxExceeded: "SP114",
-      ChildMinNotMet: "SP115",
-      /** `undeclared-variable`. */
-      UndeclaredVariable: "SP200",
-      /** `primitive-field`: a field of a number, string or boolean. */
-      PrimitiveFieldAccess: "SP201",
-      NoStoryVariables: "SP202",
-      /** `undeclared-transient`. */
-      UndeclaredTransient: "SP203",
-      TemporaryAssignedInLoop: "SP205",
-      ArrayMemberAccess: "SP206",
-      InvalidDeclaration: "SP207",
-      /** `reserved-name`: a variable named `__proto__`. */
-      ReservedVariableName: "SP208",
-      /** `unknown-passage`. */
-      BrokenPassageLink: "SP300",
-      WidgetArgCountMismatch: "SP301",
-      IncludeWidgetPassage: "SP302",
-      UnusedWidget: "SP303",
-      LinkRuntimeMismatch: "SP304",
-      LiteralLinkInterpolation: "SP305",
-      DeadEndPassage: "SP400",
-      UnreachablePassage: "SP401",
-      LineTooLong: "SP500"
-    };
-    severityMap = {
-      SP001: "warning",
-      SP100: "warning",
-      SP101: "error",
-      SP102: "error",
-      SP104: "error",
-      SP105: "error",
-      SP106: "error",
-      SP107: "error",
-      SP108: "error",
-      SP109: "error",
-      SP110: "warning",
-      SP111: "error",
-      SP113: "error",
-      SP114: "error",
-      SP115: "error",
-      SP200: "error",
-      SP201: "error",
-      SP202: "info",
-      SP203: "warning",
-      SP205: "warning",
-      SP206: "warning",
-      SP207: "error",
-      SP208: "error",
-      SP300: "warning",
-      SP301: "warning",
-      SP302: "warning",
-      SP303: "hint",
-      SP304: "warning",
-      SP305: "warning",
-      SP400: "hint",
-      SP401: "hint",
-      SP500: "warning"
+      unwatch: {
+        name: "unwatch",
+        description: "Stops watching a variable.\n\nUsage: `{unwatch $var}`",
+        parameters: ["...text"],
+        parameterDocs: [
+          { name: "variable", documentation: "Variable to stop watching." }
+        ]
+      },
+      unless: {
+        name: "unless",
+        container: true,
+        description: "Conditionally displays its contents when the expression is falsy. The inverse of `{if}`.\n\nUsage:\n\n```\n{unless condition}\n  ...\n{/unless}\n```",
+        parameters: ["...text"],
+        parameterDocs: [
+          { name: "condition", documentation: "Expression; the contents show when it is falsy." }
+        ]
+      }
     };
   }
 });
 
-// src/core/markup/source-view.ts
-function viewIndex(view, offset2) {
-  if (!view.sourceOffsets) return offset2 - view.offset;
-  let low = 0;
-  let high = view.sourceOffsets.length - 1;
-  while (low < high) {
-    const mid = Math.ceil((low + high) / 2);
-    if (view.sourceOffsets[mid] <= offset2) low = mid;
-    else high = mid - 1;
-  }
-  return low;
-}
-function textAt(passage, start, end) {
-  return passage.pieces.filter((piece) => piece.kind === "text" && piece.offset <= start && pieceOffset(piece, piece.text.length) >= end).at(-1);
-}
-function sourceView(passage, start, end) {
-  const owner = passage.pieces.filter((piece) => {
-    const value = piece.kind === "text" ? piece.text : piece.kind === "code" ? piece.code : void 0;
-    return value !== void 0 && piece.offset <= start && pieceOffset(piece, value.length) >= end;
-  }).at(-1);
-  if (owner?.kind === "code") return { ...owner, text: owner.code };
-  return owner?.kind === "text" ? owner : { offset: 0, text: passage.content };
-}
-var init_source_view = __esm({
-  "src/core/markup/source-view.ts"() {
-    "use strict";
-    init_tooling();
-  }
-});
-
-// src/core/parsing/argument-lexer.ts
-function lexArguments(source) {
-  let from = 0;
-  return splitArgs(source).map((text3) => {
-    const start = source.indexOf(text3, from);
-    from = start + text3.length;
-    return classifyArgument(text3, start);
-  });
-}
-function classifyArgument(text3, start = 0) {
-  const base = { text: text3, start, end: start + text3.length };
-  if (readQuoted(text3, 0)?.end === text3.length) return { ...base, type: 0 /* String */ };
-  if (text3 === "null") return { ...base, type: 3 /* Null */ };
-  if (text3 === "undefined") return { ...base, type: 10 /* Undefined */ };
-  if (text3 === "true" || text3 === "false") return { ...base, type: 2 /* Boolean */ };
-  if (text3 === "NaN") return { ...base, type: 9 /* NaN */ };
-  if (text3 !== "" && !Number.isNaN(Number(text3))) return { ...base, type: 1 /* Number */ };
-  if (/^[$_@%]\w+(?:\.\w+)*$/.test(text3)) {
-    return { ...base, type: 4 /* Variable */, sigil: text3[0], path: text3.slice(1).split(".") };
-  }
-  if (text3.startsWith("[[") && text3.endsWith("]]")) return { ...base, type: 5 /* Link */ };
-  if (/^\[[<>]?img\[/i.test(text3) && text3.endsWith("]]")) return { ...base, type: 6 /* Image */ };
-  return { ...base, type: /^[-\w]+$/.test(text3) ? 8 /* Bareword */ : 7 /* Expression */ };
+// src/core/workspace/workspace-model.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+function storyInitMacros(content2) {
+  return passagePieces(content2, builtinMacros).flatMap((piece) => piece.kind === "code" && piece.goal === "statements" ? discoverMacros(piece.code) : []);
 }
-var init_argument_lexer = __esm({
-  "src/core/parsing/argument-lexer.ts"() {
+var WorkspaceModel;
+var init_workspace_model = __esm({
+  "src/core/workspace/workspace-model.ts"() {
     "use strict";
     init_tooling();
-  }
-});
-
-// src/core/parsing/parameter-validator.ts
-function isAlwaysArg(arg) {
-  return arg.type === 4 /* Variable */ || arg.type === 7 /* Expression */;
-}
-function findParameterType(name) {
-  for (const pt2 of parameterTypes) {
-    if (pt2.name.includes(name)) return pt2;
-  }
-  return null;
-}
-function lexFormat(formatString) {
-  let pos = 0;
-  const lexed = [];
-  let iter = 0;
-  for (; ; ) {
-    if (++iter > LEX_LIMIT) throw new Error("Format lex iteration limit exceeded");
-    if (pos >= formatString.length) break;
-    const ch = formatString[pos];
-    if (wsRe.test(ch)) {
-      pos++;
-    } else if (ch === "&") {
-      pos++;
-      const next = formatString[pos];
-      if (next === "+") {
-        pos++;
-        lexed.push({ kind: 3 /* AndNext */ });
-      } else {
-        throw new Error(`Lex: Expected '+' after '&', found '${next ?? "EOF"}'`);
-      }
-    } else if (ch === "|") {
-      pos++;
-      const next = formatString[pos];
-      if (next === "+") {
-        pos++;
-        lexed.push({ kind: 4 /* MaybeNext */ });
-      } else if (next === void 0) {
-        throw new Error("Lex: Expected content after '|'");
-      } else if (wsRe.test(next)) {
-        pos++;
-        lexed.push({ kind: 5 /* Or */ });
-      } else if (identStartRe.test(next) || quoteRe.test(next)) {
-        lexed.push({ kind: 5 /* Or */ });
-      } else {
-        throw new Error(`Lex: Invalid character after '|': '${next}'`);
+    init_document_store();
+    init_passage_index();
+    init_macro_registry2();
+    init_variable_tracker();
+    init_widget_registry();
+    init_markup_index();
+    init_macro_sources();
+    init_story_format();
+    init_spindle_version();
+    init_macro_supplements();
+    WorkspaceModel = class extends EventEmitter2 {
+      documents;
+      passages;
+      _macros;
+      get macros() {
+        this.ensureCurrent();
+        return this._macros;
       }
-    } else if (quoteRe.test(ch)) {
-      const quoted = readQuoted(formatString, pos);
-      if (!quoted) throw new Error("Lex: Unterminated string literal");
-      pos = quoted.end;
-      lexed.push({ kind: 1 /* Literal */, value: quoted.value });
-    } else if (ch === "(" || ch === ")") {
-      pos++;
-      lexed.push({ kind: 2 /* Group */, open: ch === "(" });
-    } else if (identStartRe.test(ch)) {
-      const start = pos;
-      pos++;
-      while (pos < formatString.length) {
-        if (++iter > LEX_LIMIT) throw new Error("Format lex identifier iteration limit exceeded");
-        const c = formatString[pos];
-        if (identStopRe.test(c) || c === void 0) break;
-        if (identStartRe.test(c)) {
-          pos++;
-        } else if (digitRe.test(c)) {
-          throw new Error(`Lex: Digit '${c}' not allowed in parameter type name`);
-        } else {
-          throw new Error(`Lex: Invalid character '${c}' in parameter type name`);
-        }
+      _variables;
+      get variables() {
+        this.ensureCurrent();
+        return this._variables;
       }
-      const ident = formatString.slice(start, pos);
-      const pt2 = findParameterType(ident);
-      if (pt2 === null) throw new Error(`Lex: Unknown parameter type '${ident}'`);
-      lexed.push({ kind: 0 /* Type */, type: pt2 });
-    } else if (ch === "." && formatString[pos + 1] === "." && formatString[pos + 2] === ".") {
-      pos += 3;
-      lexed.push({ kind: 6 /* Repeat */ });
-    } else {
-      throw new Error(`Lex: Unexpected character '${ch}'`);
-    }
-  }
-  return lexed;
-}
-function parseFormat(formatString) {
-  const tokens2 = lexFormat(formatString);
-  if (tokens2.length === 0) return null;
-  let index = 0;
-  let iter = 0;
-  function infixBp(kind) {
-    switch (kind) {
-      case 5 /* Or */:
-        return [9, 10];
-      case 3 /* AndNext */:
-        return [4, 5];
-      case 4 /* MaybeNext */:
-        return [2, 3];
-      default:
-        return null;
-    }
-  }
-  function prefixBp(kind) {
-    switch (kind) {
-      case 4 /* MaybeNext */:
-        return 3;
-      case 6 /* Repeat */:
-        return 8;
-      default:
-        throw new Error(`Parse: Unexpected prefix operator kind ${kind}`);
-    }
-  }
-  function isPrefixOp(t) {
-    return t.kind === 4 /* MaybeNext */ || t.kind === 6 /* Repeat */;
-  }
-  function isValue(t) {
-    return t.kind === 0 /* Type */ || t.kind === 1 /* Literal */;
-  }
-  function exprBp(minBp) {
-    if (++iter > PARSE_LIMIT) throw new Error("Format parse iteration limit exceeded");
-    const cur = tokens2[index];
-    if (!cur) throw new Error("Parse: Unexpected end of format string");
-    index++;
-    let lhs;
-    if (isPrefixOp(cur)) {
-      const rBp = prefixBp(cur.kind);
-      const rhs = exprBp(rBp);
-      lhs = { kind: cur.kind, right: rhs };
-    } else if (cur.kind === 2 /* Group */) {
-      const g = cur;
-      if (!g.open) throw new Error("Parse: Unexpected closing parenthesis");
-      lhs = exprBp(0);
-      const closing = tokens2[index];
-      if (!closing || closing.kind !== 2 /* Group */ || closing.open) {
-        throw new Error("Parse: Expected closing parenthesis");
+      _widgets;
+      get widgets() {
+        this.ensureCurrent();
+        return this._widgets;
       }
-      index++;
-    } else if (isValue(cur)) {
-      lhs = cur;
-    } else {
-      throw new Error("Parse: Expected value or prefix operator");
-    }
-    for (; ; ) {
-      if (++iter > PARSE_LIMIT) throw new Error("Format parse operator iteration limit exceeded");
-      const op = tokens2[index];
-      if (!op) break;
-      const bp = infixBp(op.kind);
-      if (bp === null) break;
-      const [lBp, rBp] = bp;
-      if (lBp < minBp) break;
-      index++;
-      const rhs = exprBp(rBp);
-      lhs = { kind: op.kind, left: lhs, right: rhs };
-    }
-    return lhs;
-  }
-  return exprBp(0);
-}
-function slotAccepts(leaf) {
-  return (arg) => crawlValidate(leaf, [arg], 0).status === 2 /* Success */;
-}
-function describeFormat(format) {
-  const cap = (list3) => list3.slice(0, DESCRIBE_ALTERNATIVE_LIMIT);
-  const join5 = (lefts, rights) => cap(lefts.flatMap((l) => rights.map((r) => [...l, ...r])));
-  switch (format.kind) {
-    case 0 /* Type */:
-      return [[{ label: format.type.name[0], optional: false, repeat: false, accepts: slotAccepts(format) }]];
-    case 1 /* Literal */:
-      return [[{ label: `'${format.value}'`, optional: false, repeat: false, accepts: slotAccepts(format) }]];
-    case 3 /* AndNext */:
-      return join5(describeFormat(format.left), describeFormat(format.right));
-    case 4 /* MaybeNext */: {
-      const rights = describeFormat(format.right).map(
-        (seq) => seq.map((slot) => ({ ...slot, optional: true }))
-      );
-      return join5(format.left ? describeFormat(format.left) : [[]], rights);
-    }
-    case 5 /* Or */:
-      return cap([...describeFormat(format.left), ...describeFormat(format.right)]);
-    case 6 /* Repeat */:
-      return describeFormat(format.right).map(
-        (seq) => seq.map((slot) => ({ ...slot, optional: true, repeat: true }))
-      );
-  }
-}
-function makeError(status, message, argIndex, rank = 0) {
-  return {
-    status,
-    rank,
-    argIndex,
-    errors: [{ message, argIndex }],
-    warnings: []
-  };
-}
-function makeSuccess(argIndex, rank, warnings = []) {
-  return { status: 2 /* Success */, rank, argIndex, errors: [], warnings };
-}
-function isFail(s) {
-  return s === 1 /* Failure */ || s === 0 /* NotFound */;
-}
-function crawlValidate(format, args2, startIndex, state) {
-  const memo2 = /* @__PURE__ */ new Map();
-  function append(left, right) {
-    return { ...right, rank: left.rank + right.rank, warnings: left.warnings.concat(right.warnings) };
-  }
-  function follow(left, right) {
-    return left.flatMap((matched) => isFail(matched.status) ? [matched] : crawl(right, matched.argIndex).map((result2) => append(matched, result2)));
-  }
-  function crawl(fmt, argIdx) {
-    let positions = memo2.get(fmt);
-    if (!positions) memo2.set(fmt, positions = /* @__PURE__ */ new Map());
-    const cached2 = positions.get(argIdx);
-    if (cached2) return cached2;
-    if (positions.size >= VALIDATE_LIMIT) {
-      throw new Error(`Validation iteration limit exceeded at argument ${argIdx}`);
-    }
-    const unique = /* @__PURE__ */ new Map();
-    for (const result2 of match2(fmt, argIdx)) {
-      const key = isFail(result2.status) ? "failure" : result2.argIndex;
-      const previous2 = unique.get(key);
-      if (!previous2 || key === "failure" && result2.rank > previous2.rank) unique.set(key, result2);
-    }
-    const results2 = [...unique.values()];
-    positions.set(argIdx, results2);
-    return results2;
-  }
-  function match2(fmt, argIdx) {
-    switch (fmt.kind) {
-      case 4 /* MaybeNext */: {
-        const left = fmt.left ? crawl(fmt.left, argIdx) : [makeSuccess(argIdx, 0)];
-        return [...follow(left, fmt.right), ...left];
+      /** Every document's markup, read through Spindle's tooling API. */
+      _markup;
+      get markup() {
+        this.ensureCurrent();
+        return this._markup;
       }
-      case 3 /* AndNext */: {
-        return follow(crawl(fmt.left, argIdx), fmt.right);
+      /** True after initialize() has completed (full workspace scan done). */
+      initialized = false;
+      /** The story format declared by StoryData, updated with the passages. */
+      format = UNDECLARED_STORY_FORMAT;
+      /**
+       * The Spindle the project targets: the version installed under the
+       * workspace root, else StoryData's `format-version`. Only a version below
+       * {@link MINIMUM_SPINDLE_VERSION} matters (it is reported, not emulated).
+       */
+      _target;
+      get target() {
+        this.ensureCurrent();
+        return this._target;
       }
-      case 5 /* Or */: {
-        return [...crawl(fmt.left, argIdx), ...crawl(fmt.right, argIdx)];
+      workspaceRoot;
+      /** The version installed under the workspace root, read at startup and on refresh(). */
+      installedVersion;
+      /** The `format-version` StoryData declares. */
+      declaredVersion;
+      analysisPending = false;
+      debounceTimer = null;
+      DEBOUNCE_MS = 200;
+      /** Bound listeners for cleanup in dispose(). */
+      onDocumentChanged;
+      onDocumentOpened;
+      onDocumentClosed;
+      constructor(config2) {
+        super();
+        this.documents = new DocumentStore();
+        this.passages = new PassageIndex();
+        this._macros = new MacroRegistry();
+        this.macros.onChange = () => this.markup?.invalidate();
+        this._variables = new VariableTracker();
+        this._widgets = new WidgetRegistry();
+        this._markup = new MarkupIndex({
+          text: (uri) => this.documents.getText(uri),
+          passages: (uri) => this.passages.getPassagesInDocument(uri),
+          context: () => ({
+            macros: this.toolingMacros(),
+            isBlock: (name) => this.isContainer(name)
+          })
+        });
+        this.workspaceRoot = config2?.workspaceRoot;
+        this.installedVersion = this.workspaceRoot ? readInstalledSpindleVersion(this.workspaceRoot) : void 0;
+        this._target = resolveSpindleTarget(this.installedVersion);
+        this.macros.loadBuiltins();
+        this.macros.loadSupplements(macro_supplements_default);
+        this.onDocumentChanged = (uri) => this.handleDocumentChange(uri);
+        this.onDocumentOpened = (uri) => this.handleDocumentChange(uri);
+        this.onDocumentClosed = (uri) => this.handleDocumentClose(uri);
+        this.documents.on("documentChanged", this.onDocumentChanged);
+        this.documents.on("documentOpened", this.onDocumentOpened);
+        this.documents.on("documentClosed", this.onDocumentClosed);
       }
-      case 6 /* Repeat */: {
-        const matches = [];
-        const pending = [makeSuccess(argIdx, 0)];
-        const reached = /* @__PURE__ */ new Set();
-        while (pending.length > 0) {
-          const matched = pending.pop();
-          if (reached.has(matched.argIndex)) continue;
-          reached.add(matched.argIndex);
-          matches.push(matched);
-          const items = crawl(fmt.right, matched.argIndex);
-          for (let i2 = items.length - 1; i2 >= 0; i2--) {
-            const item = items[i2];
-            if (!isFail(item.status) && !reached.has(item.argIndex)) pending.push(append(matched, item));
-          }
+      /**
+       * Initialize the workspace in CLI/batch mode.
+       * Loads all file contents, builds indices, and emits 'modelReady'.
+       */
+      initialize(fileContents) {
+        this.documents.removeListener("documentOpened", this.onDocumentOpened);
+        this.documents.removeListener("documentChanged", this.onDocumentChanged);
+        for (const [uri, text3] of fileContents) {
+          this.documents.open(uri, text3);
         }
-        return matches.sort((left, right) => right.argIndex - left.argIndex);
+        this.documents.on("documentOpened", this.onDocumentOpened);
+        this.documents.on("documentChanged", this.onDocumentChanged);
+        this.rebuildAll();
+        this.initialized = true;
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = null;
+        this.emit("modelReady");
       }
-      case 1 /* Literal */: {
-        const arg = args2[argIdx];
-        if (arg === void 0) {
-          return [makeError(0 /* NotFound */, `Expected literal '${fmt.value}' but no argument found`, argIdx)];
-        }
-        if (isAlwaysArg(arg)) {
-          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
-        }
-        const argText = arg.type === 0 /* String */ ? readQuoted(arg.text, 0)?.value : arg.text;
-        if (argText === fmt.value) {
-          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
-        }
-        if (fmt.value === "null" && arg.type === 3 /* Null */ || fmt.value === "undefined" && arg.type === 10 /* Undefined */ || fmt.value === "true" && arg.type === 2 /* Boolean */ && arg.text === "true" || fmt.value === "false" && arg.type === 2 /* Boolean */ && arg.text === "false" || fmt.value === "NaN" && arg.type === 9 /* NaN */) {
-          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
-        }
-        return [makeError(1 /* Failure */, `Expected literal '${fmt.value}'`, argIdx, CORRECT_TYPE_RANK)];
+      /**
+       * Re-run cross-document analysis and schedule 'modelReady', e.g. after
+       * the macro configuration changed without any document changing.
+       */
+      refresh() {
+        if (this.workspaceRoot) this.installedVersion = readInstalledSpindleVersion(this.workspaceRoot);
+        this.analysisPending = true;
+        this.ensureCurrent();
+        this.scheduleModelReady();
       }
-      case 0 /* Type */: {
-        const arg = args2[argIdx];
-        const typeDef = fmt.type;
-        if (arg === void 0) {
-          return [makeError(
-            0 /* NotFound */,
-            `Expected type '${typeDef.name[0]}' but no argument found`,
-            argIdx
-          )];
-        }
-        if (isAlwaysArg(arg)) {
-          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
-        }
-        const result2 = typeDef.validate(arg, args2, argIdx, state);
-        if (result2 instanceof TypeError2) {
-          return [{
-            status: 1 /* Failure */,
-            rank: 0,
-            argIndex: argIdx,
-            errors: [{ message: result2.message, argIndex: argIdx }],
-            warnings: []
-          }];
-        }
-        if (result2 instanceof TypeWarning) {
-          return [makeSuccess(argIdx + 1, CORRECT_RANK, [
-            { message: result2.message, argIndex: argIdx }
-          ])];
-        }
-        return [makeSuccess(argIdx + 1, CORRECT_RANK)];
+      /**
+       * Whether `{name}` opens a container that needs a `{/name}` closing tag:
+       * a block macro, or a block widget (one whose body renders `{@children}`).
+       * Like Spindle's set of block macros, either source makes a name a block.
+       */
+      isContainer(name) {
+        return this.macros.isBlock(name) || (this.widgets.getWidget(name)?.block ?? false);
       }
-    }
-  }
-  const results = crawl(format, startIndex);
-  return results.find((result2) => !isFail(result2.status) && result2.argIndex === args2.length) ?? results.reduce((best, result2) => result2.rank > best.rank ? result2 : best);
-}
-var TypeError2, TypeWarning, parameterTypes, LEX_LIMIT, wsRe, identStartRe, identStopRe, quoteRe, digitRe, PARSE_LIMIT, DESCRIBE_ALTERNATIVE_LIMIT, VALIDATE_LIMIT, CORRECT_TYPE_RANK, CORRECT_RANK, Parameters;
-var init_parameter_validator = __esm({
-  "src/core/parsing/parameter-validator.ts"() {
-    "use strict";
-    init_tooling();
-    init_argument_lexer();
-    TypeError2 = class {
-      constructor(message) {
-        this.message = message;
+      /**
+       * Whether document `uri` declares any passage. A Twee document with no
+       * `::` header holds no passage (the compiler ignores text outside one), so
+       * there is no markup in it for any consumer to read.
+       */
+      hasPassages(uri) {
+        return this.passages.getPassagesInDocument(uri).length > 0;
+      }
+      /**
+       * The story format named by the project's StoryData passage (trimmed), or
+       * undefined if no StoryData passage names one.
+       */
+      get storyFormat() {
+        this.ensureCurrent();
+        return this.format.name;
       }
-      message;
-    };
-    TypeWarning = class {
-      constructor(message) {
-        this.message = message;
+      /**
+       * Whether Spindle semantics apply to this project. False only if a
+       * StoryData passage names another story format (SugarCube, Harlowe, ...)
+       * and none names Spindle; a missing or unreadable StoryData counts as
+       * Spindle.
+       */
+      isSpindleProject() {
+        this.ensureCurrent();
+        return this.format.isSpindle;
       }
-      message;
-    };
-    parameterTypes = [
-      {
-        name: ["bool", "boolean"],
-        validate(arg) {
-          return arg.type === 2 /* Boolean */ ? null : new TypeError2("Argument is not a boolean");
-        }
-      },
-      {
-        name: ["null"],
-        validate(arg) {
-          return arg.type === 3 /* Null */ ? null : new TypeError2("Argument is not 'null'");
-        }
-      },
-      {
-        name: ["undefined"],
-        validate(arg) {
-          return arg.type === 10 /* Undefined */ ? null : new TypeError2("Argument is not 'undefined'");
-        }
-      },
-      {
-        name: ["number"],
-        validate(arg) {
-          return arg.type === 1 /* Number */ ? null : new TypeError2("Argument is not a number");
-        }
-      },
-      {
-        name: ["NaN"],
-        validate(arg) {
-          return arg.type === 9 /* NaN */ ? null : new TypeError2("Argument is not 'NaN'");
-        }
-      },
-      {
-        name: ["link"],
-        validate(arg) {
-          return arg.type === 5 /* Link */ ? null : new TypeError2("Argument is not a link");
-        }
-      },
-      {
-        name: ["image"],
-        validate(arg) {
-          return arg.type === 6 /* Image */ ? null : new TypeError2("Argument is not an image");
-        }
-      },
-      {
-        name: ["bareword"],
-        validate(arg) {
-          return arg.type === 8 /* Bareword */ ? null : new TypeError2("Argument is not a bareword");
-        }
-      },
-      {
-        name: ["string"],
-        validate(arg) {
-          return arg.type === 0 /* String */ ? null : new TypeError2("Argument is not a quoted string");
-        }
-      },
-      {
-        name: ["text"],
-        validate(arg) {
-          const t = arg.type;
-          if (t === 8 /* Bareword */ || t === 0 /* String */ || t === 2 /* Boolean */ || t === 3 /* Null */ || t === 9 /* NaN */ || t === 1 /* Number */) {
-            return null;
-          }
-          return new TypeError2("Argument is not text");
-        }
-      },
-      {
-        name: ["var"],
-        validate(arg) {
-          return arg.type === 4 /* Variable */ ? null : new TypeError2("Argument is not a variable");
+      /** Clean up listeners and timers. */
+      dispose() {
+        this.documents.removeListener("documentChanged", this.onDocumentChanged);
+        this.documents.removeListener("documentOpened", this.onDocumentOpened);
+        this.documents.removeListener("documentClosed", this.onDocumentClosed);
+        if (this.debounceTimer) {
+          clearTimeout(this.debounceTimer);
+          this.debounceTimer = null;
         }
-      },
-      {
-        // The story variable a form control binds to: `$name` or `"$name"`.
-        // Spindle strips the quotes and the `$` sigil from the first argument
-        // and reads the rest as a dot path into the story variables.
-        name: ["receiver"],
-        validate(arg) {
-          let name;
-          if (arg.type === 0 /* String */) {
-            name = arg.text.slice(1, -1);
-          } else if (arg.type === 8 /* Bareword */) {
-            name = arg.text;
-          }
-          if (name === void 0) {
-            return new TypeError2("Argument is not a variable receiver");
-          }
-          if (/^[_@%]/.test(name)) {
-            return new TypeError2(`Variable receiver must be a story variable ($name), got '${name}'`);
-          }
-          if (!/^(?:\$\w|[A-Za-z_])[\w$]*(?:\.[\w$]+)*$/.test(name)) {
-            return new TypeError2(`Argument is not a valid variable receiver: '${name}'`);
-          }
-          return null;
+        this.removeAllListeners();
+      }
+      /** Index local headers immediately; defer expensive cross-document analysis. */
+      handleDocumentChange(uri) {
+        const text3 = this.documents.getText(uri);
+        if (text3 !== void 0 && !isMacroSource(uri)) {
+          this.passages.rebuild(uri, text3);
         }
-      },
-      {
-        name: ["passage"],
-        validate(arg, _args, _index, state) {
-          let passageName;
-          if (arg.type === 0 /* String */) {
-            const target = passageTarget(arg.text);
-            if (target.kind === "name") passageName = target.name;
-          } else if (arg.type === 8 /* Bareword */) {
-            passageName = arg.text;
-          } else if (arg.type === 1 /* Number */) {
-            passageName = arg.text;
-          } else if (arg.type === 9 /* NaN */) {
-            passageName = "NaN";
-          }
-          if (passageName !== void 0) {
-            if (state && state.passages.length > 0) {
-              if (!state.passages.includes(passageName)) {
-                return new TypeWarning(`Nonexistent passage: "${passageName}"`);
-              }
-            }
-            return null;
+        this.analysisPending = true;
+        this.updateStoryFormat();
+        this.emit("documentChanged", uri);
+        this.emit("passagesUpdated", uri);
+        this.scheduleModelReady();
+      }
+      /** Remove local indices immediately and schedule cross-document analysis. */
+      handleDocumentClose(uri) {
+        this.passages.remove(uri);
+        this._variables.removeDocument(uri);
+        this.analysisPending = true;
+        this.updateStoryFormat();
+        this.emit("documentClosed", uri);
+        this.emit("passagesUpdated", uri);
+        this.scheduleModelReady();
+      }
+      /** Rebuild all indices from scratch. */
+      rebuildAll() {
+        for (const uri of this.documents.getUris()) {
+          const text3 = this.documents.getText(uri);
+          if (text3 !== void 0 && !isMacroSource(uri)) {
+            this.passages.rebuild(uri, text3);
           }
-          return new TypeError2("Argument is not an acceptable passage");
         }
+        this.analysisPending = true;
+        this.ensureCurrent();
       }
-    ];
-    LEX_LIMIT = 1e3;
-    wsRe = /\s/;
-    identStartRe = /[a-zA-Z]/;
-    identStopRe = /[|&+\-\s)(]/;
-    quoteRe = /['"]/;
-    digitRe = /[0-9]/;
-    PARSE_LIMIT = 2e3;
-    DESCRIBE_ALTERNATIVE_LIMIT = 16;
-    VALIDATE_LIMIT = 2e3;
-    CORRECT_TYPE_RANK = 1;
-    CORRECT_RANK = 2;
-    Parameters = class {
-      variants;
-      constructor(variants) {
-        this.variants = variants.map((s) => ({
-          formatString: s,
-          format: parseFormat(s)
-        }));
+      /** Finish pending cross-document work once, before a feature reads the indices. */
+      ensureCurrent() {
+        if (!this.analysisPending) return;
+        this.analysisPending = false;
+        this.refreshDiscoveredMacros();
+        this.cascade();
+        this.updateStoryFormat();
       }
       /**
-       * Describe every argument position of every schema variant. Alternatives
-       * (`|`) and optional positions (`|+`) become separate sequences; an empty
-       * schema is the empty sequence. Variants whose format cannot be parsed
-       * contribute nothing.
+       * Re-read the story format from the StoryData passages after the passage
+       * index changed, emitting 'storyFormatChanged' if it differs. Listeners
+       * that read the analysis indices finish pending analysis through getters.
        */
-      describe() {
-        const sequences = [];
-        for (const variant of this.variants) {
-          if (variant.format === null) sequences.push([]);
-          else sequences.push(...describeFormat(variant.format));
-        }
-        return sequences;
+      updateStoryFormat() {
+        const format = resolveStoryFormat(storyDataFormats(
+          this.passages.getAllPassages(),
+          (uri) => this.documents.getText(uri)
+        ));
+        if (format.name === this.format.name && format.isSpindle === this.format.isSpindle) return;
+        this.format = format;
+        this.emit("storyFormatChanged", format);
       }
       /**
-       * Validate an array of Arg tokens against these parameter variants.
-       * Selects the best-matching variant by rank.
+       * Re-run static macro discovery over the workspace and replace the
+       * registry's discovered tier (dropping definitions whose source is gone).
+       *
+       * Sources scanned for Story.defineMacro({...}) calls:
+       *  - `{do}` blocks in StoryInit passages
+       *  - passages tagged `script` (Story JavaScript)
+       *  - JavaScript/TypeScript documents in the workspace
        */
-      validate(args2, stateInfo) {
-        if (this.variants.length === 0) {
-          if (args2.length === 0) {
-            return { variantIndex: null, errors: [], warnings: [] };
-          }
-          return {
-            variantIndex: null,
-            errors: [{ message: "Expected no arguments", argIndex: 0 }],
-            warnings: []
-          };
-        }
-        let bestIndex = null;
-        let bestRank = -Infinity;
-        let bestErrors = [];
-        let bestWarnings = [];
-        let bestIsClean = false;
-        for (let i2 = 0; i2 < this.variants.length; i2++) {
-          const variant = this.variants[i2];
-          if (variant.format === null) {
-            if (args2.length === 0) {
-              if (!bestIsClean || 0 > bestRank) {
-                bestIndex = i2;
-                bestRank = 0;
-                bestErrors = [];
-                bestWarnings = [];
-                bestIsClean = true;
-              }
-            } else {
-              if (!bestIsClean && bestIndex === null) {
-                bestIndex = i2;
-                bestRank = -1;
-                bestErrors = [{ message: "Expected no arguments", argIndex: 0 }];
-                bestWarnings = [];
-              }
-            }
+      refreshDiscoveredMacros() {
+        const found = [];
+        const init = [];
+        for (const uri of this.documents.getUris().sort()) {
+          const text3 = this.documents.getText(uri);
+          if (!text3) continue;
+          if (isMacroSource(uri)) {
+            found.push(...discoverMacros(text3));
             continue;
           }
-          const result2 = crawlValidate(variant.format, args2, 0, stateInfo);
-          let errors = result2.errors;
-          if (result2.errors.length === 0 && result2.argIndex < args2.length) {
-            errors = [
-              {
-                message: `Too many arguments: expected ${result2.argIndex}, got ${args2.length}`,
-                argIndex: result2.argIndex
-              }
-            ];
-          }
-          const rank = result2.rank;
-          const isClean = errors.length === 0;
-          if (isClean && (!bestIsClean || rank > bestRank)) {
-            bestIndex = i2;
-            bestRank = rank;
-            bestErrors = [];
-            bestWarnings = result2.warnings;
-            bestIsClean = true;
-          } else if (!isClean && !bestIsClean && rank > bestRank) {
-            bestIndex = i2;
-            bestRank = rank;
-            bestErrors = errors;
-            bestWarnings = result2.warnings;
-          } else if (bestIndex === null) {
-            bestIndex = i2;
-            bestRank = rank;
-            bestErrors = errors;
-            bestWarnings = result2.warnings;
-            bestIsClean = isClean;
+          let lines;
+          for (const passage of this.passages.getPassagesInDocument(uri)) {
+            const isStoryInit = passage.name === "StoryInit";
+            const isScript = passage.tags?.includes("script") ?? false;
+            if (!isStoryInit && !isScript) continue;
+            lines ??= text3.split("\n");
+            const content2 = lines.slice(passage.headerEnd.end.line + 1, passage.range.end.line + 1).join("\n");
+            if (isScript) found.push(...discoverMacros(content2));
+            else init.push(...storyInitMacros(content2));
           }
         }
-        return {
-          variantIndex: bestIndex,
-          errors: bestErrors,
-          warnings: bestWarnings
-        };
+        this.macros.setDiscoveredMacros([...found, ...init]);
       }
       /**
-       * Whether all variants are empty (accept no arguments).
+       * Cascade: rescan variables and widgets based on current passages.
+       * Called after any passage index update.
+       *
+       * The markup of every document is read again (the macros may have changed),
+       * the widgets are defined from it, and then the variable usages and widget
+       * invocations are read from the same markup, which pairs its tags with the
+       * widgets just defined.
        */
-      isEmpty() {
-        if (this.variants.length === 0) return true;
-        return !this.variants.some((v2) => v2.format !== null);
+      cascade() {
+        this.markup.invalidate();
+        this.declaredVersion = storyDataFormatVersion(this.passages.getAllPassages(), (uri) => this.documents.getText(uri));
+        this._target = resolveSpindleTarget(this.installedVersion, this.declaredVersion);
+        const declarations = (name) => {
+          const passage = this.passages.getPassage(name);
+          return passage ? this.markup.get(passage.uri)?.passages.find((p) => p.passage === passage) : void 0;
+        };
+        const variables = declarations("StoryVariables");
+        if (variables) this.variables.parseStoryVariables(variables.content, variables.passage.headerEnd.end.line + 1, variables.doc.uri);
+        else this.variables.clearStoryVariables();
+        const transients = declarations("StoryTransients");
+        if (transients) this.variables.parseStoryTransients(transients.content, transients.passage.headerEnd.end.line + 1, transients.doc.uri);
+        else this.variables.clearStoryTransients();
+        const readDocuments = () => this.documents.getUris().flatMap((uri) => {
+          const markup = isMacroSource(uri) ? void 0 : this.markup.get(uri);
+          return markup ? [markup] : [];
+        });
+        const markups = /* @__PURE__ */ new Map();
+        for (const doc of readDocuments()) for (const passage of doc.passages) markups.set(passage.passage, passage);
+        this.widgets.scan(
+          this.passages.getAllPassages().flatMap((passage) => markups.get(passage) ?? []),
+          this.macros.toolingMacros()
+        );
+        this.markup.invalidate();
+        this.widgets.clearInvocations();
+        for (const doc of readDocuments()) {
+          this.variables.scanDocument(doc.uri, doc.text, doc);
+          this.widgets.recordInvocations(doc.uri, doc.passages);
+        }
+      }
+      /** All runtime metadata, with real macros taking precedence over widgets. */
+      toolingMacros() {
+        const macros = this.macros.toolingMacros();
+        return [...macros, ...this.widgets.getAllWidgets().filter((widget) => !this.macros.getMacro(widget.name)).map((widget) => ({ name: widget.name, block: widget.block, subMacros: [], widget: widget.tooling }))];
+      }
+      /** Coalesce analysis and diagnostics across a burst of document changes. */
+      scheduleModelReady() {
+        if (this.debounceTimer) {
+          clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+          this.debounceTimer = null;
+          this.ensureCurrent();
+          this.emit("modelReady");
+        }, this.DEBOUNCE_MS);
       }
     };
   }
 });
 
+// src/core/diagnostic-codes.ts
+function getSeverity(code) {
+  return severityMap[code];
+}
+var DiagnosticCode, severityMap;
+var init_diagnostic_codes = __esm({
+  "src/core/diagnostic-codes.ts"() {
+    "use strict";
+    DiagnosticCode = {
+      /** The Spindle the project targets is older than the oldest one supported. */
+      UnsupportedSpindleVersion: "SP001",
+      /** `unknown-macro`: a macro that is none of the built-in, configured or defined ones. */
+      UndefinedMacro: "SP100",
+      /** `unclosed-block`, `mismatched-closer`, `stray-closer` of a macro. */
+      MalformedContainer: "SP101",
+      /** Tags of an HTML element Spindle cannot read or pair. */
+      MalformedElement: "SP102",
+      /** A closing tag that closes no macro (`{/set}`), or is malformed (`{/}`, `{/if x}`). */
+      IllegalClosingTag: "SP104",
+      /** `unclosed-link`, `unclosed-expression`, `unclosed-macro`: a `[[`, `{$` or `{name` that is never ended. */
+      UnclosedMarkup: "SP105",
+      /** `code-syntax`: JavaScript that does not parse. */
+      CodeSyntaxError: "SP106",
+      /** `misplaced-branch` (`{else}` outside `{if}`), and a macro outside the parents it needs. */
+      InvalidChildren: "SP107",
+      /** A configured parameter schema rejects the arguments (macros Spindle declares nothing for). */
+      ExpectedNoArguments: "SP108",
+      /** `argument-error`: arguments that do not have their parameters' forms. */
+      ParameterTypeError: "SP109",
+      ParameterWarning: "SP110",
+      TooManyArguments: "SP111",
+      /** `unquoted-passage-name`: `{goto Kitchen}`, which throws a ReferenceError. */
+      UnquotedPassageName: "SP113",
+      ChildMaxExceeded: "SP114",
+      ChildMinNotMet: "SP115",
+      /** `undeclared-variable`. */
+      UndeclaredVariable: "SP200",
+      /** `primitive-field`: a field of a number, string or boolean. */
+      PrimitiveFieldAccess: "SP201",
+      NoStoryVariables: "SP202",
+      /** `undeclared-transient`. */
+      UndeclaredTransient: "SP203",
+      TemporaryAssignedInLoop: "SP205",
+      ArrayMemberAccess: "SP206",
+      InvalidDeclaration: "SP207",
+      /** `reserved-name`: a variable named `__proto__`. */
+      ReservedVariableName: "SP208",
+      /** `unknown-passage`. */
+      BrokenPassageLink: "SP300",
+      WidgetArgCountMismatch: "SP301",
+      IncludeWidgetPassage: "SP302",
+      UnusedWidget: "SP303",
+      LinkRuntimeMismatch: "SP304",
+      LiteralLinkInterpolation: "SP305",
+      DeadEndPassage: "SP400",
+      UnreachablePassage: "SP401",
+      LineTooLong: "SP500"
+    };
+    severityMap = {
+      SP001: "warning",
+      SP100: "warning",
+      SP101: "error",
+      SP102: "error",
+      SP104: "error",
+      SP105: "error",
+      SP106: "error",
+      SP107: "error",
+      SP108: "error",
+      SP109: "error",
+      SP110: "warning",
+      SP111: "error",
+      SP113: "error",
+      SP114: "error",
+      SP115: "error",
+      SP200: "error",
+      SP201: "error",
+      SP202: "info",
+      SP203: "warning",
+      SP205: "warning",
+      SP206: "warning",
+      SP207: "error",
+      SP208: "error",
+      SP300: "warning",
+      SP301: "warning",
+      SP302: "warning",
+      SP303: "hint",
+      SP304: "warning",
+      SP305: "warning",
+      SP400: "hint",
+      SP401: "hint",
+      SP500: "warning"
+    };
+  }
+});
+
+// src/core/markup/source-view.ts
+function viewIndex(view, offset2) {
+  if (!view.sourceOffsets) return offset2 - view.offset;
+  let low = 0;
+  let high = view.sourceOffsets.length - 1;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (view.sourceOffsets[mid] <= offset2) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+function textAt(passage, start, end) {
+  return passage.pieces.filter((piece) => piece.kind === "text" && piece.offset <= start && pieceOffset(piece, piece.text.length) >= end).at(-1);
+}
+function sourceView(passage, start, end) {
+  const owner = passage.pieces.filter((piece) => {
+    const value = piece.kind === "text" ? piece.text : piece.kind === "code" ? piece.code : void 0;
+    return value !== void 0 && piece.offset <= start && pieceOffset(piece, value.length) >= end;
+  }).at(-1);
+  if (owner?.kind === "code") return { ...owner, text: owner.code };
+  return owner?.kind === "text" ? owner : { offset: 0, text: passage.content };
+}
+var init_source_view = __esm({
+  "src/core/markup/source-view.ts"() {
+    "use strict";
+    init_tooling();
+  }
+});
+
 // src/core/parsing/link-runtime.ts
 function quoteArg2(value) {
   return `"${value.replace(/[\\"]/g, "\\$&")}"`;
@@ -34252,10 +34334,11 @@ function buildReport(documents, workspace) {
   const passages = [];
   for (const doc of documents) {
     for (const passage of doc.passages) {
-      if (!COMPILER_PASSAGES.has(passage.passage.name)) passages.push(passage);
+      if (isRuntimePassage(passage.passage)) passages.push(passage);
     }
   }
   const markup = /* @__PURE__ */ new Map();
+  const validationMacros = toolingMacros.map((macro) => workspace.macros.hasConfiguredParameters(macro.name) ? { ...macro, widget: void 0 } : macro);
   const found = validateStoryMarkup(
     passages.map((passage, index) => ({
       name: passage.passage.name,
@@ -34263,7 +34346,7 @@ function buildReport(documents, workspace) {
       tags: passage.passage.tags,
       metadata: { "data-source-file": String(index) }
     })),
-    toolingMacros,
+    validationMacros,
     // Every malformed tag and pairing error, and the checks of the markup around them
     { tolerant: true }
   );
@@ -34607,7 +34690,7 @@ function isReadInBody(passage, bodyStart, bodyEnd, name, macroStart, macroEnd) {
 }
 function argumentDiagnostics(passage, workspace) {
   const diagnostics = [];
-  const passageNames = Array.from(workspace.passages.getAllPassages(), (candidate) => candidate.name);
+  const passageNames = workspace.passages.getAllPassages().filter(isRuntimePassage).map((candidate) => candidate.name);
   for (const token of passage.isMarkup ? macroTokens(passage) : []) {
     if (token.type !== "macro" || token.isClose) continue;
     const info = workspace.macros.getMacro(token.name);
@@ -35135,12 +35218,12 @@ async function runCheck(args2) {
     return 0;
   }
   const workspace = new WorkspaceModel({ workspaceRoot: commonDir });
-  const workspaceContents = new Map(fileContents);
-  await addProjectMacroSources(workspaceContents, commonDir);
-  workspace.initialize(workspaceContents);
   if (Object.keys(projectConfig.macros).length > 0) {
     workspace.macros.loadConfig(projectConfig.macros);
   }
+  const workspaceContents = new Map(fileContents);
+  await addProjectMacroSources(workspaceContents, commonDir);
+  workspace.initialize(workspaceContents);
   const diagOptions = {};
   if (options.maxLineLength !== null) {
     diagOptions.maxLineLength = options.maxLineLength;
@@ -69102,12 +69185,12 @@ async function createWorkspace(files, fileContents) {
   const configRoot = findConfigRoot(commonDir);
   const projectConfig = loadConfigFromDisk(configRoot);
   const workspace = new WorkspaceModel({ workspaceRoot: configRoot });
-  fileContents = new Map(fileContents);
-  await addProjectMacroSources(fileContents, commonDir);
-  workspace.initialize(fileContents);
   if (Object.keys(projectConfig.macros).length > 0) {
     workspace.macros.loadConfig(projectConfig.macros);
   }
+  fileContents = new Map(fileContents);
+  await addProjectMacroSources(fileContents, commonDir);
+  workspace.initialize(fileContents);
   return workspace;
 }
 async function checkFiles(pattern, severity, cwd = process.cwd()) {
@@ -80456,6 +80539,15 @@ function computeRename(uri, position, newName, workspace) {
       if (workspace.passages.getPassage(newName)) {
         throw new RenameError(`Cannot rename to ${JSON.stringify(newName)}: a passage with that name already exists.`).at(uri, symbol2.range);
       }
+      for (const documentUri of workspace.documents.getUris()) {
+        const doc = workspace.markup.get(documentUri);
+        if (!doc) continue;
+        for (const head of documentMacroHeads(doc)) {
+          if (!head.closing && workspace.macros.hasUnsafeConfiguredPassages(head.name)) {
+            throw new RenameError(`Cannot rename: {${head.name}} has configured passage parameters whose positions are ambiguous, repeated or conflict with its runtime signature.`).at(documentUri, head.range);
+          }
+        }
+      }
       const refEdits = [];
       for (const { uri: refUri, ref: ref2 } of findPassageRefs(symbol2.name, workspace)) {
         try {