npm - @rohal12/spindle-lsp - Versions diffs - 0.1.0 - Mend

@rohal12/spindle-lsp 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/bin.js ADDED Viewed

@@ -0,0 +1,4663 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+// src/core/workspace/document-store.ts
+import { EventEmitter } from "node:events";
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+var DocumentStore;
+var init_document_store = __esm({
+  "src/core/workspace/document-store.ts"() {
+    "use strict";
+    DocumentStore = class extends EventEmitter {
+      docs = /* @__PURE__ */ new Map();
+      /** Open a document (or replace if already open). */
+      open(uri, text, version) {
+        this.docs.set(uri, { text, version: version ?? 0 });
+        this.emit("documentOpened", uri);
+      }
+      /** Update an already-open document's text. */
+      update(uri, text, version) {
+        const existing = this.docs.get(uri);
+        const newVersion = version ?? (existing ? existing.version + 1 : 0);
+        this.docs.set(uri, { text, version: newVersion });
+        this.emit("documentChanged", uri);
+      }
+      /** Close a document and remove it from the store. */
+      close(uri) {
+        this.docs.delete(uri);
+        this.emit("documentClosed", uri);
+      }
+      /** Get the text of a document, or undefined if not open. */
+      getText(uri) {
+        return this.docs.get(uri)?.text;
+      }
+      /** Get the version of a document (0 if unknown). */
+      getVersion(uri) {
+        return this.docs.get(uri)?.version ?? 0;
+      }
+      /** Get all open document URIs. */
+      getUris() {
+        return Array.from(this.docs.keys());
+      }
+      /** Check whether a document is currently open. */
+      has(uri) {
+        return this.docs.has(uri);
+      }
+      /** Load files from disk (CLI mode). Converts paths to file:// URIs. */
+      loadFromDisk(paths) {
+        for (const filePath of paths) {
+          try {
+            const text = readFileSync(filePath, "utf-8");
+            const uri = pathToFileURL(filePath).href;
+            this.open(uri, text);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+// src/core/parsing/passage-parser.ts
+function parsePassageHeader(line, lineNumber) {
+  const escaped = line.replace(/\\./g, "ec");
+  const match = passageHeaderRegex.exec(escaped);
+  if (!match) return null;
+  const prefix = match[1] ?? "";
+  const rawName = match[2] ?? "";
+  const rawTags = match[3] ?? "";
+  const rawMeta = match[4] ?? "";
+  const nameStart = prefix.length;
+  const nameEnd = nameStart + rawName.length;
+  const name = line.substring(nameStart, nameEnd).trim();
+  if (!name) return null;
+  const escapedName = name.replace(/\\./g, "ec");
+  if (/[\[\]\{\}]/.test(escapedName)) return null;
+  const tagsStr = rawTags.trim();
+  let tags = [];
+  if (tagsStr) {
+    const inner = tagsStr.substring(1, tagsStr.length - 1).trim();
+    if (/[\[\]\{\}]/.test(inner.replace(/\\./g, "ec"))) return null;
+    tags = inner ? inner.split(/\s+/) : [];
+  }
+  let meta;
+  const metaStr = rawMeta.trim();
+  if (metaStr) {
+    try {
+      meta = JSON.parse(line.substring(nameStart + rawName.length + rawTags.length, nameStart + rawName.length + rawTags.length + rawMeta.length).trim());
+    } catch {
+      return null;
+    }
+  }
+  const headerRange = {
+    start: { line: lineNumber, character: 0 },
+    end: { line: lineNumber, character: line.length }
+  };
+  const nameCharStart = prefix.length;
+  const nameCharEnd = nameCharStart + name.length;
+  const nameRange = {
+    start: { line: lineNumber, character: nameCharStart },
+    end: { line: lineNumber, character: nameCharEnd }
+  };
+  return {
+    name: name.replace(/\\(.)/g, "$1"),
+    // unescape
+    tags,
+    meta,
+    headerRange,
+    nameRange
+  };
+}
+var passageHeaderRegex;
+var init_passage_parser = __esm({
+  "src/core/parsing/passage-parser.ts"() {
+    "use strict";
+    passageHeaderRegex = /^(::\s+)(.*?)(\[.*?\]\s*)?(\{.*?\}\s*)?\r?$/;
+  }
+});
+// src/core/workspace/passage-index.ts
+var PassageIndex;
+var init_passage_index = __esm({
+  "src/core/workspace/passage-index.ts"() {
+    "use strict";
+    init_passage_parser();
+    PassageIndex = class {
+      /** Per-URI list of passages. */
+      byUri = /* @__PURE__ */ new Map();
+      /**
+       * Parse all passage headers in the given document text and
+       * store them, replacing any previous entries for this URI.
+       */
+      rebuild(uri, text) {
+        this.byUri.delete(uri);
+        const lines = text.split("\n");
+        const passages = [];
+        for (let i = 0; i < lines.length; i++) {
+          const header = parsePassageHeader(lines[i], i);
+          if (!header) continue;
+          const passage = {
+            name: header.name,
+            range: {
+              start: { line: i, character: 0 },
+              end: { line: i, character: lines[i].length }
+              // will be extended below
+            },
+            headerEnd: header.headerRange,
+            uri,
+            tags: header.tags.length > 0 ? header.tags : void 0,
+            meta: header.meta
+          };
+          passages.push(passage);
+        }
+        for (let i = 0; i < passages.length; i++) {
+          const nextStart = i + 1 < passages.length ? passages[i + 1].range.start.line - 1 : lines.length - 1;
+          passages[i].range = {
+            start: passages[i].range.start,
+            end: { line: nextStart, character: lines[nextStart]?.length ?? 0 }
+          };
+        }
+        if (passages.length > 0) {
+          this.byUri.set(uri, passages);
+        }
+      }
+      /** Remove all passages for a URI. */
+      remove(uri) {
+        this.byUri.delete(uri);
+      }
+      /** Get a passage by name. Returns the first match found. */
+      getPassage(name) {
+        for (const passages of this.byUri.values()) {
+          for (const p of passages) {
+            if (p.name === name) return p;
+          }
+        }
+        return void 0;
+      }
+      /** Get the passage containing a specific line in a document. */
+      getPassageAt(uri, line) {
+        const passages = this.byUri.get(uri);
+        if (!passages) return void 0;
+        for (let i = passages.length - 1; i >= 0; i--) {
+          if (passages[i].range.start.line <= line) {
+            return passages[i];
+          }
+        }
+        return void 0;
+      }
+      /** Get all passages in a specific document. */
+      getPassagesInDocument(uri) {
+        return this.byUri.get(uri) ?? [];
+      }
+      /** Get all passages across all documents. */
+      getAllPassages() {
+        const result = [];
+        for (const passages of this.byUri.values()) {
+          result.push(...passages);
+        }
+        return result;
+      }
+      /** Get the StoryVariables passage, if any. */
+      getStoryVariables() {
+        return this.getPassage("StoryVariables");
+      }
+      /** Get the StoryInit passage, if any. */
+      getStoryInit() {
+        return this.getPassage("StoryInit");
+      }
+      /**
+       * Find passage names that appear more than once across all documents.
+       * Returns a map from name to the list of duplicate Passage objects.
+       */
+      getDuplicates() {
+        const byName = /* @__PURE__ */ new Map();
+        for (const passages of this.byUri.values()) {
+          for (const p of passages) {
+            const existing = byName.get(p.name);
+            if (existing) {
+              existing.push(p);
+            } else {
+              byName.set(p.name, [p]);
+            }
+          }
+        }
+        const duplicates = /* @__PURE__ */ new Map();
+        for (const [name, passages] of byName) {
+          if (passages.length > 1) {
+            duplicates.set(name, passages);
+          }
+        }
+        return duplicates;
+      }
+    };
+  }
+});
+// src/core/workspace/macro-registry.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join, parse as parsePath } from "node:path";
+import { fileURLToPath } from "node:url";
+var MacroRegistry;
+var init_macro_registry = __esm({
+  "src/core/workspace/macro-registry.ts"() {
+    "use strict";
+    MacroRegistry = class {
+      macros = /* @__PURE__ */ new Map();
+      /**
+       * Load built-in macro metadata from @rohal12/spindle's macro-registry.json.
+       * This is the base layer that provides name, block, subMacros, flags, source.
+       */
+      /** Warnings collected during loadBuiltins for logging. */
+      warnings = [];
+      loadBuiltins() {
+        let builtinMacros = [];
+        try {
+          const thisDir = dirname(fileURLToPath(import.meta.url));
+          const registryPath = this.resolveRegistryPath(thisDir);
+          if (registryPath) {
+            const raw = readFileSync2(registryPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+              this.warnings.push(
+                `macro-registry.json: expected array, got ${typeof parsed}. Continuing with supplements only.`
+              );
+            } else {
+              builtinMacros = parsed;
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          this.warnings.push(
+            `Failed to load builtin macros: ${message}. Continuing with supplements only.`
+          );
+        }
+        for (const m of builtinMacros) {
+          try {
+            const key = m.name.toLowerCase();
+            this.macros.set(key, {
+              name: m.name,
+              block: m.block,
+              subMacros: m.subMacros ?? [],
+              storeVar: m.storeVar,
+              interpolate: m.interpolate,
+              merged: m.merged,
+              source: m.source === "builtin" ? "builtin" : "user"
+            });
+          } catch {
+            this.warnings.push(`Skipped malformed builtin macro entry: ${JSON.stringify(m)}`);
+          }
+        }
+      }
+      /**
+       * 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);
+      }
+      /**
+       * Overlay user config onto the registry.
+       * Same format as supplements; applied last so it wins.
+       */
+      loadConfig(config) {
+        this.mergeEntries(config);
+      }
+      /** 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,
+          children: info.children ?? existing?.children,
+          parents: info.parents ?? existing?.parents,
+          skipArgs: info.skipArgs ?? existing?.skipArgs
+        });
+      }
+      /** Get a macro by name (case-insensitive). */
+      getMacro(name) {
+        return this.macros.get(name.toLowerCase());
+      }
+      /** Check if a macro is a block (container) macro. */
+      isBlock(name) {
+        return this.macros.get(name.toLowerCase())?.block ?? false;
+      }
+      /** Check if a macro is a sub-macro (has parents). */
+      isSubMacro(name) {
+        const info = this.macros.get(name.toLowerCase());
+        return info?.parents != null && info.parents.length > 0;
+      }
+      /** Get all registered macros. */
+      getAllMacros() {
+        return Array.from(this.macros.values());
+      }
+      /**
+       * Walk up directory tree from `startDir` to find the
+       * @rohal12/spindle/dist/pkg/macro-registry.json file.
+       */
+      resolveRegistryPath(startDir) {
+        const target = join("node_modules", "@rohal12", "spindle", "dist", "pkg", "macro-registry.json");
+        let dir = startDir;
+        const { root } = parsePath(dir);
+        while (dir !== root) {
+          const candidate = join(dir, target);
+          if (existsSync(candidate)) {
+            return candidate;
+          }
+          dir = dirname(dir);
+        }
+        return null;
+      }
+      /** 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) {
+            if (entry.description !== void 0) existing.description = entry.description;
+            if (entry.parameters !== void 0) existing.parameters = entry.parameters;
+            if (entry.children !== void 0) existing.children = entry.children;
+            if (entry.parents !== void 0) existing.parents = entry.parents;
+            if (entry.skipArgs !== void 0) existing.skipArgs = entry.skipArgs;
+            if (entry.container !== void 0) existing.block = entry.container;
+          } else {
+            this.macros.set(key, {
+              name: entry.name ?? rawKey,
+              block: entry.container ?? false,
+              subMacros: [],
+              source: "user",
+              description: entry.description,
+              parameters: entry.parameters,
+              children: entry.children,
+              parents: entry.parents,
+              skipArgs: entry.skipArgs
+            });
+          }
+        }
+      }
+    };
+  }
+});
+// src/core/workspace/variable-tracker.ts
+var varRefRegex, EXCLUDED_PASSAGES, CLEAN_PATTERNS, VariableTracker;
+var init_variable_tracker = __esm({
+  "src/core/workspace/variable-tracker.ts"() {
+    "use strict";
+    init_passage_parser();
+    varRefRegex = /\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+    EXCLUDED_PASSAGES = /* @__PURE__ */ new Set([
+      "StoryVariables",
+      "StoryInit",
+      "StoryData",
+      "StoryScript",
+      "StoryInterface"
+    ]);
+    CLEAN_PATTERNS = [
+      /<!--[\s\S]*?-->/g,
+      // HTML comments
+      /<script(?:\s+[^>]*)?>[\s\S]*?<\/script>/gi,
+      // script tags
+      /<style>[\s\S]*?<\/style>/gi,
+      // style tags
+      /`(?:\\.|[^`\\])*`/g,
+      // backtick strings
+      /"(?:\\.|[^"\\])*"/g,
+      // double-quoted strings
+      /'(?:\\.|[^'\\])*'/g
+      // single-quoted strings
+    ];
+    VariableTracker = class {
+      declared = /* @__PURE__ */ new Map();
+      _hasStoryVariables = false;
+      /** Per-URI list of variable usages. */
+      usagesByUri = /* @__PURE__ */ new Map();
+      /**
+       * Parse the StoryVariables passage content for declarations.
+       * Each line like `$name = value` becomes a declaration.
+       */
+      parseStoryVariables(content) {
+        this.declared.clear();
+        this._hasStoryVariables = true;
+        const lines = content.split("\n");
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("<!--")) continue;
+          const match = /^\$([A-Za-z_$][\w$]*)\s*=\s*(.*)$/.exec(trimmed);
+          if (!match) continue;
+          const name = match[1];
+          const expr = match[2].trim();
+          const decl = { name, sigil: "$" };
+          if (expr.startsWith("{")) {
+            const fieldRegex = /(\w+)\s*:/g;
+            let fieldMatch;
+            const fields = [];
+            while ((fieldMatch = fieldRegex.exec(expr)) !== null) {
+              fields.push(fieldMatch[1]);
+            }
+            if (fields.length > 0) {
+              decl.fields = fields;
+            }
+          }
+          this.declared.set(name, decl);
+        }
+      }
+      /**
+       * Scan a document for variable usages.
+       * Identifies passages in the document and scans non-special ones.
+       */
+      scanDocument(uri, text, _macros) {
+        this.usagesByUri.delete(uri);
+        const lines = text.split("\n");
+        const usages = [];
+        const passageBoundaries = [];
+        for (let i = 0; i < lines.length; i++) {
+          const header = parsePassageHeader(lines[i], i);
+          if (header) {
+            passageBoundaries.push({ name: header.name, startLine: i });
+          }
+        }
+        for (let pi = 0; pi < passageBoundaries.length; pi++) {
+          const passage = passageBoundaries[pi];
+          if (EXCLUDED_PASSAGES.has(passage.name)) continue;
+          const contentStartLine = passage.startLine + 1;
+          const contentEndLine = pi + 1 < passageBoundaries.length ? passageBoundaries[pi + 1].startLine : lines.length;
+          const contentLines = lines.slice(contentStartLine, contentEndLine);
+          const content = contentLines.join("\n");
+          let cleaned = content;
+          for (const pattern of CLEAN_PATTERNS) {
+            cleaned = cleaned.replace(pattern, (m) => " ".repeat(m.length));
+          }
+          const lineOffsets = [0];
+          for (let i = 0; i < cleaned.length; i++) {
+            if (cleaned[i] === "\n") lineOffsets.push(i + 1);
+          }
+          const re = new RegExp(varRefRegex.source, "g");
+          let match;
+          while ((match = re.exec(cleaned)) !== null) {
+            const fullName = match[1];
+            const baseName = fullName.split(".")[0];
+            const charOffset = match.index;
+            let localLine = 0;
+            for (let i = 0; i < lineOffsets.length; i++) {
+              if (lineOffsets[i] > charOffset) break;
+              localLine = i;
+            }
+            const character = charOffset - lineOffsets[localLine];
+            const absoluteLine = contentStartLine + localLine;
+            const range = {
+              start: { line: absoluteLine, character },
+              end: { line: absoluteLine, character: character + match[0].length }
+            };
+            usages.push({ uri, baseName, fullName, range });
+          }
+        }
+        if (usages.length > 0) {
+          this.usagesByUri.set(uri, usages);
+        }
+      }
+      /** Get all declared variables. */
+      getDeclared() {
+        return this.declared;
+      }
+      /** Get all usages of a variable by base name. */
+      getUsages(name) {
+        const results = [];
+        for (const usages of this.usagesByUri.values()) {
+          for (const u of usages) {
+            if (u.baseName === name) {
+              results.push({ uri: u.uri, range: u.range });
+            }
+          }
+        }
+        return results;
+      }
+      /** Get undeclared variable usages in a specific document. */
+      getUndeclared(uri) {
+        const usages = this.usagesByUri.get(uri);
+        if (!usages) return [];
+        const results = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const u of usages) {
+          if (!this.declared.has(u.baseName) && !seen.has(u.baseName)) {
+            seen.add(u.baseName);
+            results.push({ name: u.baseName, range: u.range });
+          }
+        }
+        return results;
+      }
+      /** Whether a StoryVariables passage has been parsed. */
+      hasStoryVariables() {
+        return this._hasStoryVariables;
+      }
+    };
+  }
+});
+// src/core/workspace/widget-registry.ts
+var widgetDefRegex, paramRegex, WidgetRegistry;
+var init_widget_registry = __esm({
+  "src/core/workspace/widget-registry.ts"() {
+    "use strict";
+    widgetDefRegex = /\{widget\s+"([^"]+)"((?:\s+@[A-Za-z_$][\w$]*)*)\s*\}/gi;
+    paramRegex = /@([A-Za-z_$][\w$]*)/g;
+    WidgetRegistry = class {
+      widgets = /* @__PURE__ */ new Map();
+      /**
+       * Scan all passages for widget definitions.
+       * Only passages tagged `widget` are examined.
+       *
+       * @param passages - All known passages.
+       * @param getContent - Function to retrieve document text by URI.
+       */
+      scan(passages, getContent) {
+        this.widgets.clear();
+        for (const passage of passages) {
+          if (!passage.tags?.includes("widget")) continue;
+          const text = getContent(passage.uri);
+          if (!text) continue;
+          const lines = text.split("\n");
+          const contentStartLine = passage.range.start.line + 1;
+          let contentEndLine = lines.length;
+          for (let i = contentStartLine; i < lines.length; i++) {
+            if (/^::\s+/.test(lines[i])) {
+              contentEndLine = i;
+              break;
+            }
+          }
+          const contentLines = lines.slice(contentStartLine, contentEndLine);
+          for (let i = 0; i < contentLines.length; i++) {
+            const line = contentLines[i];
+            widgetDefRegex.lastIndex = 0;
+            let match;
+            while ((match = widgetDefRegex.exec(line)) !== null) {
+              const widgetName = match[1];
+              const paramString = match[2] || "";
+              const params = [];
+              let paramMatch;
+              paramRegex.lastIndex = 0;
+              while ((paramMatch = paramRegex.exec(paramString)) !== null) {
+                params.push(paramMatch[1]);
+              }
+              const lineNum = contentStartLine + i;
+              const charStart = match.index;
+              const charEnd = charStart + match[0].length;
+              const range = {
+                start: { line: lineNum, character: charStart },
+                end: { line: lineNum, character: charEnd }
+              };
+              this.widgets.set(widgetName, {
+                name: widgetName,
+                params,
+                uri: passage.uri,
+                range
+              });
+            }
+          }
+        }
+      }
+      /** Get a widget definition by name. */
+      getWidget(name) {
+        return this.widgets.get(name);
+      }
+      /** Get all registered widget definitions. */
+      getAllWidgets() {
+        return Array.from(this.widgets.values());
+      }
+    };
+  }
+});
+// src/core/parsing/macro-parser.ts
+function buildLineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "\n") {
+      starts.push(i + 1);
+    }
+  }
+  return starts;
+}
+function offsetToPosition(offset, lineStarts) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (lineStarts[mid] <= offset) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return { line: low, character: offset - lineStarts[low] };
+}
+function parseMacros(text) {
+  const cleaned = text.replace(variableInterpolationRegex, (match2) => {
+    return " ".repeat(match2.length);
+  });
+  const lineStarts = buildLineStarts(text);
+  const macros = [];
+  let id = 0;
+  macroRegex.lastIndex = 0;
+  let match;
+  while ((match = macroRegex.exec(cleaned)) !== null) {
+    const closeSlash = match[1];
+    const cssPrefix = (match[2] || "").trim();
+    const macroName = match[3];
+    const rawArgs = match[4];
+    const open = closeSlash !== "/";
+    const matchStart = match.index;
+    const matchEnd = matchStart + match[0].length;
+    const startPos = offsetToPosition(matchStart, lineStarts);
+    const endPos = offsetToPosition(matchEnd, lineStarts);
+    const range = {
+      start: startPos,
+      end: endPos
+    };
+    macros.push({
+      id,
+      pair: -1,
+      name: macroName,
+      open,
+      range,
+      cssPrefix: cssPrefix || void 0,
+      rawArgs: rawArgs || void 0
+    });
+    id++;
+  }
+  return macros;
+}
+function pairMacros(macros, isBlock) {
+  const stacks = {};
+  for (const macro of macros) {
+    const name = macro.name.toLowerCase();
+    if (!isBlock(macro.name)) continue;
+    if (macro.open) {
+      if (!stacks[name]) stacks[name] = [];
+      stacks[name].push(macro.id);
+    } else {
+      const stack = stacks[name];
+      if (stack && stack.length > 0) {
+        const openId = stack.pop();
+        macros[openId].pair = macro.id;
+        macro.pair = openId;
+      }
+    }
+  }
+}
+var variableInterpolationRegex, macroRegex;
+var init_macro_parser = __esm({
+  "src/core/parsing/macro-parser.ts"() {
+    "use strict";
+    variableInterpolationRegex = /(?<!\\)\{([$_@][A-Za-z_$][\w$.]*)\}/g;
+    macroRegex = /(?<!\\)\{(\/)?(?:((?:[#.][a-zA-Z][\w-]*\s*)*)([A-Za-z][\w-]*))(?:\s+((?:(?:`(?:\\.|[^`\\])*?`)|(?:"(?:\\.|[^"\\])*?")|(?:'(?:\\.|[^'\\])*?')|(?:\[(?:[<>]?[Ii][Mm][Gg])?\[[^\r\n]*?\]\]+)|[^}]|(?:}))*?))?\}/gmi;
+  }
+});
+// src/macro-supplements.json
+var macro_supplements_default;
+var init_macro_supplements = __esm({
+  "src/macro-supplements.json"() {
+    macro_supplements_default = {
+      if: {
+        name: "if",
+        children: [
+          { name: "else", max: 1 },
+          { name: "elseif" }
+        ],
+        container: true,
+        description: "Conditionally displays its contents based on the given expression.\n\nUsage:\n\n```\n{if condition}\n  ...\n{elseif condition}\n  ...\n{else}\n  ...\n{/if}\n```",
+        parameters: ["...text"]
+      },
+      elseif: {
+        name: "elseif",
+        parents: ["if"],
+        description: "Used within `{if}` to provide an additional conditional branch.\n\nUsage: `{elseif condition}`",
+        parameters: ["...text"]
+      },
+      else: {
+        name: "else",
+        parents: ["if"],
+        description: "Used within `{if}` to provide a fallback branch.\n\nUsage: `{else}`",
+        parameters: []
+      },
+      for: {
+        name: "for",
+        children: [
+          { name: "next" },
+          { name: "stop" }
+        ],
+        container: true,
+        description: "Loop block. Usage: `{for @item of $list}...{/for}` or `{for @item, @index of $list}...{/for}`",
+        skipArgs: true
+      },
+      next: {
+        name: "next",
+        parents: ["for"],
+        description: "Continues to the next iteration of a `{for}` loop.\n\nUsage: `{next}`",
+        parameters: []
+      },
+      stop: {
+        name: "stop",
+        parents: ["for", "repeat"],
+        description: "Breaks out of a `{for}` or `{repeat}` loop.\n\nUsage: `{stop}`",
+        parameters: []
+      },
+      switch: {
+        name: "switch",
+        children: [
+          { name: "case", min: 1 },
+          { name: "default", max: 1 }
+        ],
+        container: true,
+        description: "Evaluates an expression and executes the matching `{case}` branch.\n\nUsage:\n\n```\n{switch expression}\n  {case value1}\n    ...\n  {case value2}\n    ...\n  {default}\n    ...\n{/switch}\n```",
+        parameters: ["...text"]
+      },
+      case: {
+        name: "case",
+        parents: ["switch"],
+        description: "Defines a branch within a `{switch}` macro.\n\nUsage: `{case value}`",
+        parameters: ["...text"]
+      },
+      default: {
+        name: "default",
+        parents: ["switch"],
+        description: "Defines the default branch within a `{switch}` macro.\n\nUsage: `{default}`",
+        parameters: []
+      },
+      set: {
+        name: "set",
+        description: "Sets variables based on the given expression.\n\nUsage: `{set $var to value}`\n\nSupports `$var` (story), `_var` (temporary), and `@var` (local) variables.",
+        parameters: ["...text"]
+      },
+      unset: {
+        name: "unset",
+        description: "Unsets one or more variables.\n\nUsage: `{unset $var}`",
+        parameters: ["...text"]
+      },
+      computed: {
+        name: "computed",
+        description: "Evaluates an expression and outputs the result.\n\nUsage: `{computed expression}`",
+        parameters: ["...text"]
+      },
+      print: {
+        name: "print",
+        description: "Outputs the result of the given expression.\n\nUsage: `{print expression}`",
+        parameters: ["...text"]
+      },
+      do: {
+        name: "do",
+        container: true,
+        description: "Displays its contents. Can be updated dynamically.\n\nUsage:\n\n```\n{do}\n  ...\n{/do}\n```",
+        parameters: []
+      },
+      link: {
+        name: "link",
+        container: true,
+        description: 'Creates a link that executes its contents when clicked.\n\nUsage:\n\n```\n{link "text" "passage"}\n  ...\n{/link}\n```',
+        parameters: ["text |+ text", ""]
+      },
+      button: {
+        name: "button",
+        container: true,
+        description: 'Creates a button that executes its contents when clicked.\n\nUsage:\n\n```\n{button "text" "passage"}\n  ...\n{/button}\n```',
+        parameters: ["text |+ text", ""]
+      },
+      timed: {
+        name: "timed",
+        children: [
+          { name: "next" }
+        ],
+        container: true,
+        description: "Displays its contents after a specified delay.\n\nUsage:\n\n```\n{timed delay}\n  ...\n  {next delay}\n  ...\n{/timed}\n```",
+        parameters: ["text"]
+      },
+      repeat: {
+        name: "repeat",
+        children: [
+          { name: "stop" }
+        ],
+        container: true,
+        description: "Repeatedly displays its contents at the specified interval.\n\nUsage:\n\n```\n{repeat delay}\n  ...\n{/repeat}\n```",
+        parameters: ["text"]
+      },
+      type: {
+        name: "type",
+        container: true,
+        description: "Outputs its contents one character at a time, mimicking a typewriter effect.\n\nUsage:\n\n```\n{type speed}\n  ...\n{/type}\n```",
+        parameters: ["text"]
+      },
+      listbox: {
+        name: "listbox",
+        children: [
+          { name: "option", min: 1 }
+        ],
+        container: true,
+        description: 'Creates a dropdown listbox.\n\nUsage:\n\n```\n{listbox "$receiver"}\n  {option "label1"}\n  {option "label2"}\n{/listbox}\n```',
+        parameters: ["receiver"]
+      },
+      cycle: {
+        name: "cycle",
+        children: [
+          { name: "option", min: 1 }
+        ],
+        container: true,
+        description: 'Creates a cycling link.\n\nUsage:\n\n```\n{cycle "$receiver"}\n  {option "label1"}\n  {option "label2"}\n{/cycle}\n```',
+        parameters: ["receiver"]
+      },
+      option: {
+        name: "option",
+        parents: ["listbox", "cycle"],
+        description: "Defines an option within a `{listbox}` or `{cycle}` macro.\n\nUsage: `{option label}`",
+        parameters: ["|+ text &+ text", "text"]
+      },
+      widget: {
+        name: "widget",
+        container: true,
+        description: 'Defines a custom widget (macro).\n\nUsage:\n\n```\n{widget "name"}\n  ...\n{/widget}\n```',
+        parameters: ["...text"]
+      },
+      meter: {
+        name: "meter",
+        description: "Displays a progress meter.\n\nUsage: `{meter $var min max}`",
+        parameters: ["...text"]
+      },
+      goto: {
+        name: "goto",
+        description: 'Navigates to the specified passage.\n\nUsage: `{goto "passage"}`',
+        parameters: ["text"]
+      },
+      back: {
+        name: "back",
+        description: "Creates a link or navigates to the previous passage in history.\n\nUsage: `{back}`",
+        parameters: []
+      },
+      forward: {
+        name: "forward",
+        description: "Creates a link or navigates to the next passage in history.\n\nUsage: `{forward}`",
+        parameters: []
+      },
+      restart: {
+        name: "restart",
+        description: "Restarts the story.\n\nUsage: `{restart}`",
+        parameters: []
+      },
+      include: {
+        name: "include",
+        description: 'Outputs the contents of the specified passage.\n\nUsage: `{include "passage"}`',
+        parameters: ["text"]
+      },
+      passage: {
+        name: "passage",
+        description: "Outputs the name of the current passage.\n\nUsage: `{passage}`",
+        parameters: []
+      },
+      textbox: {
+        name: "textbox",
+        description: 'Creates a text input box.\n\nUsage: `{textbox "$receiver" defaultValue}`',
+        parameters: ["receiver &+ text"]
+      },
+      numberbox: {
+        name: "numberbox",
+        description: 'Creates a number input box.\n\nUsage: `{numberbox "$receiver" defaultValue}`',
+        parameters: ["receiver &+ text"]
+      },
+      textarea: {
+        name: "textarea",
+        description: 'Creates a multi-line text input area.\n\nUsage: `{textarea "$receiver" defaultValue}`',
+        parameters: ["receiver &+ text"]
+      },
+      checkbox: {
+        name: "checkbox",
+        description: 'Creates a checkbox input.\n\nUsage: `{checkbox "$receiver" uncheckedValue checkedValue}`',
+        parameters: ["receiver &+ text"]
+      },
+      radiobutton: {
+        name: "radiobutton",
+        description: 'Creates a radio button input.\n\nUsage: `{radiobutton "$receiver" value}`',
+        parameters: ["receiver &+ text &+ text"]
+      },
+      quicksave: {
+        name: "quicksave",
+        description: "Performs a quick save of the current story state.\n\nUsage: `{quicksave}`",
+        parameters: []
+      },
+      quickload: {
+        name: "quickload",
+        description: "Loads the most recent quick save.\n\nUsage: `{quickload}`",
+        parameters: []
+      },
+      saves: {
+        name: "saves",
+        description: "Opens the saves dialog.\n\nUsage: `{saves}`",
+        parameters: []
+      },
+      settings: {
+        name: "settings",
+        description: "Opens the settings dialog.\n\nUsage: `{settings}`",
+        parameters: []
+      },
+      "story-title": {
+        name: "story-title",
+        description: "Outputs the story title.\n\nUsage: `{story-title}`",
+        parameters: []
+      },
+      dialog: {
+        name: "dialog",
+        container: true,
+        description: 'Opens a dialog with its contents.\n\nUsage:\n\n```\n{dialog "title"}\n  ...\n{/dialog}\n```',
+        parameters: ["text"]
+      },
+      nobr: {
+        name: "nobr",
+        container: true,
+        description: "Removes line breaks from its contents.\n\nUsage:\n\n```\n{nobr}\n  ...\n{/nobr}\n```",
+        parameters: []
+      },
+      span: {
+        name: "span",
+        container: true,
+        description: "Wraps its contents in a `<span>` element.\n\nUsage:\n\n```\n{span}\n  ...\n{/span}\n```",
+        parameters: []
+      },
+      "save-manager": {
+        name: "save-manager",
+        description: "Renders the save/load UI.\n\nUsage: `{save-manager}`",
+        parameters: []
+      },
+      "settings-controls": {
+        name: "settings-controls",
+        description: "Renders the settings controls UI.\n\nUsage: `{settings-controls}`",
+        parameters: []
+      },
+      watch: {
+        name: "watch",
+        description: "Watches a variable for changes and triggers a re-render.\n\nUsage: `{watch $var}`",
+        parameters: ["...text"]
+      },
+      unwatch: {
+        name: "unwatch",
+        description: "Stops watching a variable.\n\nUsage: `{unwatch $var}`",
+        parameters: ["...text"]
+      }
+    };
+  }
+});
+// src/core/workspace/workspace-model.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+var WorkspaceModel;
+var init_workspace_model = __esm({
+  "src/core/workspace/workspace-model.ts"() {
+    "use strict";
+    init_document_store();
+    init_passage_index();
+    init_macro_registry();
+    init_variable_tracker();
+    init_widget_registry();
+    init_macro_parser();
+    init_macro_supplements();
+    WorkspaceModel = class extends EventEmitter2 {
+      documents;
+      passages;
+      macros;
+      variables;
+      widgets;
+      debounceTimer = null;
+      DEBOUNCE_MS = 200;
+      /** Bound listeners for cleanup in dispose(). */
+      onDocumentChanged;
+      onDocumentOpened;
+      onDocumentClosed;
+      constructor(config) {
+        super();
+        this.documents = new DocumentStore();
+        this.passages = new PassageIndex();
+        this.macros = new MacroRegistry();
+        this.variables = new VariableTracker();
+        this.widgets = new WidgetRegistry();
+        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.macros.loadBuiltins();
+        this.macros.loadSupplements(macro_supplements_default);
+        this.documents.removeListener("documentOpened", this.onDocumentOpened);
+        this.documents.removeListener("documentChanged", this.onDocumentChanged);
+        for (const [uri, text] of fileContents) {
+          this.documents.open(uri, text);
+        }
+        this.documents.on("documentOpened", this.onDocumentOpened);
+        this.documents.on("documentChanged", this.onDocumentChanged);
+        this.rebuildAll();
+        this.scheduleModelReady();
+      }
+      /** 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();
+      }
+      /** Handle a document change: rebuild passages for that document, then cascade. */
+      handleDocumentChange(uri) {
+        const text = this.documents.getText(uri);
+        if (text !== void 0) {
+          this.passages.rebuild(uri, text);
+        }
+        this.cascade();
+        this.emit("documentChanged", uri);
+        this.emit("passagesUpdated", uri);
+        this.scheduleModelReady();
+      }
+      /** Handle a document close: remove its passages and cascade. */
+      handleDocumentClose(uri) {
+        this.passages.remove(uri);
+        this.cascade();
+        this.emit("documentClosed", uri);
+        this.emit("passagesUpdated", uri);
+        this.scheduleModelReady();
+      }
+      /** Rebuild all indices from scratch. */
+      rebuildAll() {
+        for (const uri of this.documents.getUris()) {
+          const text = this.documents.getText(uri);
+          if (text !== void 0) {
+            this.passages.rebuild(uri, text);
+          }
+        }
+        this.cascade();
+      }
+      /**
+       * Cascade: rescan variables and widgets based on current passages.
+       * Called after any passage index update.
+       */
+      cascade() {
+        const storyVars = this.passages.getStoryVariables();
+        if (storyVars) {
+          const text = this.documents.getText(storyVars.uri);
+          if (text) {
+            const lines = text.split("\n");
+            const contentStart = storyVars.headerEnd.end.line + 1;
+            let contentEnd = lines.length;
+            for (let i = contentStart; i < lines.length; i++) {
+              if (/^::\s+/.test(lines[i])) {
+                contentEnd = i;
+                break;
+              }
+            }
+            const content = lines.slice(contentStart, contentEnd).join("\n");
+            this.variables.parseStoryVariables(content);
+          }
+        }
+        for (const uri of this.documents.getUris()) {
+          const text = this.documents.getText(uri);
+          if (text) {
+            const macros = parseMacros(text);
+            this.variables.scanDocument(uri, text, macros);
+          }
+        }
+        const allPassages = this.passages.getAllPassages();
+        this.widgets.scan(allPassages, (uri) => this.documents.getText(uri));
+      }
+      /** Debounce modelReady emission. */
+      scheduleModelReady() {
+        if (this.debounceTimer) {
+          clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+          this.debounceTimer = null;
+          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 = {
+      UndefinedMacro: "SP100",
+      MalformedContainer: "SP101",
+      IllegalClosingTag: "SP104",
+      InvalidChildren: "SP107",
+      ExpectedNoArguments: "SP108",
+      ParameterTypeError: "SP109",
+      ParameterWarning: "SP110",
+      TooManyArguments: "SP111",
+      ArgumentParsingWarning: "SP112",
+      ChildMaxExceeded: "SP114",
+      ChildMinNotMet: "SP115",
+      UndeclaredVariable: "SP200",
+      UndeclaredField: "SP201",
+      NoStoryVariables: "SP202",
+      BrokenPassageLink: "SP300",
+      WidgetArgCountMismatch: "SP301",
+      DeadEndPassage: "SP400",
+      UnreachablePassage: "SP401"
+    };
+    severityMap = {
+      SP100: "warning",
+      SP101: "error",
+      SP104: "error",
+      SP107: "error",
+      SP108: "error",
+      SP109: "error",
+      SP110: "warning",
+      SP111: "error",
+      SP112: "warning",
+      SP114: "error",
+      SP115: "error",
+      SP200: "warning",
+      SP201: "warning",
+      SP202: "info",
+      SP300: "warning",
+      SP301: "warning",
+      SP400: "hint",
+      SP401: "hint"
+    };
+  }
+});
+// src/core/parsing/argument-lexer.ts
+function lexArguments(source) {
+  const lexer = new Lexer(source, lexSpace);
+  const rawItems = lexer.run();
+  const args2 = [];
+  for (const item of rawItems) {
+    if (item.type === 0 /* Error */) {
+      break;
+    }
+    args2.push(classifyToken(item));
+  }
+  return args2;
+}
+function classifyToken(item) {
+  const text = item.text;
+  const base = { text, start: item.start, end: item.position };
+  switch (item.type) {
+    case 3 /* String */:
+      return { ...base, type: 0 /* String */ };
+    case 2 /* Expression */:
+      return { ...base, type: 7 /* Expression */ };
+    case 4 /* SquareBracket */: {
+      const inner = text.slice(1);
+      if (/^[<>]?[Ii][Mm][Gg]\[/.test(inner)) {
+        return { ...base, type: 6 /* Image */ };
+      }
+      return { ...base, type: 5 /* Link */ };
+    }
+    case 1 /* Bareword */: {
+      if (varTestRegexp.test(text)) {
+        const sigil = text[0];
+        const pathParts = text.slice(1).split(".");
+        return {
+          ...base,
+          type: 4 /* Variable */,
+          sigil,
+          path: pathParts
+        };
+      }
+      if (text === "null") return { ...base, type: 3 /* Null */ };
+      if (text === "undefined") return { ...base, type: 10 /* Undefined */ };
+      if (text === "true") return { ...base, type: 2 /* Boolean */ };
+      if (text === "false") return { ...base, type: 2 /* Boolean */ };
+      if (text === "NaN") return { ...base, type: 9 /* NaN */ };
+      const asNum = Number(text);
+      if (!Number.isNaN(asNum)) {
+        return { ...base, type: 1 /* Number */ };
+      }
+      return { ...base, type: 8 /* Bareword */ };
+    }
+    default:
+      return { ...base, type: 8 /* Bareword */ };
+  }
+}
+function slurpQuote(lexer, endQuote) {
+  for (; ; ) {
+    const next = lexer.next();
+    if (next === "\\") {
+      const ch = lexer.next();
+      if (ch !== EOF && ch !== "\n") continue;
+    } else if (next === EOF) {
+      return EOF;
+    } else if (next === "\n" && endQuote !== "`") {
+      return EOF;
+    } else if (next === endQuote) {
+      break;
+    }
+  }
+  return lexer.pos;
+}
+function lexSpace(lexer) {
+  const offset = lexer.source.slice(lexer.pos).search(notSpaceRegex);
+  if (offset === -1) return null;
+  if (offset !== 0) {
+    lexer.pos += offset;
+    lexer.ignore();
+  }
+  if (lexer.peek() === ",") {
+    lexer.next();
+    lexer.ignore();
+    return lexSpace;
+  }
+  switch (lexer.next()) {
+    case "`":
+      return lexExpression;
+    case '"':
+      return lexDoubleQuote;
+    case "'":
+      return lexSingleQuote;
+    case "[":
+      return lexSquareBracket;
+    default:
+      return lexBareword;
+  }
+}
+function lexExpression(lexer) {
+  if (slurpQuote(lexer, "`") === EOF) {
+    return lexer.error(0 /* Error */, "unterminated backquote expression");
+  }
+  lexer.emit(2 /* Expression */);
+  return lexSpace;
+}
+function lexDoubleQuote(lexer) {
+  if (slurpQuote(lexer, '"') === EOF) {
+    return lexer.error(0 /* Error */, "unterminated double quoted string");
+  }
+  lexer.emit(3 /* String */);
+  return lexSpace;
+}
+function lexSingleQuote(lexer) {
+  if (slurpQuote(lexer, "'") === EOF) {
+    return lexer.error(0 /* Error */, "unterminated single quoted string");
+  }
+  lexer.emit(3 /* String */);
+  return lexSpace;
+}
+function lexSquareBracket(lexer) {
+  const imgMeta = "<>IiMmGg";
+  let what;
+  if (lexer.accept(imgMeta)) {
+    what = "image";
+    lexer.acceptRun(imgMeta);
+  } else {
+    what = "link";
+  }
+  if (!lexer.accept("[")) {
+    return lexer.error(0 /* Error */, `malformed ${what} markup`);
+  }
+  lexer.depth = 2;
+  for (; ; ) {
+    switch (lexer.next()) {
+      case "\\": {
+        const ch = lexer.next();
+        if (ch !== EOF && ch !== "\n") break;
+      }
+      /* falls through */
+      case EOF:
+      case "\n":
+        return lexer.error(0 /* Error */, `unterminated ${what} markup`);
+      case "[":
+        ++lexer.depth;
+        break;
+      case "]":
+        --lexer.depth;
+        if (lexer.depth < 0) {
+          return lexer.error(0 /* Error */, "unexpected right square bracket ']'");
+        }
+        if (lexer.depth === 1) {
+          if (lexer.next() === "]") {
+            --lexer.depth;
+            lexer.emit(4 /* SquareBracket */);
+            return lexSpace;
+          }
+          lexer.backup();
+        }
+        break;
+    }
+  }
+}
+function lexBareword(lexer) {
+  const offset = lexer.source.slice(lexer.pos).search(spaceRegex);
+  if (offset === -1) {
+    let end = lexer.source.length;
+    while (end > lexer.pos && lexer.source[end - 1] === ",") {
+      end--;
+    }
+    lexer.pos = end;
+    lexer.emit(1 /* Bareword */);
+    if (end < lexer.source.length) {
+      lexer.pos = end + 1;
+      lexer.ignore();
+      return lexSpace;
+    }
+    return null;
+  }
+  const commaOffset = lexer.source.slice(lexer.pos).indexOf(",");
+  if (commaOffset !== -1 && commaOffset < offset) {
+    lexer.pos += commaOffset;
+    lexer.emit(1 /* Bareword */);
+    lexer.pos++;
+    lexer.ignore();
+    return lexSpace;
+  }
+  lexer.pos += offset;
+  lexer.emit(1 /* Bareword */);
+  return lexSpace;
+}
+var varTestRegexp, EOF, Lexer, notSpaceRegex, spaceRegex;
+var init_argument_lexer = __esm({
+  "src/core/parsing/argument-lexer.ts"() {
+    "use strict";
+    varTestRegexp = /^[$_@][$A-Z_a-z][$0-9A-Z_.a-z]*/;
+    EOF = -1;
+    Lexer = class {
+      source;
+      state;
+      start = 0;
+      pos = 0;
+      depth = 0;
+      items = [];
+      constructor(source, initial) {
+        this.source = source;
+        this.state = initial;
+      }
+      run() {
+        while (this.state !== null) {
+          this.state = this.state(this);
+        }
+        return this.items;
+      }
+      next() {
+        const ch = this.peek();
+        this.pos++;
+        return ch;
+      }
+      peek() {
+        if (this.pos >= this.source.length) return EOF;
+        return this.source[this.pos];
+      }
+      backup(num = 1) {
+        this.pos -= num;
+      }
+      forward(num = 1) {
+        this.pos += num;
+      }
+      ignore() {
+        this.start = this.pos;
+      }
+      accept(valid) {
+        const ch = this.next();
+        if (ch === EOF) return false;
+        if (valid.includes(ch)) return true;
+        this.backup();
+        return false;
+      }
+      acceptRun(valid) {
+        for (; ; ) {
+          const ch = this.next();
+          if (ch === EOF) return;
+          if (!valid.includes(ch)) {
+            break;
+          }
+        }
+        this.backup();
+      }
+      emit(type) {
+        this.items.push({
+          type,
+          text: this.source.slice(this.start, this.pos),
+          start: this.start,
+          position: this.pos
+        });
+        this.start = this.pos;
+      }
+      error(type, message) {
+        this.items.push({
+          type,
+          message,
+          text: this.source.slice(this.start, this.pos),
+          start: this.start,
+          position: this.pos
+        });
+        return null;
+      }
+    };
+    notSpaceRegex = /\S/;
+    spaceRegex = /\s/;
+  }
+});
+// src/core/parsing/parameter-validator.ts
+function isAlwaysArg(arg) {
+  return arg.type === 4 /* Variable */ || arg.type === 7 /* Expression */;
+}
+function findParameterType(name) {
+  for (const pt of parameterTypes) {
+    if (pt.name.includes(name)) return pt;
+  }
+  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}'`);
+      }
+    } else if (quoteRe.test(ch)) {
+      const openQuote = ch;
+      const start = pos;
+      pos++;
+      while (pos < formatString.length && formatString[pos] !== openQuote) {
+        if (++iter > LEX_LIMIT) throw new Error("Format lex string iteration limit exceeded");
+        pos++;
+      }
+      if (pos >= formatString.length) throw new Error("Lex: Unterminated string literal");
+      const value = formatString.slice(start + 1, pos);
+      pos++;
+      lexed.push({ kind: 1 /* Literal */, 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`);
+        }
+      }
+      const ident = formatString.slice(start, pos);
+      const pt = findParameterType(ident);
+      if (pt === null) throw new Error(`Lex: Unknown parameter type '${ident}'`);
+      lexed.push({ kind: 0 /* Type */, type: pt });
+    } 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 tokens = lexFormat(formatString);
+  if (tokens.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 = tokens[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 = tokens[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 = tokens[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 formatArgCountRange(format) {
+  switch (format.kind) {
+    case 0 /* Type */:
+    case 1 /* Literal */:
+      return { min: 1, max: 1 };
+    case 3 /* AndNext */: {
+      const l = formatArgCountRange(format.left);
+      const r = formatArgCountRange(format.right);
+      return { min: l.min + r.min, max: l.max + r.max };
+    }
+    case 4 /* MaybeNext */: {
+      const l = format.left ? formatArgCountRange(format.left) : { min: 0, max: 0 };
+      const r = formatArgCountRange(format.right);
+      return { min: l.min, max: l.max + r.max };
+    }
+    case 5 /* Or */: {
+      const l = formatArgCountRange(format.left);
+      const r = formatArgCountRange(format.right);
+      return { min: Math.min(l.min, r.min), max: Math.max(l.max, r.max) };
+    }
+    case 6 /* Repeat */:
+      return { min: 0, max: Infinity };
+  }
+}
+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) {
+  let iter = 0;
+  function crawl(fmt, argIdx) {
+    if (++iter > VALIDATE_LIMIT) {
+      throw new Error(`Validation iteration limit exceeded at argument ${argIdx}`);
+    }
+    switch (fmt.kind) {
+      case 4 /* MaybeNext */: {
+        let rank = 0;
+        let warnings = [];
+        let idx = argIdx;
+        if (fmt.left) {
+          const left = crawl(fmt.left, idx);
+          if (isFail(left.status)) return left;
+          rank += left.rank;
+          idx = left.argIndex;
+          warnings = left.warnings;
+        }
+        const right = crawl(fmt.right, idx);
+        if (right.status === 0 /* NotFound */) {
+          return makeSuccess(idx, rank, warnings);
+        }
+        if (isFail(right.status)) {
+          right.status = 1 /* Failure */;
+          return right;
+        }
+        return makeSuccess(right.argIndex, rank + right.rank, warnings.concat(right.warnings));
+      }
+      case 3 /* AndNext */: {
+        const left = crawl(fmt.left, argIdx);
+        if (isFail(left.status)) return left;
+        const right = crawl(fmt.right, left.argIndex);
+        if (isFail(right.status)) return right;
+        return makeSuccess(
+          right.argIndex,
+          left.rank + right.rank,
+          left.warnings.concat(right.warnings)
+        );
+      }
+      case 5 /* Or */: {
+        const left = crawl(fmt.left, argIdx);
+        if (!isFail(left.status)) return left;
+        const right = crawl(fmt.right, argIdx);
+        if (!isFail(right.status)) return right;
+        return left;
+      }
+      case 6 /* Repeat */: {
+        let rank = 0;
+        let warnings = [];
+        let idx = argIdx;
+        for (; ; ) {
+          const r = crawl(fmt.right, idx);
+          if (isFail(r.status)) break;
+          idx = r.argIndex;
+          rank += r.rank;
+          warnings = warnings.concat(r.warnings);
+        }
+        return makeSuccess(idx, rank, warnings);
+      }
+      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 */ ? arg.text.slice(1, -1) : 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 result = typeDef.validate(arg, args2, argIdx, state);
+        if (result instanceof TypeError2) {
+          return {
+            status: 1 /* Failure */,
+            rank: 0,
+            argIndex: argIdx,
+            errors: [{ message: result.message, argIndex: argIdx }],
+            warnings: []
+          };
+        }
+        if (result instanceof TypeWarning) {
+          return makeSuccess(argIdx + 1, CORRECT_RANK, [
+            { message: result.message, argIndex: argIdx }
+          ]);
+        }
+        return makeSuccess(argIdx + 1, CORRECT_RANK);
+      }
+    }
+  }
+  return crawl(format, startIndex);
+}
+var TypeError2, TypeWarning, parameterTypes, LEX_LIMIT, wsRe, identStartRe, identStopRe, quoteRe, digitRe, PARSE_LIMIT, VALIDATE_LIMIT, CORRECT_TYPE_RANK, CORRECT_RANK, Parameters;
+var init_parameter_validator = __esm({
+  "src/core/parsing/parameter-validator.ts"() {
+    "use strict";
+    init_argument_lexer();
+    TypeError2 = class {
+      constructor(message) {
+        this.message = message;
+      }
+    };
+    TypeWarning = class {
+      constructor(message) {
+        this.message = 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");
+        }
+      },
+      {
+        name: ["passage"],
+        validate(arg, _args, _index, state) {
+          let passageName;
+          if (arg.type === 0 /* String */) {
+            passageName = arg.text.slice(1, -1);
+          } 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) {
+            passageName = passageName.replace(/\\/g, "");
+            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");
+        }
+      }
+    ];
+    LEX_LIMIT = 1e3;
+    wsRe = /\s/;
+    identStartRe = /[a-zA-Z]/;
+    identStopRe = /[|&+\-\s)(]/;
+    quoteRe = /['"]/;
+    digitRe = /[0-9]/;
+    PARSE_LIMIT = 2e3;
+    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)
+        }));
+      }
+      /**
+       * Validate an array of Arg tokens against these parameter variants.
+       * Selects the best-matching variant by rank.
+       */
+      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 i = 0; i < this.variants.length; i++) {
+          const variant = this.variants[i];
+          if (variant.format === null) {
+            if (args2.length === 0) {
+              if (!bestIsClean || 0 > bestRank) {
+                bestIndex = i;
+                bestRank = 0;
+                bestErrors = [];
+                bestWarnings = [];
+                bestIsClean = true;
+              }
+            } else {
+              if (!bestIsClean && bestIndex === null) {
+                bestIndex = i;
+                bestRank = -1;
+                bestErrors = [{ message: "Expected no arguments", argIndex: 0 }];
+                bestWarnings = [];
+              }
+            }
+            continue;
+          }
+          const result = crawlValidate(variant.format, args2, 0, stateInfo);
+          let errors = result.errors;
+          if (result.errors.length === 0 && result.argIndex < args2.length) {
+            errors = [
+              {
+                message: `Too many arguments: expected ${result.argIndex}, got ${args2.length}`,
+                argIndex: result.argIndex
+              }
+            ];
+          }
+          const rank = result.rank;
+          const isClean = errors.length === 0;
+          if (isClean && (!bestIsClean || rank > bestRank)) {
+            bestIndex = i;
+            bestRank = rank;
+            bestErrors = [];
+            bestWarnings = result.warnings;
+            bestIsClean = true;
+          } else if (!isClean && !bestIsClean && rank > bestRank) {
+            bestIndex = i;
+            bestRank = rank;
+            bestErrors = errors;
+            bestWarnings = result.warnings;
+          } else if (bestIndex === null) {
+            bestIndex = i;
+            bestRank = rank;
+            bestErrors = errors;
+            bestWarnings = result.warnings;
+            bestIsClean = isClean;
+          }
+        }
+        return {
+          variantIndex: bestIndex,
+          errors: bestErrors,
+          warnings: bestWarnings
+        };
+      }
+      /**
+       * Compute the min/max argument count across all variants.
+       */
+      argCountRange() {
+        let min = Infinity;
+        let max = 0;
+        for (const variant of this.variants) {
+          if (variant.format === null) {
+            min = 0;
+          } else {
+            const range = formatArgCountRange(variant.format);
+            min = Math.min(min, range.min);
+            max = Math.max(max, range.max);
+          }
+        }
+        if (min === Infinity) min = 0;
+        return { min, max };
+      }
+      /**
+       * Whether all variants are empty (accept no arguments).
+       */
+      isEmpty() {
+        if (this.variants.length === 0) return true;
+        return !this.variants.some((v) => v.format !== null);
+      }
+    };
+  }
+});
+// src/core/parsing/link-parser.ts
+function buildLineStarts2(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "\n") {
+      starts.push(i + 1);
+    }
+  }
+  return starts;
+}
+function offsetToPosition2(offset, lineStarts) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (lineStarts[mid] <= offset) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return { line: low, character: offset - lineStarts[low] };
+}
+function parseLinks(text, lineOffset = 0) {
+  const lineStarts = buildLineStarts2(text);
+  const refs = [];
+  linkRegex.lastIndex = 0;
+  let match;
+  while ((match = linkRegex.exec(text)) !== null) {
+    const passageName = match[2].trim();
+    if (!passageName) continue;
+    const nameStartInMatch = match[0].indexOf(passageName);
+    const nameStart = match.index + nameStartInMatch;
+    const nameEnd = nameStart + passageName.length;
+    const startPos = offsetToPosition2(nameStart, lineStarts);
+    const endPos = offsetToPosition2(nameEnd, lineStarts);
+    const range = {
+      start: { line: startPos.line + lineOffset, character: startPos.character },
+      end: { line: endPos.line + lineOffset, character: endPos.character }
+    };
+    refs.push({
+      name: passageName,
+      range,
+      source: "link"
+    });
+  }
+  return refs;
+}
+var linkRegex;
+var init_link_parser = __esm({
+  "src/core/parsing/link-parser.ts"() {
+    "use strict";
+    linkRegex = /\[\[([^\]]*?\|)?([^\]]+?)\]\]/g;
+  }
+});
+// src/plugins/diagnostics.ts
+function computeDiagnostics(uri, workspace) {
+  try {
+    const text = workspace.documents.getText(uri);
+    if (text === void 0) return [];
+    const passages = workspace.passages.getPassagesInDocument(uri);
+    if (passages.length === 0) return [];
+    const diagnostics = [];
+    const macros = parseMacros(text);
+    pairMacros(macros, (name) => workspace.macros.isBlock(name));
+    const allPassages = workspace.passages.getAllPassages();
+    const passageNames = new Set(allPassages.map((p) => p.name));
+    try {
+      validateMacros(macros, workspace, diagnostics);
+    } catch {
+    }
+    try {
+      validateArguments(macros, workspace, passageNames, diagnostics);
+    } catch {
+    }
+    try {
+      validateVariables(uri, workspace, diagnostics);
+    } catch {
+    }
+    try {
+      validateLinks(text, passages, passageNames, diagnostics);
+    } catch {
+    }
+    try {
+      validateWidgetInvocations(macros, workspace, diagnostics);
+    } catch {
+    }
+    return diagnostics;
+  } catch {
+    return [];
+  }
+}
+function validateMacros(macros, workspace, diagnostics) {
+  for (let curIndex = 0; curIndex < macros.length; curIndex++) {
+    const macro = macros[curIndex];
+    const info = workspace.macros.getMacro(macro.name);
+    if (info) {
+      if (info.block) {
+        if (macro.open && macro.pair === -1) {
+          diagnostics.push(makeDiag(
+            macro.range,
+            DiagnosticCode.MalformedContainer,
+            `Malformed container: no matching {/${macro.name}}`
+          ));
+        } else if (!macro.open && macro.pair === -1) {
+          diagnostics.push(makeDiag(
+            macro.range,
+            DiagnosticCode.MalformedContainer,
+            `Malformed container: no matching {${macro.name}}`
+          ));
+        }
+        if (info.children && info.children.length > 0 && macro.open && macro.pair !== -1) {
+          validateChildren(macros, curIndex, macro, info.children, workspace, diagnostics);
+        }
+      } else {
+        if (!macro.open) {
+          diagnostics.push(makeDiag(
+            macro.range,
+            DiagnosticCode.IllegalClosingTag,
+            `Illegal closing tag: {${macro.name}} is not a container`
+          ));
+        }
+      }
+      if (info.parents && info.parents.length > 0 && macro.open) {
+        if (!isInsideParent(macros, curIndex, info.parents, workspace)) {
+          const parentList = info.parents.join(", ");
+          diagnostics.push(makeDiag(
+            macro.range,
+            DiagnosticCode.InvalidChildren,
+            `Invalid: {${macro.name}} can only be inside {${parentList}}`
+          ));
+        }
+      }
+    } else {
+      const widget = workspace.widgets.getWidget(macro.name);
+      if (!widget && macro.open) {
+        diagnostics.push(makeDiag(
+          macro.range,
+          DiagnosticCode.UndefinedMacro,
+          `Unrecognized macro: {${macro.name}}`
+        ));
+      }
+    }
+  }
+}
+function isInsideParent(macros, index, parents, workspace) {
+  const parentSet = new Set(parents.map((p) => p.toLowerCase()));
+  for (let i = index - 1; i >= 0; i--) {
+    const candidate = macros[i];
+    if (!candidate.open) continue;
+    const candidateInfo = workspace.macros.getMacro(candidate.name);
+    if (!candidateInfo?.block) continue;
+    if (candidate.pair !== -1 && candidate.pair > index) {
+      if (parentSet.has(candidate.name.toLowerCase())) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function validateChildren(macros, curIndex, parentMacro, childConstraints, workspace, diagnostics) {
+  const children = /* @__PURE__ */ Object.create(null);
+  const startIndex = curIndex + 1;
+  const endIndex = parentMacro.pair;
+  for (let i = startIndex; i < endIndex; i++) {
+    const child = macros[i];
+    const childInfo = workspace.macros.getMacro(child.name);
+    if (!childInfo) continue;
+    if (childInfo.block && child.open && child.pair !== -1) {
+      i = child.pair;
+      continue;
+    }
+    for (const constraint of childConstraints) {
+      if (constraint.name === child.name) {
+        children[child.name] = (children[child.name] ?? 0) + 1;
+      }
+    }
+  }
+  for (const constraint of childConstraints) {
+    const count = children[constraint.name] ?? 0;
+    if (constraint.max !== void 0 && count > constraint.max) {
+      diagnostics.push(makeDiag(
+        parentMacro.range,
+        DiagnosticCode.ChildMaxExceeded,
+        `Too many {${constraint.name}} in {${parentMacro.name}} (max ${constraint.max}, found ${count})`
+      ));
+    }
+    if (constraint.min !== void 0 && count < constraint.min) {
+      diagnostics.push(makeDiag(
+        parentMacro.range,
+        DiagnosticCode.ChildMinNotMet,
+        `Too few {${constraint.name}} in {${parentMacro.name}} (min ${constraint.min}, found ${count})`
+      ));
+    }
+  }
+}
+function validateArguments(macros, workspace, passageNames, diagnostics) {
+  for (const macro of macros) {
+    if (!macro.open) continue;
+    const info = workspace.macros.getMacro(macro.name);
+    if (!info) continue;
+    if (info.skipArgs) continue;
+    if (!info.parameters) continue;
+    const rawArgs = macro.rawArgs ?? "";
+    const args2 = lexArguments(rawArgs);
+    const params = new Parameters(info.parameters);
+    if (params.isEmpty()) {
+      if (args2.length > 0) {
+        diagnostics.push(makeDiag(
+          macro.range,
+          DiagnosticCode.ExpectedNoArguments,
+          `Expected no arguments for {${macro.name}}, got ${args2.length}`
+        ));
+      }
+      continue;
+    }
+    const stateInfo = { passages: Array.from(passageNames) };
+    const result = params.validate(args2, stateInfo);
+    if (result.variantIndex === null) {
+      continue;
+    }
+    for (const error of result.errors) {
+      if (error.message.startsWith("Too many arguments")) {
+        diagnostics.push(makeDiag(
+          macro.range,
+          DiagnosticCode.TooManyArguments,
+          `{${macro.name}}: ${error.message}`
+        ));
+      } else {
+        diagnostics.push(makeDiag(
+          macro.range,
+          DiagnosticCode.ParameterTypeError,
+          `{${macro.name}}: ${error.message}`
+        ));
+      }
+    }
+    for (const warning of result.warnings) {
+      diagnostics.push(makeDiag(
+        macro.range,
+        DiagnosticCode.ParameterWarning,
+        `{${macro.name}}: ${warning.message}`
+      ));
+    }
+  }
+}
+function validateVariables(uri, workspace, diagnostics) {
+  if (!workspace.variables.hasStoryVariables()) {
+    const undeclared2 = workspace.variables.getUndeclared(uri);
+    const text = workspace.documents.getText(uri);
+    if (text && /\$[A-Za-z_$]/.test(text)) {
+      const passages = workspace.passages.getPassagesInDocument(uri);
+      const hasVarUsage = passages.some((p) => {
+        const excluded = /* @__PURE__ */ new Set(["StoryVariables", "StoryInit", "StoryData", "StoryScript", "StoryInterface"]);
+        return !excluded.has(p.name) && !p.tags?.includes("script") && !p.tags?.includes("stylesheet");
+      });
+      if (hasVarUsage) {
+        diagnostics.push(makeDiag(
+          passages[0].range,
+          DiagnosticCode.NoStoryVariables,
+          "No StoryVariables passage found. Declare all story variables with default values in a StoryVariables passage."
+        ));
+      }
+    }
+    return;
+  }
+  const undeclared = workspace.variables.getUndeclared(uri);
+  for (const u of undeclared) {
+    diagnostics.push(makeDiag(
+      u.range,
+      DiagnosticCode.UndeclaredVariable,
+      `Variable '$${u.name}' is not declared in StoryVariables`
+    ));
+  }
+}
+function validateLinks(text, passages, passageNames, diagnostics) {
+  const links = parseLinks(text);
+  for (const link of links) {
+    if (!passageNames.has(link.name)) {
+      diagnostics.push(makeDiag(
+        link.range,
+        DiagnosticCode.BrokenPassageLink,
+        `Passage "${link.name}" not found in workspace`
+      ));
+    }
+  }
+}
+function validateWidgetInvocations(macros, workspace, diagnostics) {
+  for (const macro of macros) {
+    if (!macro.open) continue;
+    const info = workspace.macros.getMacro(macro.name);
+    if (info) continue;
+    const widget = workspace.widgets.getWidget(macro.name);
+    if (!widget) continue;
+    const rawArgs = macro.rawArgs ?? "";
+    const argCount = rawArgs.trim() === "" ? 0 : lexArguments(rawArgs).length;
+    const expectedCount = widget.params.length;
+    if (argCount !== expectedCount) {
+      diagnostics.push(makeDiag(
+        macro.range,
+        DiagnosticCode.WidgetArgCountMismatch,
+        `Widget {${macro.name}} expects ${expectedCount} argument(s), got ${argCount}`
+      ));
+    }
+  }
+}
+function makeDiag(range, code, message) {
+  return {
+    range,
+    message,
+    severity: getSeverity(code),
+    code,
+    source: "spindle"
+  };
+}
+function toLspDiagnostic(d) {
+  const severityMap2 = {
+    error: 1,
+    warning: 2,
+    info: 3,
+    hint: 4
+  };
+  return {
+    range: {
+      start: { line: d.range.start.line, character: d.range.start.character },
+      end: { line: d.range.end.line, character: d.range.end.character }
+    },
+    severity: severityMap2[d.severity],
+    code: d.code,
+    source: d.source,
+    message: d.message
+  };
+}
+var diagnosticsPlugin;
+var init_diagnostics = __esm({
+  "src/plugins/diagnostics.ts"() {
+    "use strict";
+    init_diagnostic_codes();
+    init_macro_parser();
+    init_argument_lexer();
+    init_parameter_validator();
+    init_link_parser();
+    diagnosticsPlugin = {
+      id: "diagnostics",
+      capabilities: {},
+      initialize(ctx) {
+        const publishDiagnostics = () => {
+          for (const uri of ctx.workspace.documents.getUris()) {
+            const diags = computeDiagnostics(uri, ctx.workspace);
+            ctx.connection.sendDiagnostics({
+              uri,
+              diagnostics: diags.map((d) => toLspDiagnostic(d))
+            });
+          }
+        };
+        ctx.workspace.on("modelReady", publishDiagnostics);
+        ctx.workspace.on("documentChanged", (uri) => {
+          const diags = computeDiagnostics(uri, ctx.workspace);
+          ctx.connection.sendDiagnostics({
+            uri,
+            diagnostics: diags.map((d) => toLspDiagnostic(d))
+          });
+        });
+      }
+    };
+  }
+});
+// src/core/workspace/config-loader.ts
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { parse as parseYaml } from "yaml";
+function parseConfig(content, format) {
+  if (!content.trim()) {
+    return { macros: {} };
+  }
+  let raw;
+  if (format === "json") {
+    raw = JSON.parse(content);
+  } else {
+    raw = parseYaml(content);
+  }
+  if (typeof raw !== "object" || raw === null) {
+    return { macros: {} };
+  }
+  const obj = raw;
+  return {
+    macros: typeof obj.macros === "object" && obj.macros !== null ? obj.macros : {}
+  };
+}
+function findConfigFile(workspaceRoot) {
+  for (const name of CONFIG_FILENAMES) {
+    const fullPath = join2(workspaceRoot, name);
+    if (existsSync2(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function loadConfigFromDisk(workspaceRoot) {
+  const configPath = findConfigFile(workspaceRoot);
+  if (!configPath) {
+    return { ...EMPTY_CONFIG };
+  }
+  const content = readFileSync3(configPath, "utf-8");
+  const format = configPath.endsWith(".json") ? "json" : "yaml";
+  return parseConfig(content, format);
+}
+var CONFIG_FILENAMES, EMPTY_CONFIG;
+var init_config_loader = __esm({
+  "src/core/workspace/config-loader.ts"() {
+    "use strict";
+    CONFIG_FILENAMES = [
+      "spindle.config.yaml",
+      "spindle.config.yml",
+      "spindle.config.json"
+    ];
+    EMPTY_CONFIG = { macros: {} };
+  }
+});
+// src/cli/reporters/pretty.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function formatPretty(results) {
+  if (results.length === 0) {
+    return `${colors.bold}No problems found${colors.reset}`;
+  }
+  const lines = [];
+  let errorCount = 0;
+  let warningCount = 0;
+  let infoCount = 0;
+  let hintCount = 0;
+  for (const { uri, diagnostics } of results) {
+    let filePath;
+    try {
+      filePath = fileURLToPath2(uri);
+    } catch {
+      filePath = uri;
+    }
+    for (const diag of diagnostics) {
+      const line = diag.range.start.line + 1;
+      const col = diag.range.start.character + 1;
+      const color = severityColors[diag.severity] ?? colors.gray;
+      lines.push(
+        `${colors.bold}${filePath}:${line}:${col}${colors.reset} ${color}${diag.severity}${colors.reset} ${colors.gray}${diag.code}${colors.reset} ${diag.message}`
+      );
+      switch (diag.severity) {
+        case "error":
+          errorCount++;
+          break;
+        case "warning":
+          warningCount++;
+          break;
+        case "info":
+          infoCount++;
+          break;
+        case "hint":
+          hintCount++;
+          break;
+      }
+    }
+  }
+  const total = errorCount + warningCount + infoCount + hintCount;
+  const parts = [];
+  if (errorCount > 0) parts.push(`${errorCount} error${errorCount !== 1 ? "s" : ""}`);
+  if (warningCount > 0) parts.push(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`);
+  if (infoCount > 0) parts.push(`${infoCount} info`);
+  if (hintCount > 0) parts.push(`${hintCount} hint${hintCount !== 1 ? "s" : ""}`);
+  lines.push("");
+  lines.push(
+    `${colors.bold}Found ${total} problem${total !== 1 ? "s" : ""} (${parts.join(", ")})${colors.reset}`
+  );
+  return lines.join("\n");
+}
+var colors, severityColors;
+var init_pretty = __esm({
+  "src/cli/reporters/pretty.ts"() {
+    "use strict";
+    colors = {
+      red: "\x1B[31m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      cyan: "\x1B[36m",
+      gray: "\x1B[90m",
+      reset: "\x1B[0m",
+      bold: "\x1B[1m"
+    };
+    severityColors = {
+      error: colors.red,
+      warning: colors.yellow,
+      info: colors.blue,
+      hint: colors.cyan
+    };
+  }
+});
+// src/cli/reporters/json.ts
+function formatJson(results) {
+  const output = {
+    files: results.map(({ uri, diagnostics }) => ({
+      uri,
+      diagnostics: diagnostics.map((d) => ({
+        range: d.range,
+        message: d.message,
+        severity: d.severity,
+        code: d.code,
+        source: d.source
+      }))
+    }))
+  };
+  return JSON.stringify(output, null, 2);
+}
+var init_json = __esm({
+  "src/cli/reporters/json.ts"() {
+    "use strict";
+  }
+});
+// src/cli/reporters/sarif.ts
+function formatSarif(results) {
+  const ruleIds = /* @__PURE__ */ new Set();
+  for (const { diagnostics } of results) {
+    for (const d of diagnostics) {
+      ruleIds.add(d.code);
+    }
+  }
+  const sarifResults = [];
+  for (const { uri, diagnostics } of results) {
+    for (const d of diagnostics) {
+      sarifResults.push({
+        ruleId: d.code,
+        level: sarifLevelMap[d.severity] ?? "note",
+        message: { text: d.message },
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: { uri },
+              region: {
+                startLine: d.range.start.line + 1,
+                startColumn: d.range.start.character + 1,
+                endLine: d.range.end.line + 1,
+                endColumn: d.range.end.character + 1
+              }
+            }
+          }
+        ]
+      });
+    }
+  }
+  const sarif = {
+    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "spindle-lsp",
+            version: "0.1.0",
+            rules: Array.from(ruleIds).map((id) => ({
+              id,
+              shortDescription: { text: `Spindle diagnostic ${id}` }
+            }))
+          }
+        },
+        results: sarifResults
+      }
+    ]
+  };
+  return JSON.stringify(sarif, null, 2);
+}
+var sarifLevelMap;
+var init_sarif = __esm({
+  "src/cli/reporters/sarif.ts"() {
+    "use strict";
+    sarifLevelMap = {
+      error: "error",
+      warning: "warning",
+      info: "note",
+      hint: "note"
+    };
+  }
+});
+// src/cli/check.ts
+var check_exports = {};
+__export(check_exports, {
+  runCheck: () => runCheck
+});
+import { readFileSync as readFileSync4 } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { glob } from "glob";
+function parseArgs(args2) {
+  const options = {
+    format: "pretty",
+    severity: null,
+    configPath: null,
+    patterns: []
+  };
+  let i = 0;
+  while (i < args2.length) {
+    const arg = args2[i];
+    if (arg === "--format" && i + 1 < args2.length) {
+      const fmt = args2[i + 1];
+      if (fmt === "pretty" || fmt === "json" || fmt === "sarif") {
+        options.format = fmt;
+      }
+      i += 2;
+    } else if (arg.startsWith("--format=")) {
+      const fmt = arg.slice("--format=".length);
+      if (fmt === "pretty" || fmt === "json" || fmt === "sarif") {
+        options.format = fmt;
+      }
+      i++;
+    } else if (arg === "--severity" && i + 1 < args2.length) {
+      const sev = args2[i + 1];
+      if (sev === "error" || sev === "warning" || sev === "info" || sev === "hint") {
+        options.severity = sev;
+      }
+      i += 2;
+    } else if (arg.startsWith("--severity=")) {
+      const sev = arg.slice("--severity=".length);
+      if (sev === "error" || sev === "warning" || sev === "info" || sev === "hint") {
+        options.severity = sev;
+      }
+      i++;
+    } else if (arg === "--config" && i + 1 < args2.length) {
+      options.configPath = args2[i + 1];
+      i += 2;
+    } else if (arg.startsWith("--config=")) {
+      options.configPath = arg.slice("--config=".length);
+      i++;
+    } else if (!arg.startsWith("--")) {
+      options.patterns.push(arg);
+      i++;
+    } else {
+      i++;
+    }
+  }
+  if (options.patterns.length === 0) {
+    options.patterns = ["**/*.{tw,twee}"];
+  }
+  return options;
+}
+function filterBySeverity(diagnostics, minSeverity) {
+  const minIdx = SEVERITY_ORDER.indexOf(minSeverity);
+  return diagnostics.filter((d) => {
+    const idx = SEVERITY_ORDER.indexOf(d.severity);
+    return idx >= minIdx;
+  });
+}
+async function runCheck(args2) {
+  const options = parseArgs(args2);
+  const cwd = process.cwd();
+  const files = [];
+  for (const pattern of options.patterns) {
+    const matches = await glob(pattern, {
+      cwd,
+      absolute: true,
+      nodir: true
+    });
+    files.push(...matches);
+  }
+  const uniqueFiles = [...new Set(files)];
+  if (uniqueFiles.length === 0) {
+    if (options.format === "pretty") {
+      console.log("No files found");
+    } else if (options.format === "json") {
+      console.log(JSON.stringify({ files: [] }, null, 2));
+    } else {
+      console.log(formatSarif([]));
+    }
+    return 0;
+  }
+  const configRoot = options.configPath ? resolve(cwd, options.configPath, "..") : cwd;
+  const projectConfig = loadConfigFromDisk(configRoot);
+  const workspace = new WorkspaceModel();
+  const fileContents = /* @__PURE__ */ new Map();
+  for (const filePath of uniqueFiles) {
+    try {
+      const text = readFileSync4(filePath, "utf-8");
+      const uri = pathToFileURL2(filePath).toString();
+      fileContents.set(uri, text);
+    } catch {
+    }
+  }
+  workspace.initialize(fileContents);
+  if (Object.keys(projectConfig.macros).length > 0) {
+    workspace.macros.loadSupplements(projectConfig.macros);
+  }
+  const allResults = [];
+  let hasErrors = false;
+  for (const uri of fileContents.keys()) {
+    let diags = computeDiagnostics(uri, workspace);
+    if (options.severity) {
+      diags = filterBySeverity(diags, options.severity);
+    }
+    if (diags.length > 0) {
+      allResults.push({ uri, diagnostics: diags });
+      if (diags.some((d) => d.severity === "error")) {
+        hasErrors = true;
+      }
+    }
+  }
+  switch (options.format) {
+    case "pretty":
+      console.log(formatPretty(allResults));
+      break;
+    case "json":
+      console.log(formatJson(allResults));
+      break;
+    case "sarif":
+      console.log(formatSarif(allResults));
+      break;
+  }
+  workspace.dispose();
+  return hasErrors ? 1 : 0;
+}
+var SEVERITY_ORDER;
+var init_check = __esm({
+  "src/cli/check.ts"() {
+    "use strict";
+    init_workspace_model();
+    init_diagnostics();
+    init_config_loader();
+    init_pretty();
+    init_json();
+    init_sarif();
+    SEVERITY_ORDER = ["hint", "info", "warning", "error"];
+  }
+});
+// src/plugins/format.ts
+function formatDocument(text) {
+  const lines = text.split("\n");
+  const result = [];
+  let indentLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    line = line.replace(/\s+$/, "");
+    if (PASSAGE_HEADER_REGEX.test(line)) {
+      line = normalizePassageHeader(line);
+      indentLevel = 0;
+      result.push(line);
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      result.push("");
+      continue;
+    }
+    if (BLOCK_CLOSE_REGEX.test(trimmed)) {
+      indentLevel = Math.max(0, indentLevel - 1);
+    }
+    const indented = indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed;
+    result.push(indented);
+    if (BLOCK_OPEN_REGEX.test(trimmed)) {
+      indentLevel++;
+    }
+  }
+  let output = result.join("\n");
+  output = output.replace(/\n*$/, "\n");
+  return output;
+}
+function formatRange(text, range) {
+  const lines = text.split("\n");
+  const startLine = Math.max(0, range.start.line);
+  const endLine = Math.min(lines.length - 1, range.end.line);
+  const rangeLines = lines.slice(startLine, endLine + 1);
+  const rangeText = rangeLines.join("\n");
+  const formatted = formatDocument(rangeText);
+  const formattedLines = formatted.replace(/\n$/, "").split("\n");
+  const before = lines.slice(0, startLine);
+  const after = lines.slice(endLine + 1);
+  const result = [...before, ...formattedLines, ...after].join("\n");
+  return result;
+}
+function normalizePassageHeader(line) {
+  const headerMatch = line.match(/^::\s+(.*)/);
+  if (!headerMatch) return line;
+  const rest = headerMatch[1];
+  const bracketIdx = rest.indexOf("[");
+  const braceIdx = rest.indexOf("{");
+  let name;
+  let suffix = "";
+  if (bracketIdx !== -1 && (braceIdx === -1 || bracketIdx < braceIdx)) {
+    name = rest.substring(0, bracketIdx).trim();
+    suffix = " " + rest.substring(bracketIdx).trim();
+  } else if (braceIdx !== -1) {
+    name = rest.substring(0, braceIdx).trim();
+    suffix = " " + rest.substring(braceIdx).trim();
+  } else {
+    name = rest.trim();
+  }
+  return `:: ${name}${suffix}`;
+}
+var BLOCK_OPEN_REGEX, BLOCK_CLOSE_REGEX, PASSAGE_HEADER_REGEX, formatPlugin;
+var init_format = __esm({
+  "src/plugins/format.ts"() {
+    "use strict";
+    BLOCK_OPEN_REGEX = /^\s*\{(if|for|switch|unless|widget)\b/i;
+    BLOCK_CLOSE_REGEX = /^\s*\{\/(if|for|switch|unless|widget)\b/i;
+    PASSAGE_HEADER_REGEX = /^(::)\s+/;
+    formatPlugin = {
+      id: "format",
+      capabilities: {
+        documentFormattingProvider: true,
+        documentRangeFormattingProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onDocumentFormatting((params) => {
+          const text = ctx.workspace.documents.getText(params.textDocument.uri);
+          if (text === void 0) return [];
+          const formatted = formatDocument(text);
+          if (formatted === text) return [];
+          const lines = text.split("\n");
+          return [{
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: lines.length - 1, character: lines[lines.length - 1].length }
+            },
+            newText: formatted
+          }];
+        });
+        ctx.connection.onDocumentRangeFormatting((params) => {
+          const text = ctx.workspace.documents.getText(params.textDocument.uri);
+          if (text === void 0) return [];
+          const range = {
+            start: { line: params.range.start.line, character: params.range.start.character },
+            end: { line: params.range.end.line, character: params.range.end.character }
+          };
+          const formatted = formatRange(text, range);
+          if (formatted === text) return [];
+          const lines = text.split("\n");
+          return [{
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: lines.length - 1, character: lines[lines.length - 1].length }
+            },
+            newText: formatted
+          }];
+        });
+      }
+    };
+  }
+});
+// src/cli/format.ts
+var format_exports = {};
+__export(format_exports, {
+  runFormat: () => runFormat
+});
+import { readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { glob as glob2 } from "glob";
+function parseArgs2(args2) {
+  const options = {
+    check: false,
+    patterns: []
+  };
+  for (const arg of args2) {
+    if (arg === "--check") {
+      options.check = true;
+    } else if (!arg.startsWith("--")) {
+      options.patterns.push(arg);
+    }
+  }
+  if (options.patterns.length === 0) {
+    options.patterns = ["**/*.{tw,twee}"];
+  }
+  return options;
+}
+async function runFormat(args2) {
+  const options = parseArgs2(args2);
+  const cwd = process.cwd();
+  const files = [];
+  for (const pattern of options.patterns) {
+    const matches = await glob2(pattern, {
+      cwd,
+      absolute: true,
+      nodir: true
+    });
+    files.push(...matches);
+  }
+  const uniqueFiles = [...new Set(files)];
+  if (uniqueFiles.length === 0) {
+    console.log("No files found");
+    return 0;
+  }
+  const unformatted = [];
+  for (const filePath of uniqueFiles) {
+    try {
+      const text = readFileSync5(filePath, "utf-8");
+      const formatted = formatDocument(text);
+      if (formatted !== text) {
+        if (options.check) {
+          const relative = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+          unformatted.push(relative);
+        } else {
+          writeFileSync(filePath, formatted, "utf-8");
+        }
+      }
+    } catch {
+    }
+  }
+  if (options.check) {
+    if (unformatted.length > 0) {
+      for (const file of unformatted) {
+        console.log(file);
+      }
+      console.log(`
+${unformatted.length} file${unformatted.length !== 1 ? "s" : ""} would be reformatted`);
+      return 1;
+    }
+    return 0;
+  }
+  return 0;
+}
+var init_format2 = __esm({
+  "src/cli/format.ts"() {
+    "use strict";
+    init_format();
+  }
+});
+// src/core/plugin/plugin-loader.ts
+function loadPlugins(allPlugins2, config) {
+  const disabled = new Set(config.disabledPlugins ?? []);
+  return allPlugins2.filter((p) => !disabled.has(p.id));
+}
+function mergeCapabilities(plugins) {
+  const merged = {};
+  for (const plugin of plugins) {
+    for (const [key, value] of Object.entries(plugin.capabilities)) {
+      const existing = merged[key];
+      if (existing === void 0) {
+        merged[key] = value;
+      } else if (typeof existing === "object" && existing !== null && typeof value === "object" && value !== null && !Array.isArray(existing) && !Array.isArray(value)) {
+        merged[key] = { ...existing, ...value };
+      } else {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+var init_plugin_loader = __esm({
+  "src/core/plugin/plugin-loader.ts"() {
+    "use strict";
+  }
+});
+// src/server/capabilities.ts
+import { TextDocumentSyncKind } from "vscode-languageserver";
+function buildCapabilities(plugins) {
+  const pluginCaps = mergeCapabilities(plugins);
+  return {
+    textDocumentSync: TextDocumentSyncKind.Incremental,
+    ...pluginCaps
+  };
+}
+var init_capabilities = __esm({
+  "src/server/capabilities.ts"() {
+    "use strict";
+    init_plugin_loader();
+  }
+});
+// src/plugins/completions.ts
+function getCompletions(uri, position, triggerChar, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return [];
+  const lineText = lines[position.line].substring(0, position.character);
+  if (/\{\/[A-Za-z\w-]*$/.test(lineText)) {
+    return getClosingMacroCompletions(text, position, workspace);
+  }
+  const dotPathMatch = /\$([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)?$/.exec(lineText);
+  if (dotPathMatch) {
+    return getDotPathCompletions(dotPathMatch[1], workspace);
+  }
+  if (/\$[A-Za-z_$]?[\w$]*$/.test(lineText) && !/\$[A-Za-z_$][\w$]*\./.test(lineText)) {
+    return getStoryVariableCompletions(workspace);
+  }
+  if (/_[A-Za-z_$]?[\w$]*$/.test(lineText)) {
+    return getTempVariableCompletions(text);
+  }
+  if (/@[A-Za-z_$]?[\w$]*$/.test(lineText)) {
+    return getLocalVariableCompletions(text);
+  }
+  if (/\[\[[^\]]*$/.test(lineText)) {
+    return getPassageNameCompletions(workspace);
+  }
+  if (/(?:^|[^\\])\{[A-Za-z\w-]*$/.test(lineText)) {
+    return getMacroCompletions(workspace);
+  }
+  return [];
+}
+function getClosingMacroCompletions(text, position, workspace) {
+  const macros = parseMacros(text);
+  pairMacros(macros, (name) => workspace.macros.isBlock(name));
+  const openStack = [];
+  for (const macro of macros) {
+    if (macro.range.start.line > position.line || macro.range.start.line === position.line && macro.range.start.character >= position.character) {
+      break;
+    }
+    if (!macro.open) continue;
+    if (!workspace.macros.isBlock(macro.name)) continue;
+    if (macro.pair === -1) {
+      openStack.push(macro.name);
+    } else {
+      const pairMacro = macros[macro.pair];
+      if (pairMacro && (pairMacro.range.start.line > position.line || pairMacro.range.start.line === position.line && pairMacro.range.start.character > position.character)) {
+        openStack.push(macro.name);
+      }
+    }
+  }
+  if (openStack.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const suggestions = [];
+  for (let i = openStack.length - 1; i >= 0; i--) {
+    const name = openStack[i];
+    if (!seen.has(name)) {
+      seen.add(name);
+      suggestions.push(name);
+    }
+  }
+  return suggestions.map((name, idx) => ({
+    label: `{/${name}}`,
+    kind: 14,
+    // CompletionItemKind.Keyword
+    detail: `Close {${name}}`,
+    sortText: String(idx).padStart(3, "0"),
+    insertText: `{/${name}}`
+  }));
+}
+function getMacroCompletions(workspace) {
+  const items = [];
+  for (const macro of workspace.macros.getAllMacros()) {
+    items.push({
+      label: macro.name,
+      kind: 3,
+      // CompletionItemKind.Function
+      detail: macro.block ? `(container macro) ${macro.name}` : `(macro) ${macro.name}`,
+      documentation: macro.description ?? void 0
+    });
+  }
+  for (const widget of workspace.widgets.getAllWidgets()) {
+    items.push({
+      label: widget.name,
+      kind: 3,
+      // CompletionItemKind.Function
+      detail: `(widget) ${widget.name}`,
+      documentation: widget.params.length > 0 ? `Parameters: ${widget.params.map((p) => `@${p}`).join(", ")}` : void 0
+    });
+  }
+  return items;
+}
+function getStoryVariableCompletions(workspace) {
+  const declared = workspace.variables.getDeclared();
+  if (declared.size === 0) return [];
+  const items = [];
+  for (const [name, decl] of declared) {
+    items.push({
+      label: `$${name}`,
+      kind: 6,
+      // CompletionItemKind.Variable
+      detail: "story variable",
+      insertText: name,
+      documentation: decl.fields && decl.fields.length > 0 ? `Fields: ${decl.fields.join(", ")}` : void 0
+    });
+  }
+  return items;
+}
+function getTempVariableCompletions(text) {
+  const tempVarRegex = /_([A-Za-z_$][\w$]*)/g;
+  const names = /* @__PURE__ */ new Set();
+  let m;
+  while ((m = tempVarRegex.exec(text)) !== null) {
+    names.add(m[1]);
+  }
+  if (names.size === 0) return [];
+  return Array.from(names).map((name) => ({
+    label: `_${name}`,
+    kind: 6,
+    // CompletionItemKind.Variable
+    detail: "temporary variable",
+    insertText: name
+  }));
+}
+function getLocalVariableCompletions(text) {
+  const atVarRegex = /@([A-Za-z_$][\w$]*)/g;
+  const names = /* @__PURE__ */ new Set();
+  let m;
+  while ((m = atVarRegex.exec(text)) !== null) {
+    names.add(m[1]);
+  }
+  if (names.size === 0) return [];
+  return Array.from(names).map((name) => ({
+    label: `@${name}`,
+    kind: 6,
+    // CompletionItemKind.Variable
+    detail: "local/parameter variable",
+    insertText: name
+  }));
+}
+function getDotPathCompletions(varName, workspace) {
+  const declared = workspace.variables.getDeclared();
+  const decl = declared.get(varName);
+  if (!decl || !decl.fields || decl.fields.length === 0) return [];
+  return decl.fields.map((field) => ({
+    label: field,
+    kind: 5,
+    // CompletionItemKind.Field
+    detail: `field of $${varName}`
+  }));
+}
+function getPassageNameCompletions(workspace) {
+  const passages = workspace.passages.getAllPassages();
+  if (passages.length === 0) return [];
+  return passages.map((p) => ({
+    label: p.name,
+    kind: 18,
+    // CompletionItemKind.Reference
+    detail: p.uri
+  }));
+}
+var completionsPlugin;
+var init_completions = __esm({
+  "src/plugins/completions.ts"() {
+    "use strict";
+    init_macro_parser();
+    completionsPlugin = {
+      id: "completions",
+      capabilities: {
+        completionProvider: {
+          triggerCharacters: ["{", "$", "_", "@", "[", "."]
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.onCompletion((params) => {
+          const uri = params.textDocument.uri;
+          const position = {
+            line: params.position.line,
+            character: params.position.character
+          };
+          const triggerChar = params.context?.triggerCharacter;
+          return getCompletions(uri, position, triggerChar, ctx.workspace);
+        });
+      }
+    };
+  }
+});
+// src/plugins/hover.ts
+function getHoverInfo(uri, position, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return null;
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return null;
+  const line = lines[position.line];
+  const macroResult = getMacroHover(line, position, workspace);
+  if (macroResult) return macroResult;
+  const varResult = getVariableHover(line, position, workspace);
+  if (varResult) return varResult;
+  const widgetResult = getWidgetHover(line, position, workspace);
+  if (widgetResult) return widgetResult;
+  return null;
+}
+function getMacroHover(line, position, workspace) {
+  const macroRegex2 = /\{(\/)?(?:(?:[#.][a-zA-Z][\w-]*\s*)*)([A-Za-z][\w-]*)/g;
+  let match;
+  while ((match = macroRegex2.exec(line)) !== null) {
+    const name = match[2];
+    const nameStart = match.index + match[0].indexOf(name);
+    const nameEnd = nameStart + name.length;
+    if (position.character >= nameStart && position.character <= nameEnd) {
+      const info = workspace.macros.getMacro(name);
+      if (info) {
+        const parts = [];
+        parts.push(`**${info.name}** _(${info.block ? "container" : "inline"} macro)_`);
+        if (info.description) {
+          parts.push("", info.description);
+        }
+        if (info.parameters && info.parameters.length > 0) {
+          parts.push("", `Parameters: \`${info.parameters.join(" ")}\``);
+        }
+        return {
+          contents: parts.join("\n"),
+          range: {
+            start: { line: position.line, character: nameStart },
+            end: { line: position.line, character: nameEnd }
+          }
+        };
+      }
+      const widget = workspace.widgets.getWidget(name);
+      if (widget) {
+        return buildWidgetHover(widget, position.line, nameStart, nameEnd);
+      }
+    }
+  }
+  return null;
+}
+function getVariableHover(line, position, workspace) {
+  {
+    const re = /\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+    let match;
+    while ((match = re.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (position.character >= start && position.character <= end) {
+        const baseName = match[1].split(".")[0];
+        const decl = workspace.variables.getDeclared().get(baseName);
+        const typeInfo = decl?.fields && decl.fields.length > 0 ? `
+Fields: ${decl.fields.map((f) => `\`${f}\``).join(", ")}` : "";
+        return {
+          contents: `**Story variable** \`$${match[1]}\`${typeInfo}`,
+          range: {
+            start: { line: position.line, character: start },
+            end: { line: position.line, character: end }
+          }
+        };
+      }
+    }
+  }
+  {
+    const re = /(?<!\w)_([A-Za-z_$][\w$]*)/g;
+    let match;
+    while ((match = re.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (position.character >= start && position.character <= end) {
+        return {
+          contents: `**Temp variable** \`_${match[1]}\``,
+          range: {
+            start: { line: position.line, character: start },
+            end: { line: position.line, character: end }
+          }
+        };
+      }
+    }
+  }
+  {
+    const re = /(?<!\w)@([A-Za-z_$][\w$]*)/g;
+    let match;
+    while ((match = re.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (position.character >= start && position.character <= end) {
+        return {
+          contents: `**Local variable** \`@${match[1]}\``,
+          range: {
+            start: { line: position.line, character: start },
+            end: { line: position.line, character: end }
+          }
+        };
+      }
+    }
+  }
+  return null;
+}
+function getWidgetHover(line, position, workspace) {
+  const re = /\{([A-Za-z_$][\w$]*)/g;
+  let match;
+  while ((match = re.exec(line)) !== null) {
+    const name = match[1];
+    const nameStart = match.index + 1;
+    const nameEnd = nameStart + name.length;
+    if (position.character >= nameStart && position.character <= nameEnd) {
+      const widget = workspace.widgets.getWidget(name);
+      if (widget) {
+        return buildWidgetHover(widget, position.line, nameStart, nameEnd);
+      }
+    }
+  }
+  return null;
+}
+function buildWidgetHover(widget, line, nameStart, nameEnd) {
+  const sig = widget.params.length > 0 ? widget.params.map((p) => `@${p}`).join(", ") : "no parameters";
+  return {
+    contents: `**Widget** \`${widget.name}\`
+Parameters: ${sig}
+Defined in: \`${widget.uri}\``,
+    range: {
+      start: { line, character: nameStart },
+      end: { line, character: nameEnd }
+    }
+  };
+}
+function toLspRange(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var hoverPlugin;
+var init_hover = __esm({
+  "src/plugins/hover.ts"() {
+    "use strict";
+    hoverPlugin = {
+      id: "hover",
+      capabilities: {
+        hoverProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onHover((params) => {
+          const result = getHoverInfo(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            ctx.workspace
+          );
+          if (!result) return null;
+          return {
+            contents: { kind: "markdown", value: result.contents },
+            range: toLspRange(result.range)
+          };
+        });
+      }
+    };
+  }
+});
+// src/plugins/signature.ts
+function getSignatureHelp(uri, position, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return null;
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return null;
+  const lineText = lines[position.line];
+  const textBefore = lineText.substring(0, position.character);
+  const macroMatch = textBefore.match(/\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\s+([^}]*)$/);
+  if (!macroMatch) return null;
+  const macroName = macroMatch[1];
+  const argsBefore = macroMatch[2];
+  const activeParameter = argsBefore.trim() === "" ? 0 : lexArguments(argsBefore).length;
+  const macroInfo = workspace.macros.getMacro(macroName);
+  if (macroInfo && macroInfo.parameters && macroInfo.parameters.length > 0) {
+    const paramLabels = macroInfo.parameters;
+    return {
+      signatures: [{
+        label: `{${macroName} ${paramLabels.join(" ")}}`,
+        documentation: macroInfo.description ?? void 0,
+        parameters: paramLabels.map((p) => ({ label: p }))
+      }],
+      activeSignature: 0,
+      activeParameter
+    };
+  }
+  const widget = workspace.widgets.getWidget(macroName);
+  if (widget && widget.params.length > 0) {
+    const paramLabels = widget.params.map((p) => `@${p}`);
+    return {
+      signatures: [{
+        label: `{${macroName} ${paramLabels.join(", ")}}`,
+        documentation: `Widget defined in: ${widget.uri}`,
+        parameters: paramLabels.map((p) => ({ label: p }))
+      }],
+      activeSignature: 0,
+      activeParameter
+    };
+  }
+  return null;
+}
+var signaturePlugin;
+var init_signature = __esm({
+  "src/plugins/signature.ts"() {
+    "use strict";
+    init_argument_lexer();
+    signaturePlugin = {
+      id: "signature",
+      capabilities: {
+        signatureHelpProvider: {
+          triggerCharacters: [" ", '"', "'"]
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.onSignatureHelp((params) => {
+          const result = getSignatureHelp(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            ctx.workspace
+          );
+          if (!result) return null;
+          const signatures = result.signatures.map((sig) => ({
+            label: sig.label,
+            documentation: sig.documentation,
+            parameters: sig.parameters.map((p) => ({ label: p.label }))
+          }));
+          return {
+            signatures,
+            activeSignature: result.activeSignature,
+            activeParameter: result.activeParameter
+          };
+        });
+      }
+    };
+  }
+});
+// src/plugins/definition.ts
+function getDefinition(uri, position, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return null;
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return null;
+  const line = lines[position.line];
+  const linkResult = getPassageLinkDefinition(text, position, workspace);
+  if (linkResult) return linkResult;
+  const macroPassageResult = getMacroPassageDefinition(line, position, workspace);
+  if (macroPassageResult) return macroPassageResult;
+  const widgetResult = getWidgetDefinition(line, position, workspace);
+  if (widgetResult) return widgetResult;
+  return null;
+}
+function getPassageLinkDefinition(text, position, workspace) {
+  const links = parseLinks(text);
+  for (const link of links) {
+    if (link.range.start.line === position.line && position.character >= link.range.start.character && position.character <= link.range.end.character) {
+      const passage = workspace.passages.getPassage(link.name);
+      if (passage) {
+        return {
+          uri: passage.uri,
+          range: passage.headerEnd
+        };
+      }
+    }
+  }
+  return null;
+}
+function getMacroPassageDefinition(line, position, workspace) {
+  const patterns = [
+    /\{(?:goto|include)\s+"([^"]+)"\s*\}/gi,
+    /\{(?:link|button)\s+"[^"]*"\s+"([^"]+)"\s*\}/gi
+  ];
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(line)) !== null) {
+      const passageName = match[1];
+      const nameStart = match.index + match[0].indexOf(passageName);
+      const nameEnd = nameStart + passageName.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        const passage = workspace.passages.getPassage(passageName);
+        if (passage) {
+          return {
+            uri: passage.uri,
+            range: passage.headerEnd
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+function getWidgetDefinition(line, position, workspace) {
+  const re = /\{([A-Za-z_$][\w$]*)/g;
+  let match;
+  while ((match = re.exec(line)) !== null) {
+    const name = match[1];
+    const nameStart = match.index + 1;
+    const nameEnd = nameStart + name.length;
+    if (position.character >= nameStart && position.character <= nameEnd) {
+      if (workspace.macros.getMacro(name)) continue;
+      const widget = workspace.widgets.getWidget(name);
+      if (widget) {
+        return {
+          uri: widget.uri,
+          range: widget.range
+        };
+      }
+    }
+  }
+  return null;
+}
+function toLspRange2(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var definitionPlugin;
+var init_definition = __esm({
+  "src/plugins/definition.ts"() {
+    "use strict";
+    init_link_parser();
+    definitionPlugin = {
+      id: "definition",
+      capabilities: {
+        definitionProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onDefinition((params) => {
+          const result = getDefinition(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            ctx.workspace
+          );
+          if (!result) return null;
+          return {
+            uri: result.uri,
+            range: toLspRange2(result.range)
+          };
+        });
+      }
+    };
+  }
+});
+// src/plugins/references.ts
+function findReferences(uri, position, workspace, includeDeclaration) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return [];
+  const line = lines[position.line];
+  const passageHeaderRegex2 = /^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/;
+  if (line.trimStart().startsWith("::")) {
+    const headerMatch = passageHeaderRegex2.exec(line);
+    if (headerMatch) {
+      const passageName = headerMatch[1].trim();
+      const nameStart = line.indexOf(passageName);
+      const nameEnd = nameStart + passageName.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        return findPassageReferences(passageName, workspace, includeDeclaration);
+      }
+    }
+  }
+  {
+    const varRegex = /\$([A-Za-z_$][\w$]*)/g;
+    let match;
+    while ((match = varRegex.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (position.character >= start && position.character <= end) {
+        const varName = match[1];
+        return findVariableReferences(varName, workspace, includeDeclaration);
+      }
+    }
+  }
+  {
+    const widgetRegex = /\{([A-Za-z_$][\w$]*)/g;
+    let match;
+    while ((match = widgetRegex.exec(line)) !== null) {
+      const name = match[1];
+      const nameStart = match.index + 1;
+      const nameEnd = nameStart + name.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        if (!workspace.macros.getMacro(name) && workspace.widgets.getWidget(name)) {
+          return findWidgetReferences(name, workspace, includeDeclaration);
+        }
+      }
+    }
+  }
+  {
+    const allPassages = workspace.passages.getAllPassages();
+    const passageNames = new Set(allPassages.map((p) => p.name));
+    const wordRegex = /[A-Za-z_$][\w$\s]*/g;
+    let match;
+    while ((match = wordRegex.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (position.character >= start && position.character <= end) {
+        const word = match[0].trim();
+        if (passageNames.has(word)) {
+          return findPassageReferences(word, workspace, includeDeclaration);
+        }
+      }
+    }
+  }
+  return [];
+}
+function findPassageReferences(passageName, workspace, includeDeclaration) {
+  const locations = [];
+  if (includeDeclaration) {
+    const passage = workspace.passages.getPassage(passageName);
+    if (passage) {
+      locations.push({
+        uri: passage.uri,
+        range: passage.headerEnd
+      });
+    }
+  }
+  const gotoRegex = /\{(?:goto|include)\s+"([^"]+)"\s*\}/gi;
+  const linkMacroRegex = /\{(?:link|button)\s+"[^"]*"\s+"([^"]+)"\s*\}/gi;
+  for (const docUri of workspace.documents.getUris()) {
+    const docText = workspace.documents.getText(docUri);
+    if (!docText) continue;
+    const links = parseLinks(docText);
+    for (const link of links) {
+      if (link.name === passageName) {
+        locations.push({ uri: docUri, range: link.range });
+      }
+    }
+    const lines = docText.split("\n");
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      for (const regex of [gotoRegex, linkMacroRegex]) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+          if (match[1] === passageName) {
+            const nameStart = match.index + match[0].indexOf(match[1]);
+            locations.push({
+              uri: docUri,
+              range: {
+                start: { line: lineNum, character: nameStart },
+                end: { line: lineNum, character: nameStart + match[1].length }
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  return locations;
+}
+function findVariableReferences(varName, workspace, includeDeclaration) {
+  const locations = [];
+  if (includeDeclaration) {
+    const decl = workspace.variables.getDeclared().get(varName);
+    if (decl?.declarationRange && decl.declarationUri) {
+      locations.push({
+        uri: decl.declarationUri,
+        range: decl.declarationRange
+      });
+    }
+  }
+  const usages = workspace.variables.getUsages(varName);
+  for (const u of usages) {
+    locations.push({ uri: u.uri, range: u.range });
+  }
+  return locations;
+}
+function findWidgetReferences(widgetName, workspace, includeDeclaration) {
+  const locations = [];
+  if (includeDeclaration) {
+    const widget = workspace.widgets.getWidget(widgetName);
+    if (widget) {
+      locations.push({ uri: widget.uri, range: widget.range });
+    }
+  }
+  const widgetInvocationRegex = /\{([A-Za-z_$][\w$]*)\b/g;
+  for (const docUri of workspace.documents.getUris()) {
+    const docText = workspace.documents.getText(docUri);
+    if (!docText) continue;
+    const lines = docText.split("\n");
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      if (/\{widget\s+"/i.test(line)) continue;
+      widgetInvocationRegex.lastIndex = 0;
+      let match;
+      while ((match = widgetInvocationRegex.exec(line)) !== null) {
+        if (match[1] === widgetName) {
+          const nameStart = match.index + 1;
+          locations.push({
+            uri: docUri,
+            range: {
+              start: { line: lineNum, character: nameStart },
+              end: { line: lineNum, character: nameStart + widgetName.length }
+            }
+          });
+        }
+      }
+    }
+  }
+  return locations;
+}
+function toLspRange3(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var referencesPlugin;
+var init_references = __esm({
+  "src/plugins/references.ts"() {
+    "use strict";
+    init_link_parser();
+    referencesPlugin = {
+      id: "references",
+      capabilities: {
+        referencesProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onReferences((params) => {
+          const refs = findReferences(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            ctx.workspace,
+            params.context.includeDeclaration
+          );
+          return refs.map((r) => ({
+            uri: r.uri,
+            range: toLspRange3(r.range)
+          }));
+        });
+      }
+    };
+  }
+});
+// src/plugins/rename.ts
+function prepareRename(uri, position, workspace) {
+  const symbol = resolveSymbolAtCursor(uri, position, workspace);
+  if (!symbol) return null;
+  return { range: symbol.range, placeholder: symbol.name };
+}
+function computeRename(uri, position, newName, workspace) {
+  const symbol = resolveSymbolAtCursor(uri, position, workspace);
+  if (!symbol) return /* @__PURE__ */ new Map();
+  const edits = /* @__PURE__ */ new Map();
+  function addEdit(editUri, range, text) {
+    const existing = edits.get(editUri) ?? [];
+    existing.push({ range, newText: text });
+    edits.set(editUri, existing);
+  }
+  switch (symbol.kind) {
+    case "passage": {
+      const refs = findPassageReferences(symbol.name, workspace, true);
+      for (const ref of refs) {
+        addEdit(ref.uri, ref.range, newName);
+      }
+      break;
+    }
+    case "variable": {
+      const bareName = newName.startsWith("$") ? newName.slice(1) : newName;
+      const refs = findVariableReferences(symbol.name, workspace, true);
+      for (const ref of refs) {
+        addEdit(ref.uri, ref.range, bareName);
+      }
+      break;
+    }
+    case "widget": {
+      const invocationRefs = findWidgetReferences(symbol.name, workspace, false);
+      for (const ref of invocationRefs) {
+        addEdit(ref.uri, ref.range, newName);
+      }
+      const widget = workspace.widgets.getWidget(symbol.name);
+      if (widget) {
+        const docText = workspace.documents.getText(widget.uri);
+        if (docText) {
+          const lines = docText.split("\n");
+          const defLine = lines[widget.range.start.line];
+          if (defLine) {
+            const defSlice = defLine.slice(widget.range.start.character);
+            const nameMatch = /\{widget\s+"([^"]+)"/.exec(defSlice);
+            if (nameMatch) {
+              const nameOffsetInSlice = defSlice.indexOf(nameMatch[1]);
+              const nameStart = widget.range.start.character + nameOffsetInSlice;
+              addEdit(widget.uri, {
+                start: { line: widget.range.start.line, character: nameStart },
+                end: { line: widget.range.start.line, character: nameStart + symbol.name.length }
+              }, newName);
+            }
+          }
+        }
+      }
+      break;
+    }
+  }
+  return edits;
+}
+function resolveSymbolAtCursor(uri, position, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return null;
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return null;
+  const line = lines[position.line];
+  const passageHeaderRegex2 = /^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/;
+  if (line.trimStart().startsWith("::")) {
+    const headerMatch = passageHeaderRegex2.exec(line);
+    if (headerMatch) {
+      const passageName = headerMatch[1].trim();
+      const nameStart = line.indexOf(passageName);
+      const nameEnd = nameStart + passageName.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        return {
+          kind: "passage",
+          name: passageName,
+          range: {
+            start: { line: position.line, character: nameStart },
+            end: { line: position.line, character: nameEnd }
+          }
+        };
+      }
+    }
+  }
+  {
+    const varRegex = /\$([A-Za-z_$][\w$]*)/g;
+    let match;
+    while ((match = varRegex.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (position.character >= start && position.character <= end) {
+        return {
+          kind: "variable",
+          name: match[1],
+          range: {
+            start: { line: position.line, character: start },
+            end: { line: position.line, character: end }
+          }
+        };
+      }
+    }
+  }
+  {
+    const widgetDefRegex2 = /\{widget\s+"([^"]+)"/gi;
+    let match;
+    while ((match = widgetDefRegex2.exec(line)) !== null) {
+      const name = match[1];
+      const nameStart = match.index + match[0].indexOf(name);
+      const nameEnd = nameStart + name.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        return {
+          kind: "widget",
+          name,
+          range: {
+            start: { line: position.line, character: nameStart },
+            end: { line: position.line, character: nameEnd }
+          }
+        };
+      }
+    }
+  }
+  {
+    const re = /\{([A-Za-z_$][\w$]*)/g;
+    let match;
+    while ((match = re.exec(line)) !== null) {
+      const name = match[1];
+      const nameStart = match.index + 1;
+      const nameEnd = nameStart + name.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        if (!workspace.macros.getMacro(name) && workspace.widgets.getWidget(name)) {
+          return {
+            kind: "widget",
+            name,
+            range: {
+              start: { line: position.line, character: nameStart },
+              end: { line: position.line, character: nameEnd }
+            }
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+function toLspRange4(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var renamePlugin;
+var init_rename = __esm({
+  "src/plugins/rename.ts"() {
+    "use strict";
+    init_references();
+    renamePlugin = {
+      id: "rename",
+      capabilities: {
+        renameProvider: {
+          prepareProvider: true
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.onPrepareRename((params) => {
+          const result = prepareRename(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            ctx.workspace
+          );
+          if (!result) return null;
+          return {
+            range: toLspRange4(result.range),
+            placeholder: result.placeholder
+          };
+        });
+        ctx.connection.onRenameRequest((params) => {
+          const editsMap = computeRename(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            params.newName,
+            ctx.workspace
+          );
+          const changes = {};
+          for (const [editUri, edits] of editsMap) {
+            changes[editUri] = edits.map((e) => ({
+              range: toLspRange4(e.range),
+              newText: e.newText
+            }));
+          }
+          return { changes };
+        });
+      }
+    };
+  }
+});
+// src/plugins/code-lens.ts
+function computeCodeLenses(uri, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const lines = text.split("\n");
+  const lenses = [];
+  const storyVarsPassage = workspace.passages.getStoryVariables();
+  const isStoryVarsFile = storyVarsPassage && storyVarsPassage.uri === uri;
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    const passageMatch = line.match(/^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/);
+    if (passageMatch) {
+      const passageName = passageMatch[1].trim();
+      if (passageName === "StoryData") continue;
+      const refs = findPassageReferences(passageName, workspace, true);
+      const refCount = Math.max(0, refs.length - 1);
+      lenses.push({
+        range: {
+          start: { line: lineNum, character: 0 },
+          end: { line: lineNum, character: line.length }
+        },
+        command: {
+          title: `${refCount} reference${refCount !== 1 ? "s" : ""}`
+        }
+      });
+      continue;
+    }
+    const widgetMatch = line.match(/\{widget\s+"([^"]+)"/);
+    if (widgetMatch) {
+      const widgetName = widgetMatch[1];
+      const refs = findWidgetReferences(widgetName, workspace, true);
+      const usageCount = Math.max(0, refs.length - 1);
+      lenses.push({
+        range: {
+          start: { line: lineNum, character: 0 },
+          end: { line: lineNum, character: line.length }
+        },
+        command: {
+          title: `${usageCount} usage${usageCount !== 1 ? "s" : ""}`
+        }
+      });
+    }
+    if (isStoryVarsFile) {
+      const varDeclMatch = line.match(/^\$([A-Za-z_$][\w$]*)\s*=/);
+      if (varDeclMatch) {
+        const varName = varDeclMatch[1];
+        const refs = findVariableReferences(varName, workspace, true);
+        const usageCount = Math.max(0, refs.length - 1);
+        lenses.push({
+          range: {
+            start: { line: lineNum, character: 0 },
+            end: { line: lineNum, character: line.length }
+          },
+          command: {
+            title: `${usageCount} usage${usageCount !== 1 ? "s" : ""}`
+          }
+        });
+      }
+    }
+  }
+  return lenses;
+}
+function toLspRange5(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var codeLensPlugin;
+var init_code_lens = __esm({
+  "src/plugins/code-lens.ts"() {
+    "use strict";
+    init_references();
+    codeLensPlugin = {
+      id: "code-lens",
+      capabilities: {
+        codeLensProvider: {
+          resolveProvider: false
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.onCodeLens((params) => {
+          const lenses = computeCodeLenses(params.textDocument.uri, ctx.workspace);
+          return lenses.map((l) => ({
+            range: toLspRange5(l.range),
+            command: {
+              title: l.command.title,
+              command: "spindle.findReferences"
+            }
+          }));
+        });
+      }
+    };
+  }
+});
+// src/plugins/inlay-hints.ts
+function computeInlayHints(uri, range, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const hints = [];
+  addWidgetParamHints(text, range, workspace, hints);
+  addVariableTypeHints(uri, text, range, workspace, hints);
+  return hints;
+}
+function addWidgetParamHints(text, range, workspace, hints) {
+  const allWidgets = workspace.widgets.getAllWidgets();
+  if (allWidgets.length === 0) return;
+  const widgetMap = new Map(allWidgets.map((w) => [w.name, w]));
+  const macros = parseMacros(text);
+  for (const macro of macros) {
+    if (!macro.open) continue;
+    if (macro.range.start.line < range.start.line || macro.range.start.line > range.end.line) continue;
+    const widget = widgetMap.get(macro.name);
+    if (!widget || widget.params.length === 0) continue;
+    if (!macro.rawArgs || macro.rawArgs.trim() === "") continue;
+    const args2 = lexArguments(macro.rawArgs);
+    const lines = text.split("\n");
+    const macroLine = lines[macro.range.start.line];
+    if (!macroLine) continue;
+    const macroText = macroLine.substring(macro.range.start.character, macro.range.end.character);
+    const nameEnd = macroText.indexOf(macro.name) + macro.name.length;
+    const argsText = macroText.substring(nameEnd).replace(/^\s+/, "").replace(/\}$/, "");
+    if (!argsText) continue;
+    for (let i = 0; i < Math.min(args2.length, widget.params.length); i++) {
+      const argText = args2[i].text;
+      const idx = macroLine.indexOf(argText, macro.range.start.character + nameEnd);
+      if (idx >= 0) {
+        hints.push({
+          position: { line: macro.range.start.line, character: idx },
+          label: `@${widget.params[i]}:`,
+          kind: "parameter"
+        });
+      }
+    }
+  }
+}
+function addVariableTypeHints(uri, text, range, workspace, hints) {
+  const storyVarsPassage = workspace.passages.getStoryVariables();
+  if (!storyVarsPassage) return;
+  if (storyVarsPassage.uri !== uri) return;
+  const lines = text.split("\n");
+  const startLine = Math.max(range.start.line, 0);
+  const endLine = Math.min(range.end.line, lines.length - 1);
+  for (let lineNum = startLine; lineNum <= endLine; lineNum++) {
+    const line = lines[lineNum];
+    const declMatch = line.match(/^\$([A-Za-z_$][\w$]*)\s*=\s*(.+)$/);
+    if (!declMatch) continue;
+    const valueStr = declMatch[2].trim();
+    const inferredType = inferType(valueStr);
+    if (!inferredType) continue;
+    const eqIdx = line.indexOf("=");
+    hints.push({
+      position: { line: lineNum, character: eqIdx },
+      label: `: ${inferredType}`,
+      kind: "type"
+    });
+  }
+}
+function inferType(value) {
+  if (/^\d+(\.\d+)?$/.test(value)) return "number";
+  if (/^"[^"]*"$/.test(value) || /^'[^']*'$/.test(value)) return "string";
+  if (/^\[/.test(value)) return "array";
+  if (/^\{/.test(value)) return "object";
+  if (value === "true" || value === "false") return "boolean";
+  if (value === "null") return "null";
+  if (value === "undefined") return "undefined";
+  return null;
+}
+var inlayHintsPlugin;
+var init_inlay_hints = __esm({
+  "src/plugins/inlay-hints.ts"() {
+    "use strict";
+    init_macro_parser();
+    init_argument_lexer();
+    inlayHintsPlugin = {
+      id: "inlay-hints",
+      capabilities: {
+        inlayHintProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.languages.inlayHint.on((params) => {
+          const range = {
+            start: { line: params.range.start.line, character: params.range.start.character },
+            end: { line: params.range.end.line, character: params.range.end.character }
+          };
+          const hints = computeInlayHints(params.textDocument.uri, range, ctx.workspace);
+          return hints.map((h) => ({
+            position: { line: h.position.line, character: h.position.character },
+            label: h.label,
+            kind: h.kind === "type" ? 1 : 2,
+            paddingRight: h.kind === "parameter",
+            paddingLeft: h.kind === "type"
+          }));
+        });
+      }
+    };
+  }
+});
+// src/plugins/semantic-tokens.ts
+function encodeType(type) {
+  return tokenTypeIndex.get(type) ?? 0;
+}
+function encodeModifiers(modifiers) {
+  let bits = 0;
+  for (const m of modifiers) {
+    const idx = tokenModifierIndex.get(m);
+    if (idx !== void 0) bits |= 1 << idx;
+  }
+  return bits;
+}
+function computeSemanticTokensAbsolute(uri, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const lines = text.split("\n");
+  const tokens = [];
+  const headerLines = /* @__PURE__ */ new Set();
+  const passages = workspace.passages.getPassagesInDocument(uri);
+  for (const passage of passages) {
+    const headerLine = passage.headerEnd.start.line;
+    headerLines.add(headerLine);
+    const rawLine = lines[headerLine] ?? "";
+    tokens.push({
+      line: headerLine,
+      startChar: 0,
+      length: 2,
+      tokenType: encodeType("namespace"),
+      tokenModifiers: 0
+    });
+    const nameMatch = rawLine.match(/^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/);
+    if (nameMatch) {
+      const name = nameMatch[1].trim();
+      const nameStart = rawLine.indexOf(name);
+      tokens.push({
+        line: headerLine,
+        startChar: nameStart,
+        length: name.length,
+        tokenType: encodeType("namespace"),
+        tokenModifiers: encodeModifiers(["declaration"])
+      });
+    }
+  }
+  const macros = parseMacros(text);
+  for (const macro of macros) {
+    const macroLine = macro.range.start.line;
+    const macroChar = macro.range.start.character;
+    if (headerLines.has(macroLine)) continue;
+    const isDefined = !!workspace.macros.getMacro(macro.name);
+    let nameOffset = 1;
+    if (!macro.open) nameOffset += 1;
+    if (macro.cssPrefix) nameOffset += macro.cssPrefix.length + 1;
+    tokens.push({
+      line: macroLine,
+      startChar: macroChar + nameOffset,
+      length: macro.name.length,
+      tokenType: encodeType("function"),
+      tokenModifiers: encodeModifiers(isDefined ? ["defaultLibrary"] : [])
+    });
+  }
+  const storyVarRegex = /(?<!\w)\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+  const tempVarRegex = /(?<!\w)_([A-Za-z_$][\w$]*)/g;
+  const localVarRegex = /(?<!\w)@([A-Za-z_$][\w$]*)/g;
+  const sugarKeywordRegex = /\b(to|is|isnot|eq|neq|gt|gte|lt|lte|and|or|not|def|ndef)\b/g;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    if (headerLines.has(lineIndex)) continue;
+    const line = lines[lineIndex];
+    storyVarRegex.lastIndex = 0;
+    let m;
+    while ((m = storyVarRegex.exec(line)) !== null) {
+      tokens.push({
+        line: lineIndex,
+        startChar: m.index,
+        length: m[0].length,
+        tokenType: encodeType("variable"),
+        tokenModifiers: encodeModifiers(["global"])
+      });
+    }
+    tempVarRegex.lastIndex = 0;
+    while ((m = tempVarRegex.exec(line)) !== null) {
+      tokens.push({
+        line: lineIndex,
+        startChar: m.index,
+        length: m[0].length,
+        tokenType: encodeType("variable"),
+        tokenModifiers: encodeModifiers(["local"])
+      });
+    }
+    localVarRegex.lastIndex = 0;
+    while ((m = localVarRegex.exec(line)) !== null) {
+      tokens.push({
+        line: lineIndex,
+        startChar: m.index,
+        length: m[0].length,
+        tokenType: encodeType("variable"),
+        tokenModifiers: encodeModifiers(["readonly"])
+      });
+    }
+    sugarKeywordRegex.lastIndex = 0;
+    while ((m = sugarKeywordRegex.exec(line)) !== null) {
+      tokens.push({
+        line: lineIndex,
+        startChar: m.index,
+        length: m[0].length,
+        tokenType: encodeType("keyword"),
+        tokenModifiers: 0
+      });
+    }
+  }
+  tokens.sort((a, b) => a.line - b.line || a.startChar - b.startChar);
+  return tokens;
+}
+function encodeTokens(absoluteTokens) {
+  const data = [];
+  let prevLine = 0;
+  let prevChar = 0;
+  for (const token of absoluteTokens) {
+    const deltaLine = token.line - prevLine;
+    const deltaStart = deltaLine === 0 ? token.startChar - prevChar : token.startChar;
+    data.push(deltaLine, deltaStart, token.length, token.tokenType, token.tokenModifiers);
+    prevLine = token.line;
+    prevChar = token.startChar;
+  }
+  return data;
+}
+function computeSemanticTokens(uri, workspace) {
+  const absoluteTokens = computeSemanticTokensAbsolute(uri, workspace);
+  return encodeTokens(absoluteTokens);
+}
+var tokenTypesLegend, tokenModifiersLegend, tokenTypeIndex, tokenModifierIndex, semanticTokensPlugin;
+var init_semantic_tokens = __esm({
+  "src/plugins/semantic-tokens.ts"() {
+    "use strict";
+    init_macro_parser();
+    tokenTypesLegend = [
+      "function",
+      "variable",
+      "parameter",
+      "property",
+      "keyword",
+      "string",
+      "number",
+      "comment",
+      "namespace",
+      "type",
+      "macro",
+      "regexp"
+    ];
+    tokenModifiersLegend = [
+      "declaration",
+      "defaultLibrary",
+      "global",
+      "local",
+      "readonly"
+    ];
+    tokenTypeIndex = new Map(
+      tokenTypesLegend.map((t, i) => [t, i])
+    );
+    tokenModifierIndex = new Map(
+      tokenModifiersLegend.map((m, i) => [m, i])
+    );
+    semanticTokensPlugin = {
+      id: "semantic-tokens",
+      capabilities: {
+        semanticTokensProvider: {
+          full: true,
+          legend: {
+            tokenTypes: tokenTypesLegend,
+            tokenModifiers: tokenModifiersLegend
+          }
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.languages.semanticTokens.on((params) => {
+          const data = computeSemanticTokens(params.textDocument.uri, ctx.workspace);
+          return { data };
+        });
+      }
+    };
+  }
+});
+// src/plugins/code-actions.ts
+function computeCodeActions(uri, diagnostics, workspace) {
+  const actions = [];
+  for (const diag of diagnostics) {
+    switch (diag.code) {
+      case DiagnosticCode.UndefinedMacro: {
+        const action = fixUndefinedMacro(diag);
+        if (action) actions.push(action);
+        break;
+      }
+      case DiagnosticCode.UndeclaredVariable: {
+        const action = fixUndeclaredVariable(diag, workspace);
+        if (action) actions.push(action);
+        break;
+      }
+      case DiagnosticCode.NoStoryVariables: {
+        const action = fixNoStoryVariables(uri, workspace);
+        if (action) actions.push(action);
+        break;
+      }
+    }
+  }
+  return actions;
+}
+function fixUndefinedMacro(diag) {
+  const match = diag.message.match(/\{(\w[\w-]*)\}/);
+  if (!match) return null;
+  const macroName = match[1];
+  const configUri = "file:///spindle.config.yaml";
+  const yamlSnippet = `
+  ${macroName}:
+    description: ""
+`;
+  return {
+    title: `Add '${macroName}' to spindle.config.yaml`,
+    kind: "quickfix",
+    diagnosticCodes: [DiagnosticCode.UndefinedMacro],
+    edits: [{
+      uri: configUri,
+      range: {
+        start: { line: Number.MAX_SAFE_INTEGER, character: 0 },
+        end: { line: Number.MAX_SAFE_INTEGER, character: 0 }
+      },
+      newText: yamlSnippet
+    }]
+  };
+}
+function fixUndeclaredVariable(diag, workspace) {
+  const match = diag.message.match(/'\$(\w+)'/);
+  if (!match) return null;
+  const varName = match[1];
+  const storyVars = workspace.passages.getStoryVariables();
+  if (!storyVars) return null;
+  const storyVarsUri = storyVars.uri;
+  const text = workspace.documents.getText(storyVarsUri);
+  if (text === void 0) return null;
+  const lines = text.split("\n");
+  const contentStart = storyVars.headerEnd.end.line + 1;
+  let contentEnd = lines.length;
+  for (let i = contentStart; i < lines.length; i++) {
+    if (/^::\s+/.test(lines[i])) {
+      contentEnd = i;
+      break;
+    }
+  }
+  const insertLine = contentEnd;
+  return {
+    title: `Declare '$${varName}' in StoryVariables`,
+    kind: "quickfix",
+    diagnosticCodes: [DiagnosticCode.UndeclaredVariable],
+    edits: [{
+      uri: storyVarsUri,
+      range: {
+        start: { line: insertLine, character: 0 },
+        end: { line: insertLine, character: 0 }
+      },
+      newText: `$${varName} = null
+`
+    }]
+  };
+}
+function fixNoStoryVariables(uri, workspace) {
+  const uris = workspace.documents.getUris();
+  const targetUri = uris.length > 0 ? uris[0] : uri;
+  const text = workspace.documents.getText(targetUri);
+  if (text === void 0) return null;
+  const lines = text.split("\n");
+  const lastLine = lines.length;
+  return {
+    title: "Create StoryVariables passage",
+    kind: "quickfix",
+    diagnosticCodes: [DiagnosticCode.NoStoryVariables],
+    edits: [{
+      uri: targetUri,
+      range: {
+        start: { line: lastLine, character: 0 },
+        end: { line: lastLine, character: 0 }
+      },
+      newText: "\n:: StoryVariables\n"
+    }]
+  };
+}
+function toLspRange6(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var codeActionsPlugin;
+var init_code_actions = __esm({
+  "src/plugins/code-actions.ts"() {
+    "use strict";
+    init_diagnostic_codes();
+    codeActionsPlugin = {
+      id: "code-actions",
+      capabilities: {
+        codeActionProvider: {
+          codeActionKinds: ["quickfix"]
+        }
+      },
+      initialize(ctx) {
+        ctx.connection.onCodeAction((params) => {
+          const diagnostics = params.context.diagnostics.filter((d) => d.source === "spindle").map((d) => ({
+            range: {
+              start: { line: d.range.start.line, character: d.range.start.character },
+              end: { line: d.range.end.line, character: d.range.end.character }
+            },
+            message: d.message,
+            severity: d.severity === 1 ? "error" : d.severity === 2 ? "warning" : d.severity === 3 ? "info" : "hint",
+            code: String(d.code ?? ""),
+            source: d.source ?? "spindle"
+          }));
+          const actions = computeCodeActions(
+            params.textDocument.uri,
+            diagnostics,
+            ctx.workspace
+          );
+          return actions.map((a) => ({
+            title: a.title,
+            kind: a.kind,
+            diagnostics: params.context.diagnostics.filter(
+              (d) => a.diagnosticCodes.includes(String(d.code))
+            ),
+            edit: {
+              changes: Object.fromEntries(
+                a.edits.map((e) => [
+                  e.uri,
+                  [{ range: toLspRange6(e.range), newText: e.newText }]
+                ])
+              )
+            }
+          }));
+        });
+      }
+    };
+  }
+});
+// src/plugins/index.ts
+var allPlugins;
+var init_plugins = __esm({
+  "src/plugins/index.ts"() {
+    "use strict";
+    init_diagnostics();
+    init_completions();
+    init_hover();
+    init_signature();
+    init_definition();
+    init_references();
+    init_rename();
+    init_code_lens();
+    init_inlay_hints();
+    init_semantic_tokens();
+    init_code_actions();
+    init_format();
+    allPlugins = [
+      diagnosticsPlugin,
+      completionsPlugin,
+      hoverPlugin,
+      signaturePlugin,
+      definitionPlugin,
+      referencesPlugin,
+      renamePlugin,
+      codeLensPlugin,
+      inlayHintsPlugin,
+      semanticTokensPlugin,
+      codeActionsPlugin,
+      formatPlugin
+    ];
+  }
+});
+// src/server/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+import {
+  createConnection,
+  ProposedFeatures,
+  DidChangeWatchedFilesNotification,
+  FileChangeType
+} from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { glob as glob3 } from "glob";
+function uriToFsPath(uri) {
+  try {
+    return fileURLToPath3(uri);
+  } catch {
+    return uri;
+  }
+}
+function fsPathToUri(fsPath) {
+  return pathToFileURL3(fsPath).toString();
+}
+function startServer(_args) {
+  const connection = createConnection(ProposedFeatures.all);
+  const documents = /* @__PURE__ */ new Map();
+  let workspace;
+  let activePlugins = [];
+  let workspaceRoot;
+  connection.onInitialize((params) => {
+    const initOptions = params.initializationOptions ?? {};
+    workspaceRoot = initOptions.workspaceRoot ?? (params.workspaceFolders?.[0]?.uri ? uriToFsPath(params.workspaceFolders[0].uri) : void 0);
+    const projectConfig = workspaceRoot ? loadConfigFromDisk(workspaceRoot) : { macros: {} };
+    const config = {
+      disabledPlugins: initOptions.disabledPlugins,
+      diagnostics: initOptions.diagnostics,
+      workspaceRoot
+    };
+    workspace = new WorkspaceModel();
+    activePlugins = loadPlugins(allPlugins, config);
+    for (const plugin of activePlugins) {
+      plugin.initialize({ connection, workspace, config });
+    }
+    if (Object.keys(projectConfig.macros).length > 0) {
+      workspace.macros.loadSupplements(projectConfig.macros);
+    }
+    return {
+      capabilities: buildCapabilities(activePlugins)
+    };
+  });
+  connection.onInitialized(async () => {
+    connection.client.register(DidChangeWatchedFilesNotification.type, {
+      watchers: [
+        { globPattern: "**/*.tw" },
+        { globPattern: "**/*.twee" },
+        { globPattern: "**/*.js" },
+        { globPattern: "**/*.ts" },
+        { globPattern: "**/spindle.config.*" }
+      ]
+    });
+    if (workspace) {
+      const fileContents = await scanWorkspaceFiles(workspaceRoot);
+      workspace.initialize(fileContents);
+    }
+  });
+  connection.onDidOpenTextDocument(({ textDocument }) => {
+    const doc = TextDocument.create(
+      textDocument.uri,
+      textDocument.languageId,
+      textDocument.version,
+      textDocument.text
+    );
+    documents.set(textDocument.uri, doc);
+    if (workspace) {
+      workspace.documents.open(textDocument.uri, textDocument.text);
+    }
+  });
+  connection.onDidChangeTextDocument(({ textDocument, contentChanges }) => {
+    const existing = documents.get(textDocument.uri);
+    if (existing) {
+      const updated = TextDocument.update(
+        existing,
+        contentChanges,
+        textDocument.version
+      );
+      documents.set(textDocument.uri, updated);
+      if (workspace) {
+        workspace.documents.update(textDocument.uri, updated.getText());
+      }
+    }
+  });
+  connection.onDidCloseTextDocument(({ textDocument }) => {
+    documents.delete(textDocument.uri);
+    if (workspace) {
+      workspace.documents.close(textDocument.uri);
+    }
+  });
+  connection.onDidChangeWatchedFiles(({ changes }) => {
+    if (!workspace) return;
+    for (const change of changes) {
+      if (change.type === FileChangeType.Deleted) {
+        workspace.documents.close(change.uri);
+        documents.delete(change.uri);
+      } else {
+        try {
+          const fsPath = uriToFsPath(change.uri);
+          const text = readFileSync6(fsPath, "utf-8");
+          if (workspace.documents.has(change.uri)) {
+            workspace.documents.update(change.uri, text);
+          } else {
+            workspace.documents.open(change.uri, text);
+          }
+        } catch {
+        }
+      }
+    }
+  });
+  connection.onShutdown(() => {
+    for (const plugin of activePlugins) {
+      plugin.dispose?.();
+    }
+    workspace?.dispose();
+  });
+  connection.listen();
+}
+async function scanWorkspaceFiles(root) {
+  const contents = /* @__PURE__ */ new Map();
+  if (!root) return contents;
+  try {
+    const files = await glob3("**/*.{tw,twee}", {
+      cwd: root,
+      absolute: true,
+      nodir: true
+    });
+    for (const filePath of files) {
+      try {
+        const text = readFileSync6(filePath, "utf-8");
+        const uri = fsPathToUri(filePath);
+        contents.set(uri, text);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return contents;
+}
+var init_server = __esm({
+  "src/server/server.ts"() {
+    "use strict";
+    init_workspace_model();
+    init_plugin_loader();
+    init_capabilities();
+    init_plugins();
+    init_config_loader();
+  }
+});
+// src/bin.ts
+var args = process.argv.slice(2);
+if (args[0] === "check") {
+  const { runCheck: runCheck2 } = await Promise.resolve().then(() => (init_check(), check_exports));
+  const exitCode = await runCheck2(args.slice(1));
+  process.exit(exitCode);
+} else if (args[0] === "format") {
+  const { runFormat: runFormat2 } = await Promise.resolve().then(() => (init_format2(), format_exports));
+  const exitCode = await runFormat2(args.slice(1));
+  process.exit(exitCode);
+} else {
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  startServer2(args);
+}
+//# sourceMappingURL=bin.js.map