@rohal12/spindle-lsp 0.9.0 → 0.9.2

package/dist/bin.js

@@ -3185,10 +3185,10 @@ var init_esm4 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           this.on(DESTROYED, () => reject(new Error("stream destroyed")));
           this.on("error", (er) => reject(er));
-          this.on("end", () => resolve3());
+          this.on("end", () => resolve4());
         });
       }
       /**
@@ -3212,7 +3212,7 @@ var init_esm4 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve3;
+          let resolve4;
           let reject;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -3226,19 +3226,19 @@ var init_esm4 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve3({ value, done: !!this[EOF] });
+            resolve4({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve3({ done: true, value: void 0 });
+            resolve4({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject = rej;
-            resolve3 = res2;
+            resolve4 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -4226,9 +4226,9 @@ var init_esm5 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve3 = () => {
+          let resolve4 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve3 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve4 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -4241,7 +4241,7 @@ var init_esm5 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve3();
+          resolve4();
         }
         return children.slice(0, children.provisional);
       }
@@ -6303,11 +6303,15 @@ function parsePassageHeader(line, lineNumber) {
     nameRange
   };
 }
-var passageHeaderRegex;
+function isScriptOrStylesheetPassage(passage) {
+  return passage.tags?.some((t) => CODE_PASSAGE_TAGS.has(t)) ?? false;
+}
+var passageHeaderRegex, CODE_PASSAGE_TAGS;
 var init_passage_parser = __esm({
   "src/core/parsing/passage-parser.ts"() {
     "use strict";
     passageHeaderRegex = /^(::\s+)(.*?)(\[.*?\]\s*)?(\{.*?\}\s*)?\r?$/;
+    CODE_PASSAGE_TAGS = /* @__PURE__ */ new Set(["script", "stylesheet"]);
   }
 });
 
@@ -6339,6 +6343,7 @@ var init_passage_index = __esm({
               // will be extended below
             },
             headerEnd: header.headerRange,
+            nameRange: header.nameRange,
             uri,
             tags: header.tags.length > 0 ? header.tags : void 0,
             meta: header.meta
@@ -6434,27 +6439,55 @@ var init_passage_index = __esm({
 
 // src/core/workspace/macro-registry.ts
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, join, parse as parsePath } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
+function findRegistryPath(startDir) {
+  const target = join("node_modules", "@rohal12", "spindle", "dist", "pkg", "macro-registry.json");
+  let dir = resolve(startDir);
+  for (; ; ) {
+    const candidate = join(dir, target);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
 var MacroRegistry;
 var init_macro_registry = __esm({
   "src/core/workspace/macro-registry.ts"() {
     "use strict";
     MacroRegistry = class {
       macros = /* @__PURE__ */ new Map();
+      /** Entries as they were before the current user config was applied (undefined = absent). */
+      configSnapshot = /* @__PURE__ */ new Map();
+      /** Tier 3: macros discovered from Story.defineMacro() calls, keyed by lowercase name. */
+      discovered = /* @__PURE__ */ new Map();
+      /** Tier 4: user config entries, kept so they can be re-applied over discovered macros. */
+      configEntries = /* @__PURE__ */ new Map();
+      /** Warnings collected during loadBuiltins for logging. */
+      warnings = [];
+      /** Path of the macro-registry.json the builtins were loaded from, if any. */
+      builtinsPath = null;
       /**
        * Load built-in macro metadata from @rohal12/spindle's macro-registry.json.
        * This is the base layer that provides name, block, subMacros, flags, source.
+       *
+       * The project's own Spindle is authoritative: the registry is resolved from
+       * `workspaceRoot` first, and from this package's install location (a
+       * development copy, or one installed for the peer dependency) only when the
+       * workspace has none.
        */
-      /** Warnings collected during loadBuiltins for logging. */
-      warnings = [];
-      loadBuiltins() {
+      loadBuiltins(workspaceRoot) {
         let builtinMacros = [];
         try {
           const thisDir = dirname(fileURLToPath3(import.meta.url));
-          const registryPath = this.resolveRegistryPathViaRequire(thisDir) ?? this.resolveRegistryPath(thisDir);
-          if (registryPath) {
+          const registryPath = (workspaceRoot ? findRegistryPath(workspaceRoot) : null) ?? findRegistryPath(thisDir);
+          if (!registryPath) {
+            this.warnings.push(
+              "macro-registry.json not found: install @rohal12/spindle in the project. Continuing with supplements only."
+            );
+          } else {
+            this.builtinsPath = registryPath;
             const raw = readFileSync2(registryPath, "utf-8");
             const parsed = JSON.parse(raw);
             if (!Array.isArray(parsed)) {
@@ -6499,10 +6532,67 @@ var init_macro_registry = __esm({
       /**
        * Overlay user config onto the registry.
        * Same format as supplements; applied last so it wins.
+       *
+       * Replaces any previously loaded config: entries from the last call are
+       * reverted first, so macros removed from the config disappear (or fall
+       * back to their builtin/supplement definition).
        */
       loadConfig(config2) {
+        for (const [key, previous] of this.configSnapshot) {
+          if (previous) {
+            this.macros.set(key, previous);
+          } else {
+            this.macros.delete(key);
+          }
+        }
+        this.configSnapshot.clear();
+        this.configEntries.clear();
+        for (const rawKey of Object.keys(config2)) {
+          const key = rawKey.toLowerCase();
+          if (!this.configSnapshot.has(key)) {
+            const existing = this.macros.get(key);
+            this.configSnapshot.set(key, existing ? { ...existing } : void 0);
+          }
+          this.configEntries.set(key, { ...this.configEntries.get(key), ...config2[rawKey] });
+        }
         this.mergeEntries(config2);
       }
+      /**
+       * Replace the set of macros discovered from Story.defineMacro() calls.
+       * Previously discovered definitions that are no longer present are dropped,
+       * restoring whatever the other tiers define for that name.
+       *
+       * Mirrors Story.defineMacro(): a macro is a block when `block: true`, or
+       * when it declares sub-macros and does not set `block: false`. Each
+       * sub-macro becomes a known macro that may only appear inside its parent.
+       */
+      setDiscoveredMacros(macros) {
+        this.discovered.clear();
+        for (const m of macros) {
+          const subMacros = m.subMacros ?? [];
+          this.discovered.set(m.name.toLowerCase(), {
+            name: m.name,
+            block: m.block === true || m.block !== false && subMacros.length > 0,
+            subMacros,
+            storeVar: m.storeVar,
+            interpolate: m.interpolate,
+            merged: m.merged,
+            description: m.description,
+            source: "user"
+          });
+        }
+        for (const m of macros) {
+          for (const sub of m.subMacros ?? []) {
+            const key = sub.toLowerCase();
+            const existing = this.discovered.get(key);
+            if (existing) {
+              existing.parents = [...existing.parents ?? [], m.name];
+            } else {
+              this.discovered.set(key, { name: sub, block: false, subMacros: [], source: "user", parents: [m.name] });
+            }
+          }
+        }
+      }
       /** Add or replace a single macro entry. */
       addMacro(info) {
         const key = info.name.toLowerCase();
@@ -6524,51 +6614,54 @@ var init_macro_registry = __esm({
       }
       /** Get a macro by name (case-insensitive). */
       getMacro(name) {
-        return this.macros.get(name.toLowerCase());
+        return this.resolve(name.toLowerCase());
       }
       /** Check if a macro is a block (container) macro. */
       isBlock(name) {
-        return this.macros.get(name.toLowerCase())?.block ?? false;
+        return this.getMacro(name)?.block ?? false;
       }
       /** Check if a macro is a sub-macro (has parents). */
       isSubMacro(name) {
-        const info = this.macros.get(name.toLowerCase());
+        const info = this.getMacro(name);
         return info?.parents != null && info.parents.length > 0;
       }
       /** Get all registered macros. */
       getAllMacros() {
-        return Array.from(this.macros.values());
+        const keys = /* @__PURE__ */ new Set([...this.macros.keys(), ...this.discovered.keys()]);
+        return Array.from(keys, (key) => this.resolve(key));
       }
       /**
-       * Walk up directory tree from `startDir` to find the
-       * @rohal12/spindle/dist/pkg/macro-registry.json file.
+       * Compose the effective entry for a lowercase key: builtins/supplements/
+       * config (stored in `macros`), overlaid by discovered metadata, with user
+       * config re-applied on top so it keeps precedence.
        */
-      /**
-       * Resolve macro-registry.json using Node's require resolution.
-       * Works in bundled contexts where import.meta.url may not be near node_modules.
-       */
-      resolveRegistryPathViaRequire(startDir) {
-        try {
-          const require2 = createRequire(join(startDir, "_"));
-          const toolingPath = require2.resolve("@rohal12/spindle/tooling");
-          const candidate = join(dirname(toolingPath), "macro-registry.json");
-          if (existsSync(candidate)) return candidate;
-        } catch {
-        }
-        return null;
-      }
-      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);
+      resolve(key) {
+        const base = this.macros.get(key);
+        const found = this.discovered.get(key);
+        if (!found) return base;
+        const info = {
+          ...base,
+          name: base?.name ?? found.name,
+          block: found.block ?? base?.block ?? false,
+          subMacros: found.subMacros?.length ? found.subMacros : base?.subMacros ?? [],
+          source: "user",
+          storeVar: found.storeVar ?? base?.storeVar,
+          interpolate: found.interpolate ?? base?.interpolate,
+          merged: found.merged ?? base?.merged,
+          description: found.description ?? base?.description,
+          // A discovered sub-macro may also belong to other (e.g. built-in) parents
+          parents: found.parents ? [.../* @__PURE__ */ new Set([...base?.parents ?? [], ...found.parents])] : base?.parents
+        };
+        const config2 = this.configEntries.get(key);
+        if (config2) {
+          if (config2.description !== void 0) info.description = config2.description;
+          if (config2.parameters !== void 0) info.parameters = config2.parameters;
+          if (config2.children !== void 0) info.children = config2.children;
+          if (config2.parents !== void 0) info.parents = config2.parents;
+          if (config2.skipArgs !== void 0) info.skipArgs = config2.skipArgs;
+          if (config2.container !== void 0) info.block = config2.container;
         }
-        return null;
+        return info;
       }
       /** Merge a set of supplement/config entries into the registry. */
       mergeEntries(entries) {
@@ -6647,6 +6740,17 @@ function inferLiteralType(expr) {
   if (first === "{") return "object";
   return "string";
 }
+function declarationLocation(line, name, absLine, uri) {
+  const start = line.length - line.trimStart().length;
+  const location = {
+    declarationRange: {
+      start: { line: absLine, character: start },
+      end: { line: absLine, character: start + 1 + name.length }
+    }
+  };
+  if (uri !== void 0) location.declarationUri = uri;
+  return location;
+}
 var varRefRegex, transientRefRegex, EXCLUDED_PASSAGES, CLEAN_PATTERNS, ARRAY_MEMBERS, VariableTracker;
 var init_variable_tracker = __esm({
   "src/core/workspace/variable-tracker.ts"() {
@@ -6705,7 +6809,7 @@ var init_variable_tracker = __esm({
        * Parse the StoryVariables passage content for declarations.
        * Each line like `$name = value` becomes a declaration.
        */
-      parseStoryVariables(content, contentStartLine = 0) {
+      parseStoryVariables(content, contentStartLine = 0, uri) {
         this.declared.clear();
         this._hasStoryVariables = true;
         this._nullDeclarations = [];
@@ -6717,9 +6821,10 @@ var init_variable_tracker = __esm({
           if (!match2) continue;
           const name = match2[1];
           const expr = match2[2].trim();
+          const absLine = contentStartLine + i;
+          const location = declarationLocation(lines[i], name, absLine, uri);
           if (expr === "null") {
             const charIdx = lines[i].indexOf("null", lines[i].indexOf("="));
-            const absLine = contentStartLine + i;
             this._nullDeclarations.push({
               name,
               sigil: "$",
@@ -6728,10 +6833,10 @@ var init_variable_tracker = __esm({
                 end: { line: absLine, character: charIdx + 4 }
               }
             });
-            this.declared.set(name, { name, sigil: "$" });
+            this.declared.set(name, { name, sigil: "$", ...location });
             continue;
           }
-          const decl = { name, sigil: "$" };
+          const decl = { name, sigil: "$", ...location };
           const type = inferLiteralType(expr);
           if (type) decl.type = type;
           if (expr.startsWith("{")) {
@@ -6748,11 +6853,23 @@ var init_variable_tracker = __esm({
           this.declared.set(name, decl);
         }
       }
+      /** Forget StoryVariables declarations, e.g. after the passage was removed. */
+      clearStoryVariables() {
+        this.declared.clear();
+        this._hasStoryVariables = false;
+        this._nullDeclarations = [];
+      }
+      /** Forget StoryTransients declarations, e.g. after the passage was removed. */
+      clearStoryTransients() {
+        this.declaredTransient.clear();
+        this._hasStoryTransients = false;
+        this._nullTransientDeclarations = [];
+      }
       /**
        * Parse the StoryTransients passage content for declarations.
        * Each line like `%name = value` becomes a declaration.
        */
-      parseStoryTransients(content, contentStartLine = 0) {
+      parseStoryTransients(content, contentStartLine = 0, uri) {
         this.declaredTransient.clear();
         this._hasStoryTransients = true;
         this._nullTransientDeclarations = [];
@@ -6764,9 +6881,10 @@ var init_variable_tracker = __esm({
           if (!match2) continue;
           const name = match2[1];
           const expr = match2[2].trim();
+          const absLine = contentStartLine + i;
+          const location = declarationLocation(lines[i], name, absLine, uri);
           if (expr === "null") {
             const charIdx = lines[i].indexOf("null", lines[i].indexOf("="));
-            const absLine = contentStartLine + i;
             this._nullTransientDeclarations.push({
               name,
               sigil: "%",
@@ -6775,10 +6893,10 @@ var init_variable_tracker = __esm({
                 end: { line: absLine, character: charIdx + 4 }
               }
             });
-            this.declaredTransient.set(name, { name, sigil: "%" });
+            this.declaredTransient.set(name, { name, sigil: "%", ...location });
             continue;
           }
-          const decl = { name, sigil: "%" };
+          const decl = { name, sigil: "%", ...location };
           const type = inferLiteralType(expr);
           if (type) decl.type = type;
           if (expr.startsWith("{")) {
@@ -6809,19 +6927,20 @@ var init_variable_tracker = __esm({
         for (let i = 0; i < lines.length; i++) {
           const header = parsePassageHeader(lines[i], i);
           if (header) {
-            passageBoundaries.push({ name: header.name, startLine: i });
+            passageBoundaries.push({ name: header.name, tags: header.tags, startLine: i });
           }
         }
         for (let pi = 0; pi < passageBoundaries.length; pi++) {
           const passage = passageBoundaries[pi];
           if (EXCLUDED_PASSAGES.has(passage.name)) continue;
+          if (isScriptOrStylesheetPassage(passage)) 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));
+            cleaned = cleaned.replace(pattern, (m) => m.replace(/[^\r\n]/g, " "));
           }
           const lineOffsets = [0];
           for (let i = 0; i < cleaned.length; i++) {
@@ -6976,14 +7095,114 @@ var init_variable_tracker = __esm({
   }
 });
 
+// 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, (match3) => {
+    return " ".repeat(match3.length);
+  });
+  const lineStarts = buildLineStarts(text);
+  const macros = [];
+  let id = 0;
+  macroRegex.lastIndex = 0;
+  let match2;
+  while ((match2 = macroRegex.exec(cleaned)) !== null) {
+    const closeSlash = match2[1];
+    const cssPrefix = (match2[2] || "").trim();
+    const macroName = match2[3];
+    const rawArgs = match2[4];
+    const open = closeSlash !== "/";
+    const matchStart = match2.index;
+    const matchEnd = matchStart + match2[0].length;
+    const startPos = offsetToPosition(matchStart, lineStarts);
+    const endPos = offsetToPosition(matchEnd, lineStarts);
+    const range2 = {
+      start: startPos,
+      end: endPos
+    };
+    macros.push({
+      id,
+      pair: -1,
+      name: macroName,
+      open,
+      range: range2,
+      cssPrefix: cssPrefix || void 0,
+      rawArgs: rawArgs || void 0
+    });
+    id++;
+  }
+  return macros;
+}
+function pairMacros(macros, isBlock, passageStartLines = []) {
+  const boundaries = [...passageStartLines].sort((a, b) => a - b);
+  let nextBoundary = 0;
+  let stack = [];
+  for (const macro of macros) {
+    let crossed = false;
+    while (nextBoundary < boundaries.length && macro.range.start.line >= boundaries[nextBoundary]) {
+      nextBoundary++;
+      crossed = true;
+    }
+    if (crossed) stack = [];
+    if (!isBlock(macro.name)) continue;
+    if (macro.open) {
+      stack.push(macro);
+      continue;
+    }
+    const name = macro.name.toLowerCase();
+    for (let i = stack.length - 1; i >= 0; i--) {
+      if (stack[i].name.toLowerCase() === name) {
+        const opener = stack[i];
+        opener.pair = macro.id;
+        macro.pair = opener.id;
+        stack.length = i;
+        break;
+      }
+    }
+  }
+}
+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/core/workspace/widget-registry.ts
-var widgetDefRegex, paramRegex, WidgetRegistry;
+function parseParams(argString) {
+  return argString.trim().split(/\s+/).filter((t) => /^[$_@]/.test(t) && t !== "@children");
+}
+var widgetDefRegex, 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;
+    init_macro_parser();
+    widgetDefRegex = /(\{widget\s+["']?)([^\s"'}]+)["']?([^}]*)\}/gi;
     WidgetRegistry = class {
+      /** Widgets keyed by lower-cased name; Spindle resolves widgets case-insensitively. */
       widgets = /* @__PURE__ */ new Map();
       /** Per-URI set of lower-cased macro names opened in that document. */
       invokedByUri = /* @__PURE__ */ new Map();
@@ -7009,40 +7228,43 @@ var init_widget_registry = __esm({
               break;
             }
           }
-          const contentLines = lines.slice(contentStartLine, contentEndLine);
-          for (let i = 0; i < contentLines.length; i++) {
-            const line = contentLines[i];
-            widgetDefRegex.lastIndex = 0;
-            let match2;
-            while ((match2 = widgetDefRegex.exec(line)) !== null) {
-              const widgetName = match2[1];
-              const paramString = match2[2] || "";
-              const params = [];
-              let paramMatch;
-              paramRegex.lastIndex = 0;
-              while ((paramMatch = paramRegex.exec(paramString)) !== null) {
-                params.push(paramMatch[1]);
-              }
-              const lineNum = contentStartLine + i;
-              const charStart = match2.index;
-              const charEnd = charStart + match2[0].length;
-              const range2 = {
-                start: { line: lineNum, character: charStart },
-                end: { line: lineNum, character: charEnd }
-              };
-              this.widgets.set(widgetName, {
-                name: widgetName,
-                params,
-                uri: passage.uri,
-                range: range2
-              });
-            }
+          const content = lines.slice(contentStartLine, contentEndLine).join("\n");
+          const lineStarts = buildLineStarts(content);
+          const toPosition = (offset) => {
+            const pos = offsetToPosition(offset, lineStarts);
+            return { line: contentStartLine + pos.line, character: pos.character };
+          };
+          widgetDefRegex.lastIndex = 0;
+          let match2;
+          while ((match2 = widgetDefRegex.exec(content)) !== null) {
+            const widgetName = match2[2];
+            const nameStart = match2.index + match2[1].length;
+            const range2 = {
+              start: toPosition(match2.index),
+              end: toPosition(match2.index + match2[0].length)
+            };
+            const nameRange = {
+              start: toPosition(nameStart),
+              end: toPosition(nameStart + widgetName.length)
+            };
+            const bodyStart = match2.index + match2[0].length;
+            const rest = content.slice(bodyStart);
+            const closeIdx = rest.search(/\{\/widget\}/i);
+            const body = closeIdx >= 0 ? rest.slice(0, closeIdx) : rest;
+            this.widgets.set(widgetName.toLowerCase(), {
+              name: widgetName,
+              params: parseParams(match2[3]),
+              uri: passage.uri,
+              range: range2,
+              nameRange,
+              block: /\{@children\}/.test(body)
+            });
           }
         }
       }
-      /** Get a widget definition by name. */
+      /** Get a widget definition by name (case-insensitive). */
       getWidget(name) {
-        return this.widgets.get(name);
+        return this.widgets.get(name.toLowerCase());
       }
       /** Get all registered widget definitions. */
       getAllWidgets() {
@@ -7076,89 +7298,111 @@ var init_widget_registry = __esm({
   }
 });
 
-// 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);
+// src/core/parsing/macro-discovery.ts
+function extractBalancedBraces(source, start) {
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inBacktick = false;
+  for (let i = start; i < source.length; i++) {
+    const ch = source[i];
+    const prev = i > start ? source[i - 1] : "";
+    if (prev === "\\") continue;
+    if (inSingleQuote) {
+      if (ch === "'") inSingleQuote = false;
+      continue;
+    }
+    if (inDoubleQuote) {
+      if (ch === '"') inDoubleQuote = false;
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+    if (ch === "'") {
+      inSingleQuote = true;
+    } else if (ch === '"') {
+      inDoubleQuote = true;
+    } else if (ch === "`") {
+      inBacktick = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return source.slice(start, i + 1);
+      }
     }
   }
-  return starts;
+  return null;
 }
-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;
+function parseConfigFields(config2) {
+  const nameMatch = config2.match(/name:\s*['"]([^'"]+)['"]/);
+  if (!nameMatch) return null;
+  const macro = {
+    name: nameMatch[1]
+  };
+  const boolFields = [
+    "block",
+    "storeVar",
+    "merged",
+    "interpolate"
+  ];
+  for (const field of boolFields) {
+    const re = new RegExp(`${field}:\\s*(true|false)`);
+    const m = config2.match(re);
+    if (m) {
+      macro[field] = m[1] === "true";
     }
   }
-  return { line: low, character: offset - lineStarts[low] };
+  const descMatch = config2.match(/description:\s*['"]([^'"]+)['"]/);
+  if (descMatch) {
+    macro.description = descMatch[1];
+  }
+  const subMatch = config2.match(/subMacros:\s*\[([^\]]*)\]/);
+  if (subMatch) {
+    const inner = subMatch[1].trim();
+    if (inner) {
+      macro.subMacros = inner.split(",").map(
+        (s) => s.trim().replace(/^['"]|['"]$/g, "")
+      ).filter((s) => s.length > 0);
+    }
+  }
+  return macro;
 }
-function parseMacros(text) {
-  const cleaned = text.replace(variableInterpolationRegex, (match3) => {
-    return " ".repeat(match3.length);
-  });
-  const lineStarts = buildLineStarts(text);
+function discoverMacrosFromSource(source) {
   const macros = [];
-  let id = 0;
-  macroRegex.lastIndex = 0;
+  defineMacroRegex.lastIndex = 0;
   let match2;
-  while ((match2 = macroRegex.exec(cleaned)) !== null) {
-    const closeSlash = match2[1];
-    const cssPrefix = (match2[2] || "").trim();
-    const macroName = match2[3];
-    const rawArgs = match2[4];
-    const open = closeSlash !== "/";
-    const matchStart = match2.index;
-    const matchEnd = matchStart + match2[0].length;
-    const startPos = offsetToPosition(matchStart, lineStarts);
-    const endPos = offsetToPosition(matchEnd, lineStarts);
-    const range2 = {
-      start: startPos,
-      end: endPos
-    };
-    macros.push({
-      id,
-      pair: -1,
-      name: macroName,
-      open,
-      range: range2,
-      cssPrefix: cssPrefix || void 0,
-      rawArgs: rawArgs || void 0
-    });
-    id++;
+  while ((match2 = defineMacroRegex.exec(source)) !== null) {
+    const braceStart = match2.index + match2[0].length - 1;
+    const config2 = extractBalancedBraces(source, braceStart);
+    if (!config2) continue;
+    const macro = parseConfigFields(config2);
+    if (macro) {
+      macros.push(macro);
+    }
   }
   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;
-      }
-    }
+function discoverMacrosFromStoryInit(passageContent2) {
+  const macros = [];
+  doBlockRegex.lastIndex = 0;
+  let doMatch;
+  while ((doMatch = doBlockRegex.exec(passageContent2)) !== null) {
+    const jsContent = doMatch[1];
+    const found = discoverMacrosFromSource(jsContent);
+    macros.push(...found);
   }
+  return macros;
 }
-var variableInterpolationRegex, macroRegex;
-var init_macro_parser = __esm({
-  "src/core/parsing/macro-parser.ts"() {
+var defineMacroRegex, doBlockRegex;
+var init_macro_discovery = __esm({
+  "src/core/parsing/macro-discovery.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;
+    defineMacroRegex = /Story\.defineMacro\s*\(\s*\{/g;
+    doBlockRegex = /\{do\}([\s\S]*?)\{\/do\}/g;
   }
 });
 
@@ -7352,7 +7596,7 @@ var init_macro_supplements = __esm({
       },
       include: {
         name: "include",
-        description: 'Outputs the contents of the specified passage.\n\nUsage: `{include "passage"}`',
+        description: 'Outputs the contents of the specified passage. The argument is a passage name or an expression that evaluates to one; add `inline` to render the passage as inline content without markdown processing.\n\nUsage: `{include "passage"}`, `{include $passageName}` or `{include "passage" inline}`',
         parameters: ["text"]
       },
       passage: {
@@ -7362,28 +7606,28 @@ var init_macro_supplements = __esm({
       },
       textbox: {
         name: "textbox",
-        description: 'Creates a text input box.\n\nUsage: `{textbox "$receiver" defaultValue}`',
-        parameters: ["receiver &+ text"]
+        description: 'Creates a text input box bound to a story variable.\n\nUsage: `{textbox $receiver}` or `{textbox $receiver "placeholder"}`',
+        parameters: ["receiver |+ text"]
       },
       numberbox: {
         name: "numberbox",
-        description: 'Creates a number input box.\n\nUsage: `{numberbox "$receiver" defaultValue}`',
-        parameters: ["receiver &+ text"]
+        description: 'Creates a number input box bound to a story variable.\n\nUsage: `{numberbox $receiver}` or `{numberbox $receiver "placeholder"}`',
+        parameters: ["receiver |+ text"]
       },
       textarea: {
         name: "textarea",
-        description: 'Creates a multi-line text input area.\n\nUsage: `{textarea "$receiver" defaultValue}`',
-        parameters: ["receiver &+ text"]
+        description: 'Creates a multi-line text input area bound to a story variable.\n\nUsage: `{textarea $receiver}` or `{textarea $receiver "placeholder"}`',
+        parameters: ["receiver |+ text"]
       },
       checkbox: {
         name: "checkbox",
-        description: 'Creates a checkbox input.\n\nUsage: `{checkbox "$receiver" uncheckedValue checkedValue}`',
-        parameters: ["receiver &+ text"]
+        description: 'Creates a checkbox that toggles a boolean story variable.\n\nUsage: `{checkbox $receiver "label"}`',
+        parameters: ["receiver |+ text"]
       },
       radiobutton: {
         name: "radiobutton",
-        description: 'Creates a radio button input.\n\nUsage: `{radiobutton "$receiver" value}`',
-        parameters: ["receiver &+ text &+ text"]
+        description: 'Creates a radio button that sets a story variable to its value. Use the same variable for every option in a group.\n\nUsage: `{radiobutton $receiver "value" "label"}`',
+        parameters: ["receiver &+ text |+ text"]
       },
       quicksave: {
         name: "quicksave",
@@ -7413,8 +7657,8 @@ var init_macro_supplements = __esm({
       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"]
+        description: 'Creates a button that opens the passage named in its body in a dialog. Add `noclose` to hide the dialog\'s close button.\n\nUsage:\n\n```\n{dialog "label"}Passage Name{/dialog}\n{dialog "label" noclose}Passage Name{/dialog}\n```',
+        parameters: ["text |+ 'noclose'"]
       },
       nobr: {
         name: "nobr",
@@ -7470,6 +7714,7 @@ var init_workspace_model = __esm({
     init_variable_tracker();
     init_widget_registry();
     init_macro_parser();
+    init_macro_discovery();
     init_macro_supplements();
     WorkspaceModel = class extends EventEmitter3 {
       documents;
@@ -7492,7 +7737,7 @@ var init_workspace_model = __esm({
         this.macros = new MacroRegistry();
         this.variables = new VariableTracker();
         this.widgets = new WidgetRegistry();
-        this.macros.loadBuiltins();
+        this.macros.loadBuiltins(config2?.workspaceRoot);
         this.macros.loadSupplements(macro_supplements_default);
         this.onDocumentChanged = (uri) => this.handleDocumentChange(uri);
         this.onDocumentOpened = (uri) => this.handleDocumentChange(uri);
@@ -7517,6 +7762,14 @@ var init_workspace_model = __esm({
         this.initialized = true;
         this.scheduleModelReady();
       }
+      /**
+       * Re-run cross-document analysis and schedule 'modelReady', e.g. after
+       * the macro configuration changed without any document changing.
+       */
+      refresh() {
+        this.cascade();
+        this.scheduleModelReady();
+      }
       /** Clean up listeners and timers. */
       dispose() {
         this.documents.removeListener("documentChanged", this.onDocumentChanged);
@@ -7534,6 +7787,7 @@ var init_workspace_model = __esm({
         if (text !== void 0) {
           this.passages.rebuild(uri, text);
         }
+        this.refreshDiscoveredMacros();
         this.cascade();
         this.emit("documentChanged", uri);
         this.emit("passagesUpdated", uri);
@@ -7542,6 +7796,7 @@ var init_workspace_model = __esm({
       /** Handle a document close: remove its passages and cascade. */
       handleDocumentClose(uri) {
         this.passages.remove(uri);
+        this.refreshDiscoveredMacros();
         this.cascade();
         this.emit("documentClosed", uri);
         this.emit("passagesUpdated", uri);
@@ -7555,8 +7810,39 @@ var init_workspace_model = __esm({
             this.passages.rebuild(uri, text);
           }
         }
+        this.refreshDiscoveredMacros();
         this.cascade();
       }
+      /**
+       * Re-run static macro discovery over the workspace and replace the
+       * registry's discovered tier (dropping definitions whose source is gone).
+       *
+       * Sources scanned for Story.defineMacro({...}) calls:
+       *  - `{do}` blocks in StoryInit passages
+       *  - passages tagged `script` (Story JavaScript)
+       *  - JavaScript/TypeScript documents in the workspace
+       */
+      refreshDiscoveredMacros() {
+        const found = [];
+        for (const uri of this.documents.getUris()) {
+          const text = this.documents.getText(uri);
+          if (!text) continue;
+          if (/\.[cm]?[jt]s$/i.test(uri)) {
+            found.push(...discoverMacrosFromSource(text));
+            continue;
+          }
+          let lines;
+          for (const passage of this.passages.getPassagesInDocument(uri)) {
+            const isStoryInit = passage.name === "StoryInit";
+            const isScript = passage.tags?.includes("script") ?? false;
+            if (!isStoryInit && !isScript) continue;
+            lines ??= text.split("\n");
+            const content = lines.slice(passage.headerEnd.end.line + 1, passage.range.end.line + 1).join("\n");
+            found.push(...isScript ? discoverMacrosFromSource(content) : discoverMacrosFromStoryInit(content));
+          }
+        }
+        this.macros.setDiscoveredMacros(found);
+      }
       /**
        * Cascade: rescan variables and widgets based on current passages.
        * Called after any passage index update.
@@ -7576,8 +7862,10 @@ var init_workspace_model = __esm({
               }
             }
             const content = lines.slice(contentStart, contentEnd).join("\n");
-            this.variables.parseStoryVariables(content, contentStart);
+            this.variables.parseStoryVariables(content, contentStart, storyVars.uri);
           }
+        } else {
+          this.variables.clearStoryVariables();
         }
         const storyTransients = this.passages.getStoryTransients();
         if (storyTransients) {
@@ -7593,8 +7881,10 @@ var init_workspace_model = __esm({
               }
             }
             const content = lines.slice(contentStart, contentEnd).join("\n");
-            this.variables.parseStoryTransients(content, contentStart);
+            this.variables.parseStoryTransients(content, contentStart, storyTransients.uri);
           }
+        } else {
+          this.variables.clearStoryTransients();
         }
         this.widgets.clearInvocations();
         for (const uri of this.documents.getUris()) {
@@ -8353,6 +8643,30 @@ var init_parameter_validator = __esm({
           return arg.type === 4 /* Variable */ ? null : new TypeError2("Argument is not a variable");
         }
       },
+      {
+        // The story variable a form control binds to: `$name` or `"$name"`.
+        // Spindle strips the quotes and the `$` sigil from the first argument
+        // and reads the rest as a dot path into the story variables.
+        name: ["receiver"],
+        validate(arg) {
+          let name;
+          if (arg.type === 0 /* String */) {
+            name = arg.text.slice(1, -1);
+          } else if (arg.type === 8 /* Bareword */) {
+            name = arg.text;
+          }
+          if (name === void 0) {
+            return new TypeError2("Argument is not a variable receiver");
+          }
+          if (/^[_@%]/.test(name)) {
+            return new TypeError2(`Variable receiver must be a story variable ($name), got '${name}'`);
+          }
+          if (!/^\$?[A-Za-z_][\w$]*(?:\.[\w$]+)*$/.test(name)) {
+            return new TypeError2(`Argument is not a valid variable receiver: '${name}'`);
+          }
+          return null;
+        }
+      },
       {
         name: ["passage"],
         validate(arg, _args, _index, state) {
@@ -8505,58 +8819,175 @@ var init_parameter_validator = __esm({
 });
 
 // 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);
+function skipSelectors(text, i) {
+  while (text[i] === "." || text[i] === "#") {
+    i++;
+    for (; ; ) {
+      if (/[a-zA-Z0-9_-]/.test(text[i] ?? "")) {
+        i++;
+        continue;
+      }
+      const interpolation = /^\{[$_@][\w.]*\}/.exec(text.slice(i));
+      if (!interpolation) break;
+      i += interpolation[0].length;
     }
   }
-  return starts;
+  return i;
 }
-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;
-    }
+function locateTarget(inner) {
+  let start = 0;
+  let end = inner.length;
+  const pipeIdx = inner.indexOf("|");
+  const arrowIdx = inner.indexOf("->");
+  const revIdx = inner.indexOf("<-");
+  if (pipeIdx !== -1) {
+    start = pipeIdx + 1;
+  } else if (arrowIdx !== -1) {
+    start = arrowIdx + 2;
+  } else if (revIdx !== -1) {
+    end = revIdx;
   }
-  return { line: low, character: offset - lineStarts[low] };
+  while (start < end && /\s/.test(inner[start])) start++;
+  while (end > start && /\s/.test(inner[end - 1])) end--;
+  return { start, end };
 }
 function parseLinks(text, lineOffset = 0) {
-  const lineStarts = buildLineStarts2(text);
+  const lineStarts = buildLineStarts(text);
   const refs = [];
-  linkRegex.lastIndex = 0;
-  let match2;
-  while ((match2 = linkRegex.exec(text)) !== null) {
-    const passageName = match2[2].trim();
-    if (!passageName) continue;
-    const nameStartInMatch = match2[0].indexOf(passageName);
-    const nameStart = match2.index + nameStartInMatch;
-    const nameEnd = nameStart + passageName.length;
-    const startPos = offsetToPosition2(nameStart, lineStarts);
-    const endPos = offsetToPosition2(nameEnd, lineStarts);
-    const range2 = {
-      start: { line: startPos.line + lineOffset, character: startPos.character },
-      end: { line: endPos.line + lineOffset, character: endPos.character }
-    };
+  let i = text.indexOf("[[");
+  while (i !== -1) {
+    const linkStart = i;
+    i += 2;
+    if (text[i] === "." || text[i] === "#") {
+      i = skipSelectors(text, i);
+      if (text[i] === " ") i++;
+    }
+    const innerStart = i;
+    let depth = 1;
+    while (i < text.length) {
+      if (text.startsWith("[[", i)) {
+        depth++;
+        i += 2;
+      } else if (text.startsWith("]]", i)) {
+        if (--depth === 0) break;
+        i += 2;
+      } else {
+        i++;
+      }
+    }
+    if (depth !== 0) {
+      i = text.indexOf("[[", linkStart + 2);
+      continue;
+    }
+    const target = locateTarget(text.slice(innerStart, i));
+    if (target.end > target.start) {
+      const nameStart = innerStart + target.start;
+      const nameEnd = innerStart + target.end;
+      const startPos = offsetToPosition(nameStart, lineStarts);
+      const endPos = offsetToPosition(nameEnd, lineStarts);
+      refs.push({
+        name: text.slice(nameStart, nameEnd),
+        range: {
+          start: { line: startPos.line + lineOffset, character: startPos.character },
+          end: { line: endPos.line + lineOffset, character: endPos.character }
+        },
+        source: "link"
+      });
+    }
+    i = text.indexOf("[[", i + 2);
+  }
+  return refs;
+}
+function findPassageRefAt(text, position) {
+  const { line, character } = position;
+  return [...parseLinks(text), ...parseMacroPassageRefs(text)].find(({ range: { start, end } }) => (line > start.line || line === start.line && character >= start.character) && (line < end.line || line === end.line && character <= end.character));
+}
+function resolveExpressionTarget(args2) {
+  const lead = args2.length - args2.trimStart().length;
+  const expr = args2.trim();
+  if (expr === "") return null;
+  const lexed = lexArguments(expr);
+  if (lexed.length === 1 && lexed[0].start === 0 && lexed[0].end === expr.length && (lexed[0].type === 0 /* String */ || lexed[0].type === 7 /* Expression */)) {
+    const raw = expr.slice(1, -1);
+    if (interpolationRegex.test(raw) || raw.includes("${")) return null;
+    return { name: raw.replace(/\\(.)/g, "$1"), start: lead + 1, end: lead + expr.length - 1 };
+  }
+  if (/[$@%"'`(]/.test(expr) || temporaryRefRegex.test(expr)) return null;
+  if (EXPRESSION_BUILTINS.has(expr)) return null;
+  return { name: expr, start: lead, end: lead + expr.length };
+}
+function resolveIncludeTarget(args2) {
+  const inline = /\binline\b/.exec(args2);
+  if (!inline) return resolveExpressionTarget(args2);
+  const cut = inline.index;
+  const width = inline[0].length;
+  const target = resolveExpressionTarget(args2.slice(0, cut) + args2.slice(cut + width));
+  if (!target || target.start < cut && cut < target.end) return null;
+  return {
+    name: target.name,
+    start: target.start < cut ? target.start : target.start + width,
+    end: target.end <= cut ? target.end : target.end + width
+  };
+}
+function resolveLinkMacroTarget(args2) {
+  const strings = lexArguments(args2).filter((a) => a.type === 0 /* String */);
+  if (strings.length < 2) return null;
+  const target = strings[1];
+  const name = target.text.slice(1, -1);
+  if (name.includes("\\") || interpolationRegex.test(name)) return null;
+  return { name, start: target.start + 1, end: target.end - 1 };
+}
+function parseMacroPassageRefs(text, lineOffset = 0) {
+  const lineStarts = buildLineStarts(text);
+  const refs = [];
+  for (const macro of parseMacros(text)) {
+    if (!macro.open || !macro.rawArgs) continue;
+    const resolve4 = macroTargetResolvers[macro.name.toLowerCase()];
+    if (!resolve4) continue;
+    const argsEnd = lineStarts[macro.range.end.line] + macro.range.end.character - 1;
+    const argsStart = argsEnd - macro.rawArgs.length;
+    const target = resolve4(text.slice(argsStart, argsEnd));
+    if (!target || target.name === "") continue;
+    const startPos = offsetToPosition(argsStart + target.start, lineStarts);
+    const endPos = offsetToPosition(argsStart + target.end, lineStarts);
     refs.push({
-      name: passageName,
-      range: range2,
-      source: "link"
+      name: target.name,
+      range: {
+        start: { line: startPos.line + lineOffset, character: startPos.character },
+        end: { line: endPos.line + lineOffset, character: endPos.character }
+      },
+      source: "macro"
     });
   }
   return refs;
 }
-var linkRegex;
+var EXPRESSION_BUILTINS, interpolationRegex, temporaryRefRegex, macroTargetResolvers;
 var init_link_parser = __esm({
   "src/core/parsing/link-parser.ts"() {
     "use strict";
-    linkRegex = /\[\[([^\]]*?\|)?([^\]]+?)\]\]/g;
+    init_macro_parser();
+    init_argument_lexer();
+    EXPRESSION_BUILTINS = /* @__PURE__ */ new Set([
+      "currentPassage",
+      "previousPassage",
+      "visited",
+      "hasVisited",
+      "hasVisitedAny",
+      "hasVisitedAll",
+      "rendered",
+      "hasRendered",
+      "hasRenderedAny",
+      "hasRenderedAll",
+      "random",
+      "randomInt"
+    ]);
+    interpolationRegex = /\{[$_@%][A-Za-z_$]/;
+    temporaryRefRegex = /(?<![.\w$@%])_[A-Za-z_$][\w$]*(?![\w$])/;
+    macroTargetResolvers = {
+      goto: resolveExpressionTarget,
+      include: resolveIncludeTarget,
+      link: resolveLinkMacroTarget
+    };
   }
 });
 
@@ -8569,8 +9000,13 @@ function computeDiagnostics(uri, workspace, options) {
     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 markupText = maskScriptAndStylesheetPassages(text, passages);
+    const macros = parseMacros(markupText);
+    pairMacros(
+      macros,
+      (name) => workspace.macros.isBlock(name),
+      passages.map((p) => p.range.start.line)
+    );
     const allPassages = workspace.passages.getAllPassages();
     const passageNames = new Set(allPassages.map((p) => p.name));
     try {
@@ -8586,7 +9022,7 @@ function computeDiagnostics(uri, workspace, options) {
     } catch {
     }
     try {
-      validateLinks(text, passages, passageNames, diagnostics);
+      validateLinks(markupText, passages, passageNames, diagnostics);
     } catch {
     }
     try {
@@ -8620,6 +9056,18 @@ function computeDiagnostics(uri, workspace, options) {
     return [];
   }
 }
+function maskScriptAndStylesheetPassages(text, passages) {
+  const excluded = passages.filter(isScriptOrStylesheetPassage);
+  if (excluded.length === 0) return text;
+  const lines = text.split("\n");
+  for (const passage of excluded) {
+    const last = Math.min(passage.range.end.line, lines.length - 1);
+    for (let i = passage.range.start.line + 1; i <= last; i++) {
+      lines[i] = lines[i].replace(/[^\r]/g, " ");
+    }
+  }
+  return lines.join("\n");
+}
 function validateMacros(macros, workspace, diagnostics) {
   for (let curIndex = 0; curIndex < macros.length; curIndex++) {
     const macro = macros[curIndex];
@@ -8732,8 +9180,13 @@ function validateArguments(macros, workspace, passageNames, diagnostics) {
     if (info.skipArgs) continue;
     if (!info.parameters) continue;
     const rawArgs = macro.rawArgs ?? "";
-    const args2 = lexArguments(rawArgs);
-    const params = new Parameters(info.parameters);
+    const args2 = macro.name.toLowerCase() === "include" ? includeArguments(rawArgs) : lexArguments(rawArgs);
+    let params;
+    try {
+      params = new Parameters(info.parameters);
+    } catch {
+      continue;
+    }
     if (params.isEmpty()) {
       if (args2.length > 0) {
         diagnostics.push(makeDiag(
@@ -8773,6 +9226,16 @@ function validateArguments(macros, workspace, passageNames, diagnostics) {
     }
   }
 }
+function includeArguments(rawArgs) {
+  const expr = includeExpression(rawArgs);
+  if (expr === "") return [];
+  const args2 = lexArguments(expr);
+  if (args2.length === 1) return args2;
+  return [{ type: 7 /* Expression */, text: expr, start: 0, end: expr.length }];
+}
+function includeExpression(rawArgs) {
+  return rawArgs.replace(/\binline\b/, "").trim();
+}
 function validateVariables(uri, workspace, diagnostics) {
   if (!workspace.variables.hasStoryVariables()) {
     const undeclared = workspace.variables.getUndeclared(uri);
@@ -8874,7 +9337,7 @@ function validateArrayMemberAccess(uri, workspace, diagnostics) {
     ));
   }
 }
-function temporaryRefRegex(name) {
+function temporaryRefRegex2(name) {
   const ident = name ? escapeRegex(name) : "[A-Za-z_$][\\w$]*";
   return new RegExp(`(?<![.\\w$@%])_(${ident})(?![\\w$])`, "g");
 }
@@ -8950,7 +9413,7 @@ function setTemporaryTargets(rawArgs) {
   while ((m = assignRe.exec(code)) !== null) {
     const name = m[1];
     const rhs = code.slice(m.index + m[0].length, statementEnd(code, m.index + m[0].length));
-    if (temporaryRefRegex(name).test(rhs)) continue;
+    if (temporaryRefRegex2(name).test(rhs)) continue;
     targets.push({ name, offset: m.index });
   }
   return targets;
@@ -9019,7 +9482,7 @@ function validateLoopTemporaries(uri, text, macros, workspace, diagnostics) {
   }
 }
 function isReadInBody(body, bodyOffset, name, macroStart, macroEnd) {
-  const re = temporaryRefRegex(name);
+  const re = temporaryRefRegex2(name);
   let m;
   while ((m = re.exec(body)) !== null) {
     const offset = bodyOffset + m.index;
@@ -9030,16 +9493,16 @@ function isReadInBody(body, bodyOffset, name, macroStart, macroEnd) {
   }
   return false;
 }
-function resolveIncludeTarget(rawArgs) {
-  const expr = rawArgs.replace(/\binline\b/, "").trim();
+function resolveIncludeTarget2(rawArgs) {
+  const expr = includeExpression(rawArgs);
   if (expr === "") return null;
   const literal2 = /^(["'`])((?:\\.|(?!\1)[^\\])*)\1$/s.exec(expr);
   if (literal2) {
     if (literal2[1] === "`" && literal2[2].includes("${")) return null;
     return literal2[2].replace(/\\(.)/g, "$1");
   }
-  if (/[$@%"'`(]/.test(expr) || temporaryRefRegex().test(expr)) return null;
-  if (EXPRESSION_BUILTINS.has(expr)) return null;
+  if (/[$@%"'`(]/.test(expr) || temporaryRefRegex2().test(expr)) return null;
+  if (EXPRESSION_BUILTINS2.has(expr)) return null;
   return expr;
 }
 function widgetDefinitionNames(content) {
@@ -9058,7 +9521,7 @@ function validateWidgetIncludes(text, macros, workspace, diagnostics) {
   for (const macro of macros) {
     if (!macro.open || !macro.rawArgs || macro.name.toLowerCase() !== "include") continue;
     lineStarts ??= buildLineStarts(text);
-    const target = resolveIncludeTarget(sourceArgs(macro, text, lineStarts).args);
+    const target = resolveIncludeTarget2(sourceArgs(macro, text, lineStarts).args);
     if (target === null) continue;
     const passage = workspace.passages.getPassage(target);
     if (!passage?.tags?.includes("widget")) continue;
@@ -9084,10 +9547,15 @@ function validateUnusedWidgets(uri, workspace, diagnostics) {
   }
 }
 function validateLineLength(text, passages, maxLength, diagnostics) {
-  const excludedTags = /* @__PURE__ */ new Set(["script", "stylesheet"]);
-  const excludedPassages = new Set(passages.filter((p) => p.tags?.some((t) => excludedTags.has(t))).map((p) => p.name));
+  const excludedLines = /* @__PURE__ */ new Set();
+  for (const passage of passages.filter(isScriptOrStylesheetPassage)) {
+    for (let i = passage.range.start.line; i <= passage.range.end.line; i++) {
+      excludedLines.add(i);
+    }
+  }
   const lines = text.split("\n");
   for (let i = 0; i < lines.length; i++) {
+    if (excludedLines.has(i)) continue;
     const line = lines[i];
     if (/^::\s+/.test(line)) continue;
     if (/^\s*<[a-zA-Z]/.test(line)) continue;
@@ -9130,7 +9598,7 @@ function toLspDiagnostic(d) {
     message: d.message
   };
 }
-var DEFERRED_CONTAINERS, EXPRESSION_BUILTINS, diagnosticsPlugin;
+var DEFERRED_CONTAINERS, EXPRESSION_BUILTINS2, diagnosticsPlugin;
 var init_diagnostics = __esm({
   "src/plugins/diagnostics.ts"() {
     "use strict";
@@ -9139,8 +9607,9 @@ var init_diagnostics = __esm({
     init_argument_lexer();
     init_parameter_validator();
     init_link_parser();
+    init_passage_parser();
     DEFERRED_CONTAINERS = /* @__PURE__ */ new Set(["link", "button"]);
-    EXPRESSION_BUILTINS = /* @__PURE__ */ new Set([
+    EXPRESSION_BUILTINS2 = /* @__PURE__ */ new Set([
       "currentPassage",
       "previousPassage",
       "visited",
@@ -9158,22 +9627,22 @@ var init_diagnostics = __esm({
       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 isEnabled = (d) => ctx.config.diagnostics?.[d.code] !== false;
+        const publishFor = (uri) => {
           const diags = computeDiagnostics(uri, ctx.workspace);
           ctx.connection.sendDiagnostics({
             uri,
-            diagnostics: diags.map((d) => toLspDiagnostic(d))
+            diagnostics: diags.filter(isEnabled).map((d) => toLspDiagnostic(d))
           });
+        };
+        ctx.workspace.on("modelReady", () => {
+          for (const uri of ctx.workspace.documents.getUris()) {
+            publishFor(uri);
+          }
+        });
+        ctx.workspace.on("documentChanged", publishFor);
+        ctx.workspace.on("documentClosed", (uri) => {
+          ctx.connection.sendDiagnostics({ uri, diagnostics: [] });
         });
       }
     };
@@ -9193,9 +9662,9 @@ var require_identity = __commonJS({
     var NODE_TYPE = Symbol.for("yaml.node.type");
     var isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
     var isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC;
-    var isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
+    var isMap2 = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
     var isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR;
-    var isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
+    var isScalar2 = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
     var isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ;
     function isCollection(node) {
       if (node && typeof node === "object")
@@ -9217,7 +9686,7 @@ var require_identity = __commonJS({
         }
       return false;
     }
-    var hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
+    var hasAnchor = (node) => (isScalar2(node) || isCollection(node)) && !!node.anchor;
     exports.ALIAS = ALIAS;
     exports.DOC = DOC;
     exports.MAP = MAP;
@@ -9229,10 +9698,10 @@ var require_identity = __commonJS({
     exports.isAlias = isAlias;
     exports.isCollection = isCollection;
     exports.isDocument = isDocument;
-    exports.isMap = isMap;
+    exports.isMap = isMap2;
     exports.isNode = isNode;
     exports.isPair = isPair;
-    exports.isScalar = isScalar;
+    exports.isScalar = isScalar2;
     exports.isSeq = isSeq;
   }
 });
@@ -13334,9 +13803,9 @@ var require_resolve_flow_collection = __commonJS({
     var blockMsg = "Block collections are not allowed within flow collections";
     var isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
     function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
-      const isMap = fc.start.source === "{";
-      const fcName = isMap ? "flow map" : "flow sequence";
-      const NodeClass = tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq);
+      const isMap2 = fc.start.source === "{";
+      const fcName = isMap2 ? "flow map" : "flow sequence";
+      const NodeClass = tag?.nodeClass ?? (isMap2 ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq);
       const coll = new NodeClass(ctx.schema);
       coll.flow = true;
       const atRoot = ctx.atRoot;
@@ -13372,7 +13841,7 @@ var require_resolve_flow_collection = __commonJS({
             offset = props.end;
             continue;
           }
-          if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
+          if (!isMap2 && ctx.options.strict && utilContainsNewline.containsNewline(key))
             onError(
               key,
               // checked by containsNewline()
@@ -13412,7 +13881,7 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep2 && !props.found) {
+        if (!isMap2 && !sep2 && !props.found) {
           const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
@@ -13435,7 +13904,7 @@ var require_resolve_flow_collection = __commonJS({
             startOnNewline: false
           });
           if (valueProps.found) {
-            if (!isMap && !props.found && ctx.options.strict) {
+            if (!isMap2 && !props.found && ctx.options.strict) {
               if (sep2)
                 for (const st of sep2) {
                   if (st === valueProps.found)
@@ -13467,7 +13936,7 @@ var require_resolve_flow_collection = __commonJS({
           const pair = new Pair.Pair(keyNode, valueNode);
           if (ctx.options.keepSourceTokens)
             pair.srcToken = collItem;
-          if (isMap) {
+          if (isMap2) {
             const map2 = coll;
             if (utilMapIncludes.mapIncludes(ctx, map2.items, keyNode))
               onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
@@ -13483,7 +13952,7 @@ var require_resolve_flow_collection = __commonJS({
           offset = valueNode ? valueNode.range[2] : valueProps.end;
         }
       }
-      const expectedEnd = isMap ? "}" : "]";
+      const expectedEnd = isMap2 ? "}" : "]";
       const [ce, ...ee] = fc.end;
       let cePos = offset;
       if (ce?.source === expectedEnd)
@@ -14766,7 +15235,7 @@ var require_cst = __commonJS({
     var FLOW_END = "";
     var SCALAR = "";
     var isCollection = (token) => !!token && "items" in token;
-    var isScalar = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
+    var isScalar2 = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
     function prettyToken(token) {
       switch (token) {
         case BOM:
@@ -14850,7 +15319,7 @@ var require_cst = __commonJS({
     exports.FLOW_END = FLOW_END;
     exports.SCALAR = SCALAR;
     exports.isCollection = isCollection;
-    exports.isScalar = isScalar;
+    exports.isScalar = isScalar2;
     exports.prettyToken = prettyToken;
     exports.tokenType = tokenType;
   }
@@ -16363,7 +16832,7 @@ var require_public_api = __commonJS({
         return docs;
       return Object.assign([], { empty: true }, composer$1.streamInfo());
     }
-    function parseDocument(source, options = {}) {
+    function parseDocument2(source, options = {}) {
       const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options);
       const parser$1 = new parser.Parser(lineCounter2?.addNewLine);
       const composer$1 = new composer.Composer(options);
@@ -16389,7 +16858,7 @@ var require_public_api = __commonJS({
       } else if (options === void 0 && reviver && typeof reviver === "object") {
         options = reviver;
       }
-      const doc = parseDocument(src, options);
+      const doc = parseDocument2(src, options);
       if (!doc)
         return null;
       doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning));
@@ -16425,7 +16894,7 @@ var require_public_api = __commonJS({
     }
     exports.parse = parse3;
     exports.parseAllDocuments = parseAllDocuments;
-    exports.parseDocument = parseDocument;
+    exports.parseDocument = parseDocument2;
     exports.stringify = stringify;
   }
 });
@@ -16515,6 +16984,22 @@ function findConfigFile(workspaceRoot) {
   }
   return null;
 }
+function loadConfigFile(configPath) {
+  let content;
+  try {
+    content = readFileSync3(configPath, "utf-8");
+  } catch (err) {
+    const reason = err?.code === "ENOENT" ? "file not found" : err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot read config file '${configPath}': ${reason}`);
+  }
+  const format = configPath.toLowerCase().endsWith(".json") ? "json" : "yaml";
+  try {
+    return parseConfig(content, format);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid ${format.toUpperCase()} in config file '${configPath}': ${reason}`);
+  }
+}
 function loadConfigFromDisk(workspaceRoot) {
   const configPath = findConfigFile(workspaceRoot);
   if (!configPath) {
@@ -16709,7 +17194,7 @@ __export(check_exports, {
   runCheck: () => runCheck
 });
 import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 function parseArgs(args2) {
   const options = {
@@ -16782,6 +17267,15 @@ function filterBySeverity(diagnostics, minSeverity) {
 async function runCheck(args2) {
   const options = parseArgs(args2);
   const cwd = process.cwd();
+  let explicitConfig = null;
+  if (options.configPath) {
+    try {
+      explicitConfig = loadConfigFile(resolve2(cwd, options.configPath));
+    } catch (err) {
+      console.error(`spindle-lsp check: ${err instanceof Error ? err.message : String(err)}`);
+      return 2;
+    }
+  }
   const files = [];
   for (const pattern of options.patterns) {
     const matches = await glob(pattern, {
@@ -16802,28 +17296,28 @@ async function runCheck(args2) {
     }
     return 0;
   }
-  let configRoot;
-  if (options.configPath) {
-    configRoot = resolve(cwd, options.configPath, "..");
+  const commonDir = uniqueFiles.map((f) => resolve2(f, "..")).reduce((a, b) => {
+    while (!b.startsWith(a)) a = resolve2(a, "..");
+    return a;
+  });
+  let projectConfig;
+  if (explicitConfig) {
+    projectConfig = explicitConfig;
   } else {
-    const dirs = uniqueFiles.map((f) => resolve(f, ".."));
-    configRoot = dirs.reduce((a, b) => {
-      while (!b.startsWith(a)) a = resolve(a, "..");
-      return a;
-    });
+    let configRoot = commonDir;
     let search = configRoot;
     for (let i = 0; i < 10; i++) {
       if (findConfigFile(search)) {
         configRoot = search;
         break;
       }
-      const parent = resolve(search, "..");
+      const parent = resolve2(search, "..");
       if (parent === search) break;
       search = parent;
     }
+    projectConfig = loadConfigFromDisk(configRoot);
   }
-  const projectConfig = loadConfigFromDisk(configRoot);
-  const workspace = new WorkspaceModel();
+  const workspace = new WorkspaceModel({ workspaceRoot: commonDir });
   const fileContents = /* @__PURE__ */ new Map();
   for (const filePath of uniqueFiles) {
     try {
@@ -16835,7 +17329,7 @@ async function runCheck(args2) {
   }
   workspace.initialize(fileContents);
   if (Object.keys(projectConfig.macros).length > 0) {
-    workspace.macros.loadSupplements(projectConfig.macros);
+    workspace.macros.loadConfig(projectConfig.macros);
   }
   const diagOptions = {};
   if (options.maxLineLength !== null) {
@@ -16922,7 +17416,7 @@ function splitPassages(text) {
 function classifyPassage(header) {
   const tagMatch = header.match(/\[([^\]]*)\]/g);
   if (!tagMatch) return "normal";
-  const tags = tagMatch.map((t) => t.slice(1, -1).trim().toLowerCase());
+  const tags = tagMatch.flatMap((t) => t.slice(1, -1).toLowerCase().split(/\s+/));
   if (tags.includes("script")) return "script";
   if (tags.includes("stylesheet")) return "stylesheet";
   return "normal";
@@ -16941,6 +17435,10 @@ function segmentRegions(body) {
     if (/^<script(\s|>)/i.test(trimmed)) {
       const scriptLines = [line];
       i++;
+      if (/<\/script\s*>/i.test(line)) {
+        regions.push({ type: "script", lines: scriptLines });
+        continue;
+      }
       while (i < lines.length && !/<\/script>/i.test(lines[i])) {
         scriptLines.push(lines[i]);
         i++;
@@ -17165,7 +17663,7 @@ function replaceSvgBlocks(html) {
 function restoreSvgBlocks(text, tokens) {
   let result = text;
   for (let i = 0; i < tokens.length; i++) {
-    result = result.replace(`<!--SVG:${i}-->`, tokens[i]);
+    result = result.replace(`<!--SVG:${i}-->`, () => tokens[i]);
   }
   return result;
 }
@@ -17213,8 +17711,8 @@ function replaceSpindleTokens(html) {
 function restoreSpindleTokens(text, tokens) {
   let result = text;
   for (let i = 0; i < tokens.length; i++) {
-    result = result.replace(`<!--SP:${i}-->`, tokens[i]);
-    result = result.replace(`__SP${i}__`, tokens[i]);
+    result = result.replace(`<!--SP:${i}-->`, () => tokens[i]);
+    result = result.replace(`__SP${i}__`, () => tokens[i]);
   }
   return result;
 }
@@ -17257,6 +17755,7 @@ async function formatDocument(text, options) {
   const isDedenting = options?.isDedentingSubMacro ?? ((name) => DEFAULT_DEDENTING.has(name.toLowerCase()));
   const passages = splitPassages(text);
   const resultLines = [];
+  const hardBreakLines = /* @__PURE__ */ new Set();
   for (let pi = 0; pi < passages.length; pi++) {
     const passage = passages[pi];
     if (pi > 0 && passage.header) {
@@ -17285,6 +17784,10 @@ async function formatDocument(text, options) {
     const regions = segmentRegions(passage.body);
     for (const region of regions) {
       if (region.type === "script") {
+        if (region.lines.length === 1) {
+          resultLines.push(region.lines[0]);
+          continue;
+        }
         const firstLine = region.lines[0];
         const lastLine = region.lines[region.lines.length - 1];
         const innerLines = region.lines.slice(1, region.lines.length - 1);
@@ -17319,49 +17822,92 @@ async function formatDocument(text, options) {
       if (options?.maxLineLength) {
         indented = wrapLines(indented, options.maxLineLength);
       }
-      resultLines.push(...indented);
+      for (const line of indented) {
+        if (line.endsWith("  ")) hardBreakLines.add(resultLines.length);
+        resultLines.push(line);
+      }
     }
   }
-  let output = resultLines.map((l) => l.replace(/\s+$/, "")).join("\n");
+  let output = resultLines.map((l, i) => hardBreakLines.has(i) ? l : l.replace(/\s+$/, "")).join("\n");
   output = output.replace(/\n*$/, "\n");
   return output;
 }
 function indentMacros(lines, isBlock, isDedenting) {
-  const result = [];
-  let indentLevel = 0;
-  for (const rawLine of lines) {
-    const line = rawLine.replace(/\s+$/, "");
-    const trimmed = line.trim();
+  const bodies = [{ openLine: -1, minCol: Infinity, keepRelative: false }];
+  const stack = [0];
+  const info = [];
+  const openBody = (line) => {
+    bodies.push({ openLine: line, minCol: Infinity, keepRelative: false });
+    stack.push(bodies.length - 1);
+  };
+  const closeBody = () => stack.length > 1 ? stack.pop() : void 0;
+  const addLine = (col, text) => {
+    const body = bodies[stack[stack.length - 1]];
+    body.minCol = Math.min(body.minCol, col);
+    if (LIST_ITEM_REGEX.test(text) || CODE_FENCE_REGEX.test(text)) body.keepRelative = true;
+    info.push({ body: stack[stack.length - 1], col, text });
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
     if (trimmed === "") {
-      result.push("");
+      info.push(null);
       continue;
     }
+    const col = indentColumn(lines[i]);
     const dedentMatch = trimmed.match(MACRO_OPEN_REGEX);
     if (dedentMatch && isDedenting(dedentMatch[1])) {
-      indentLevel = Math.max(0, indentLevel - 1);
-      result.push(indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed);
-      indentLevel++;
+      const closed2 = closeBody();
+      if (closed2 === void 0) addLine(col, trimmed);
+      else info.push({ body: stack[stack.length - 1], closes: closed2, col, text: trimmed });
+      openBody(i);
       continue;
     }
-    const closeMatch = trimmed.match(MACRO_CLOSE_REGEX);
-    if (closeMatch) {
-      indentLevel = Math.max(0, indentLevel - 1);
-    }
-    result.push(indentLevel > 0 ? "  ".repeat(indentLevel) + trimmed : trimmed);
+    const closed = MACRO_CLOSE_REGEX.test(trimmed) ? closeBody() : void 0;
+    if (closed === void 0) addLine(col, trimmed);
+    else info.push({ body: stack[stack.length - 1], closes: closed, col, text: trimmed });
     const openMatch = trimmed.match(MACRO_OPEN_REGEX);
     if (openMatch && isBlock(openMatch[1])) {
-      indentLevel++;
+      openBody(i);
     }
     const closeGlobal = /\{\/[A-Za-z][\w-]*\s*\}/g;
     let cm;
     while ((cm = closeGlobal.exec(trimmed)) !== null) {
-      if (cm.index > 0) {
-        indentLevel = Math.max(0, indentLevel - 1);
-      }
+      if (cm.index > 0) closeBody();
     }
   }
+  const outCol = [];
+  const result = [];
+  for (let i = 0; i < info.length; i++) {
+    const line = info[i];
+    if (!line) {
+      outCol.push(0);
+      result.push("");
+      continue;
+    }
+    let col;
+    if (line.closes !== void 0) {
+      col = outCol[bodies[line.closes].openLine];
+    } else {
+      const body = bodies[line.body];
+      const isRoot = body.openLine === -1;
+      const base = isRoot ? 0 : outCol[body.openLine] + 2;
+      col = base + (body.keepRelative ? line.col - (isRoot ? 0 : body.minCol) : 0);
+    }
+    outCol.push(col);
+    const hardBreak = / {2,}$/.test(lines[i]) && info[i + 1] ? "  " : "";
+    result.push(" ".repeat(col) + line.text + hardBreak);
+  }
   return result;
 }
+function indentColumn(line) {
+  let col = 0;
+  for (const ch of line) {
+    if (ch === " ") col++;
+    else if (ch === "	") col += 4 - col % 4;
+    else break;
+  }
+  return col;
+}
 async function formatRange(text, _range, options) {
   return formatDocument(text, options);
 }
@@ -17383,6 +17929,7 @@ function wrapLines(lines, maxLen) {
     const indentMatch = line.match(/^(\s*)/);
     const indent = indentMatch ? indentMatch[1] : "";
     const wrapped = wordWrap(trimmed, maxLen, indent);
+    if (line.endsWith("  ")) wrapped[wrapped.length - 1] += "  ";
     result.push(...wrapped);
   }
   return result;
@@ -17443,7 +17990,7 @@ function normalizePassageHeader(line) {
   }
   return `:: ${name}${suffix}`;
 }
-var PASSAGE_HEADER_REGEX2, MACRO_OPEN_REGEX, MACRO_CLOSE_REGEX, DEFAULT_DEDENTING, formatPlugin;
+var PASSAGE_HEADER_REGEX2, MACRO_OPEN_REGEX, MACRO_CLOSE_REGEX, DEFAULT_DEDENTING, LIST_ITEM_REGEX, CODE_FENCE_REGEX, formatPlugin;
 var init_format = __esm({
   "src/plugins/format.ts"() {
     "use strict";
@@ -17455,6 +18002,8 @@ var init_format = __esm({
     MACRO_OPEN_REGEX = /^\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\b/;
     MACRO_CLOSE_REGEX = /^\{\/([A-Za-z][\w-]*)\b/;
     DEFAULT_DEDENTING = /* @__PURE__ */ new Set(["else", "elseif", "next", "case", "default"]);
+    LIST_ITEM_REGEX = /^(?:[-+*]|\d{1,9}[.)])(?:[ \t]|$)/;
+    CODE_FENCE_REGEX = /^(?:`{3,}|~{3,})/;
     formatPlugin = {
       id: "format",
       capabilities: {
@@ -39794,7 +40343,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+            await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
             options?.signal?.throwIfAborted();
           }
         } catch (error48) {
@@ -39811,7 +40360,7 @@ var init_protocol = __esm({
        */
       request(request, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           const earlyReject = (error48) => {
             reject(error48);
           };
@@ -39889,7 +40438,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject(parseResult.error);
               } else {
-                resolve3(parseResult.data);
+                resolve4(parseResult.data);
               }
             } catch (error48) {
               reject(error48);
@@ -40150,12 +40699,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           if (signal.aborted) {
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve3, interval);
+          const timeoutId = setTimeout(resolve4, interval);
           signal.addEventListener("abort", () => {
             clearTimeout(timeoutId);
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -43182,7 +43731,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -43209,7 +43758,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -43784,7 +44333,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -44011,7 +44560,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve3,
+      resolve: resolve4,
       resolveComponent,
       equal,
       serialize,
@@ -48135,7 +48684,7 @@ var init_mcp = __esm({
         let task = createTaskResult.task;
         const pollInterval = task.pollInterval ?? 5e3;
         while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-          await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+          await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
           const updatedTask = await extra.taskStore.getTask(taskId);
           if (!updatedTask) {
             throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -48726,12 +49275,12 @@ var init_stdio2 = __esm({
         this.onclose?.();
       }
       send(message) {
-        return new Promise((resolve3) => {
+        return new Promise((resolve4) => {
           const json2 = serializeMessage(message);
           if (this._stdout.write(json2)) {
-            resolve3();
+            resolve4();
           } else {
-            this._stdout.once("drain", resolve3);
+            this._stdout.once("drain", resolve4);
           }
         });
       }
@@ -48745,7 +49294,7 @@ __export(server_exports, {
   startMcpServer: () => startMcpServer
 });
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { pathToFileURL as pathToFileURL3, fileURLToPath as fileURLToPath5 } from "node:url";
 function filterBySeverity2(diagnostics, minSeverity) {
   const minIdx = SEVERITY_ORDER2.indexOf(minSeverity);
@@ -48763,9 +49312,9 @@ async function resolveFiles(pattern, cwd) {
   return [...new Set(matches)];
 }
 function findConfigRoot(files) {
-  const dirs = files.map((f) => resolve2(f, ".."));
+  const dirs = files.map((f) => resolve3(f, ".."));
   let configRoot = dirs.reduce((a, b) => {
-    while (!b.startsWith(a)) a = resolve2(a, "..");
+    while (!b.startsWith(a)) a = resolve3(a, "..");
     return a;
   });
   let search = configRoot;
@@ -48774,7 +49323,7 @@ function findConfigRoot(files) {
       configRoot = search;
       break;
     }
-    const parent = resolve2(search, "..");
+    const parent = resolve3(search, "..");
     if (parent === search) break;
     search = parent;
   }
@@ -48783,7 +49332,7 @@ function findConfigRoot(files) {
 function createWorkspace(files) {
   const configRoot = findConfigRoot(files);
   const projectConfig = loadConfigFromDisk(configRoot);
-  const workspace = new WorkspaceModel();
+  const workspace = new WorkspaceModel({ workspaceRoot: configRoot });
   const fileContents = /* @__PURE__ */ new Map();
   for (const filePath of files) {
     try {
@@ -48795,7 +49344,7 @@ function createWorkspace(files) {
   }
   workspace.initialize(fileContents);
   if (Object.keys(projectConfig.macros).length > 0) {
-    workspace.macros.loadSupplements(projectConfig.macros);
+    workspace.macros.loadConfig(projectConfig.macros);
   }
   return workspace;
 }
@@ -49976,8 +50525,8 @@ var require_semaphore = __commonJS({
         this._waiting = [];
       }
       lock(thunk) {
-        return new Promise((resolve3, reject) => {
-          this._waiting.push({ thunk, resolve: resolve3, reject });
+        return new Promise((resolve4, reject) => {
+          this._waiting.push({ thunk, resolve: resolve4, reject });
           this.runNext();
         });
       }
@@ -51467,9 +52016,9 @@ ${JSON.stringify(message, null, 4)}`);
           if (typeof cancellationStrategy.sender.enableCancellation === "function") {
             cancellationStrategy.sender.enableCancellation(requestMessage);
           }
-          return new Promise(async (resolve3, reject) => {
+          return new Promise(async (resolve4, reject) => {
             const resolveWithCleanup = (r) => {
-              resolve3(r);
+              resolve4(r);
               cancellationStrategy.sender.cleanup(id);
               disposable?.dispose();
             };
@@ -51880,10 +52429,10 @@ var require_ril = __commonJS({
         return api_1.Disposable.create(() => this.stream.off("end", listener));
       }
       write(data, encoding) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           const callback = (error48) => {
             if (error48 === void 0 || error48 === null) {
-              resolve3();
+              resolve4();
             } else {
               reject(error48);
             }
@@ -52135,10 +52684,10 @@ var require_main = __commonJS({
     exports.generateRandomPipeName = generateRandomPipeName;
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve3, _reject) => {
-        connectResolve = resolve3;
+      const connected = new Promise((resolve4, _reject) => {
+        connectResolve = resolve4;
       });
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve4, reject) => {
         let server = (0, net_1.createServer)((socket) => {
           server.close();
           connectResolve([
@@ -52149,7 +52698,7 @@ var require_main = __commonJS({
         server.on("error", reject);
         server.listen(pipeName, () => {
           server.removeListener("error", reject);
-          resolve3({
+          resolve4({
             onConnected: () => {
               return connected;
             }
@@ -52168,10 +52717,10 @@ var require_main = __commonJS({
     exports.createServerPipeTransport = createServerPipeTransport;
     function createClientSocketTransport(port, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve3, _reject) => {
-        connectResolve = resolve3;
+      const connected = new Promise((resolve4, _reject) => {
+        connectResolve = resolve4;
       });
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve4, reject) => {
         const server = (0, net_1.createServer)((socket) => {
           server.close();
           connectResolve([
@@ -52182,7 +52731,7 @@ var require_main = __commonJS({
         server.on("error", reject);
         server.listen(port, "127.0.0.1", () => {
           server.removeListener("error", reject);
-          resolve3({
+          resolve4({
             onConnected: () => {
               return connected;
             }
@@ -56968,8 +57517,8 @@ var require_server = __commonJS({
         if (value instanceof Promise) {
           return value;
         } else if (Is.thenable(value)) {
-          return new Promise((resolve3, reject) => {
-            value.then((resolved) => resolve3(resolved), (error48) => reject(error48));
+          return new Promise((resolve4, reject) => {
+            value.then((resolved) => resolve4(resolved), (error48) => reject(error48));
           });
         } else {
           return Promise.resolve(value);
@@ -57239,7 +57788,7 @@ var require_files = __commonJS({
     function isWindows() {
       return process.platform === "win32";
     }
-    function resolve3(moduleName, nodePath, cwd, tracer) {
+    function resolve4(moduleName, nodePath, cwd, tracer) {
       const nodePathKey = "NODE_PATH";
       const app = [
         "var p = process;",
@@ -57258,7 +57807,7 @@ var require_files = __commonJS({
         "}",
         "});"
       ].join("");
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve5, reject) => {
         let env = process.env;
         let newEnv = /* @__PURE__ */ Object.create(null);
         Object.keys(env).forEach((key) => newEnv[key] = env[key]);
@@ -57290,7 +57839,7 @@ var require_files = __commonJS({
             if (message2.c === "r") {
               cp.send({ c: "e" });
               if (message2.s) {
-                resolve4(message2.r);
+                resolve5(message2.r);
               } else {
                 reject(new Error(`Failed to resolve module: ${moduleName}`));
               }
@@ -57306,7 +57855,7 @@ var require_files = __commonJS({
         }
       });
     }
-    exports.resolve = resolve3;
+    exports.resolve = resolve4;
     function resolveGlobalNodePath(tracer) {
       let npmCommand = "npm";
       const env = /* @__PURE__ */ Object.create(null);
@@ -57421,17 +57970,17 @@ var require_files = __commonJS({
         if (!path2.isAbsolute(nodePath)) {
           nodePath = path2.join(workspaceRoot, nodePath);
         }
-        return resolve3(moduleName, nodePath, nodePath, tracer).then((value) => {
+        return resolve4(moduleName, nodePath, nodePath, tracer).then((value) => {
           if (FileSystem.isParent(nodePath, value)) {
             return value;
           } else {
             return Promise.reject(new Error(`Failed to load ${moduleName} from node path location.`));
           }
         }).then(void 0, (_error) => {
-          return resolve3(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+          return resolve4(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
         });
       } else {
-        return resolve3(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+        return resolve4(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
       }
     }
     exports.resolveModulePath = resolveModulePath;
@@ -58061,7 +58610,7 @@ function getCompletions(uri, position, triggerChar, workspace) {
   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);
+    return getClosingMacroCompletions(uri, text, position, workspace);
   }
   const transientDotPathMatch = /%([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)?$/.exec(lineText);
   if (transientDotPathMatch) {
@@ -58091,11 +58640,18 @@ function getCompletions(uri, position, triggerChar, workspace) {
   }
   return [];
 }
-function getClosingMacroCompletions(text, position, workspace) {
+function getClosingMacroCompletions(uri, text, position, workspace) {
+  const passages = workspace.passages.getPassagesInDocument(uri);
   const macros = parseMacros(text);
-  pairMacros(macros, (name) => workspace.macros.isBlock(name));
+  pairMacros(
+    macros,
+    (name) => workspace.macros.isBlock(name),
+    passages.map((p) => p.range.start.line)
+  );
+  const passageStart = workspace.passages.getPassageAt(uri, position.line)?.range.start.line ?? 0;
   const openStack = [];
   for (const macro of macros) {
+    if (macro.range.start.line < passageStart) continue;
     if (macro.range.start.line > position.line || macro.range.start.line === position.line && macro.range.start.character >= position.character) {
       break;
     }
@@ -58146,7 +58702,7 @@ function getMacroCompletions(workspace) {
       kind: 3,
       // CompletionItemKind.Function
       detail: `(widget) ${widget.name}`,
-      documentation: widget.params.length > 0 ? `Parameters: ${widget.params.map((p) => `@${p}`).join(", ")}` : void 0
+      documentation: widget.params.length > 0 ? `Parameters: ${widget.params.join(", ")}` : void 0
     });
   }
   return items;
@@ -58421,7 +58977,7 @@ function getWidgetHover(line, position, workspace) {
   return null;
 }
 function buildWidgetHover(widget, line, nameStart, nameEnd) {
-  const sig = widget.params.length > 0 ? widget.params.map((p) => `@${p}`).join(", ") : "no parameters";
+  const sig = widget.params.length > 0 ? widget.params.join(", ") : "no parameters";
   return {
     contents: `**Widget** \`${widget.name}\`
 
@@ -58495,7 +59051,7 @@ function getSignatureHelp(uri, position, workspace) {
   }
   const widget = workspace.widgets.getWidget(macroName);
   if (widget && widget.params.length > 0) {
-    const paramLabels = widget.params.map((p) => `@${p}`);
+    const paramLabels = widget.params;
     return {
       signatures: [{
         label: `{${macroName} ${paramLabels.join(", ")}}`,
@@ -58551,53 +59107,21 @@ function getDefinition(uri, position, workspace) {
   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 passageResult = getPassageRefDefinition(text, position, workspace);
+  if (passageResult) return passageResult;
   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 match2;
-    while ((match2 = pattern.exec(line)) !== null) {
-      const passageName = match2[1];
-      const nameStart = match2.index + match2[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 getPassageRefDefinition(text, position, workspace) {
+  const ref = findPassageRefAt(text, position);
+  if (!ref) return null;
+  const passage = workspace.passages.getPassage(ref.name);
+  if (!passage) return null;
+  return {
+    uri: passage.uri,
+    range: passage.headerEnd
+  };
 }
 function getWidgetDefinition(line, position, workspace) {
   const re = /\{([A-Za-z_$][\w$]*)/g;
@@ -58697,19 +59221,25 @@ function findReferences(uri, position, workspace, includeDeclaration) {
     }
   }
   {
-    const widgetRegex = /\{([A-Za-z_$][\w$]*)/g;
+    const widgetRegex = /\{\/?([A-Za-z_$][\w$]*)/g;
     let match2;
     while ((match2 = widgetRegex.exec(line)) !== null) {
       const name = match2[1];
-      const nameStart = match2.index + 1;
+      const nameStart = match2.index + match2[0].length - name.length;
       const nameEnd = nameStart + name.length;
       if (position.character >= nameStart && position.character <= nameEnd) {
-        if (!workspace.macros.getMacro(name) && workspace.widgets.getWidget(name)) {
+        const widget = workspace.widgets.getWidget(name);
+        const isClosing = match2[0][1] === "/";
+        if (!workspace.macros.getMacro(name) && widget && (!isClosing || widget.block)) {
           return findWidgetReferences(name, workspace, includeDeclaration);
         }
       }
     }
   }
+  const passageRef = findPassageRefAt(text, position);
+  if (passageRef) {
+    return findPassageReferences(passageRef.name, workspace, includeDeclaration);
+  }
   {
     const allPassages = workspace.passages.getAllPassages();
     const passageNames = new Set(allPassages.map((p) => p.name));
@@ -58735,39 +59265,16 @@ function findPassageReferences(passageName, workspace, includeDeclaration) {
     if (passage) {
       locations.push({
         uri: passage.uri,
-        range: passage.headerEnd
+        range: passage.nameRange
       });
     }
   }
-  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 match2;
-        while ((match2 = regex.exec(line)) !== null) {
-          if (match2[1] === passageName) {
-            const nameStart = match2.index + match2[0].indexOf(match2[1]);
-            locations.push({
-              uri: docUri,
-              range: {
-                start: { line: lineNum, character: nameStart },
-                end: { line: lineNum, character: nameStart + match2[1].length }
-              }
-            });
-          }
-        }
+    for (const ref of [...parseLinks(docText), ...parseMacroPassageRefs(docText)]) {
+      if (ref.name === passageName) {
+        locations.push({ uri: docUri, range: ref.range });
       }
     }
   }
@@ -58806,30 +59313,30 @@ function findTransientReferences(varName, workspace, includeDeclaration) {
 }
 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 widget = workspace.widgets.getWidget(widgetName);
+  if (includeDeclaration && widget) {
+    locations.push({ uri: widget.uri, range: widget.range });
   }
-  const widgetInvocationRegex = /\{([A-Za-z_$][\w$]*)\b/g;
+  const widgetInvocationRegex = /\{(\/)?([A-Za-z_$][\w$]*)\b/g;
+  const lowerName = widgetName.toLowerCase();
+  const isBlock = widget?.block ?? false;
   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 match2;
       while ((match2 = widgetInvocationRegex.exec(line)) !== null) {
-        if (match2[1] === widgetName) {
-          const nameStart = match2.index + 1;
+        if (match2[1] && !isBlock) continue;
+        if (match2[2].toLowerCase() === lowerName) {
+          const nameStart = match2.index + 1 + (match2[1] ? 1 : 0);
           locations.push({
             uri: docUri,
             range: {
               start: { line: lineNum, character: nameStart },
-              end: { line: lineNum, character: nameStart + widgetName.length }
+              end: { line: lineNum, character: nameStart + match2[2].length }
             }
           });
         }
@@ -58897,10 +59404,13 @@ function computeRename(uri, position, newName, workspace) {
     }
     case "variable": {
       const bareName = newName.startsWith("$") ? newName.slice(1) : newName.startsWith("%") ? newName.slice(1) : newName;
-      const isTransient = workspace.variables.getDeclaredTransient().has(symbol2.name);
-      const refs = isTransient ? findTransientReferences(symbol2.name, workspace, true) : findVariableReferences(symbol2.name, workspace, true);
+      const refs = symbol2.sigil === "%" ? findTransientReferences(symbol2.name, workspace, true) : findVariableReferences(symbol2.name, workspace, true);
       for (const ref of refs) {
-        addEdit(ref.uri, ref.range, bareName);
+        const start = ref.range.start.character + 1;
+        addEdit(ref.uri, {
+          start: { line: ref.range.start.line, character: start },
+          end: { line: ref.range.start.line, character: start + symbol2.name.length }
+        }, bareName);
       }
       break;
     }
@@ -58911,23 +59421,7 @@ function computeRename(uri, position, newName, workspace) {
       }
       const widget = workspace.widgets.getWidget(symbol2.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 + symbol2.name.length }
-              }, newName);
-            }
-          }
-        }
+        addEdit(widget.uri, widget.nameRange, newName);
       }
       break;
     }
@@ -58969,6 +59463,7 @@ function resolveSymbolAtCursor(uri, position, workspace) {
         return {
           kind: "variable",
           name: match2[1],
+          sigil: "$",
           range: {
             start: { line: position.line, character: start },
             end: { line: position.line, character: end }
@@ -58987,6 +59482,7 @@ function resolveSymbolAtCursor(uri, position, workspace) {
         return {
           kind: "variable",
           name: match2[1],
+          sigil: "%",
           range: {
             start: { line: position.line, character: start },
             end: { line: position.line, character: end }
@@ -58995,34 +59491,23 @@ function resolveSymbolAtCursor(uri, position, workspace) {
       }
     }
   }
-  {
-    const widgetDefRegex2 = /\{widget\s+"([^"]+)"/gi;
-    let match2;
-    while ((match2 = widgetDefRegex2.exec(line)) !== null) {
-      const name = match2[1];
-      const nameStart = match2.index + match2[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 }
-          }
-        };
-      }
+  for (const widget of workspace.widgets.getAllWidgets()) {
+    const { start, end } = widget.nameRange;
+    if (widget.uri === uri && position.line === start.line && position.character >= start.character && position.character <= end.character) {
+      return { kind: "widget", name: widget.name, range: widget.nameRange };
     }
   }
   {
-    const re = /\{([A-Za-z_$][\w$]*)/g;
+    const re = /\{\/?([A-Za-z_$][\w$]*)/g;
     let match2;
     while ((match2 = re.exec(line)) !== null) {
       const name = match2[1];
-      const nameStart = match2.index + 1;
+      const nameStart = match2.index + match2[0].length - name.length;
       const nameEnd = nameStart + name.length;
       if (position.character >= nameStart && position.character <= nameEnd) {
-        if (!workspace.macros.getMacro(name) && workspace.widgets.getWidget(name)) {
+        const widget = workspace.widgets.getWidget(name);
+        const isClosing = match2[0][1] === "/";
+        if (!workspace.macros.getMacro(name) && widget && (!isClosing || widget.block)) {
           return {
             kind: "widget",
             name,
@@ -59116,7 +59601,7 @@ function computeCodeLenses(uri, workspace) {
       });
       continue;
     }
-    const widgetMatch = line.match(/\{widget\s+"([^"]+)"/);
+    const widgetMatch = line.match(/\{widget\s+["']?([^\s"'}]+)/);
     if (widgetMatch) {
       const widgetName = widgetMatch[1];
       const refs = findWidgetReferences(widgetName, workspace, true);
@@ -59196,34 +59681,24 @@ function computeInlayHints(uri, range2, workspace) {
   return hints;
 }
 function addWidgetParamHints(text, range2, workspace, hints) {
-  const allWidgets = workspace.widgets.getAllWidgets();
-  if (allWidgets.length === 0) return;
-  const widgetMap = new Map(allWidgets.map((w) => [w.name, w]));
+  if (workspace.widgets.getAllWidgets().length === 0) return;
   const macros = parseMacros(text);
+  const lineStarts = buildLineStarts(text);
   for (const macro of macros) {
     if (!macro.open) continue;
     if (macro.range.start.line < range2.start.line || macro.range.start.line > range2.end.line) continue;
-    const widget = widgetMap.get(macro.name);
+    const widget = workspace.widgets.getWidget(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;
+    const macroEnd = lineStarts[macro.range.end.line] + macro.range.end.character;
+    const argsStart = macroEnd - 1 - macro.rawArgs.length;
     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"
-        });
-      }
+      hints.push({
+        position: offsetToPosition(argsStart + args2[i].start, lineStarts),
+        label: `${widget.params[i]}:`,
+        kind: "parameter"
+      });
     }
   }
 }
@@ -59506,12 +59981,15 @@ var init_semantic_tokens = __esm({
 });
 
 // src/plugins/code-actions.ts
-function computeCodeActions(uri, diagnostics, workspace) {
+import { readFileSync as readFileSync7 } from "node:fs";
+import { basename, dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL4 } from "node:url";
+function computeCodeActions(uri, diagnostics, workspace, options = {}) {
   const actions = [];
   for (const diag of diagnostics) {
     switch (diag.code) {
       case DiagnosticCode.UndefinedMacro: {
-        const action = fixUndefinedMacro(diag);
+        const action = fixUndefinedMacro(uri, diag, workspace, options);
         if (action) actions.push(action);
         break;
       }
@@ -59539,27 +60017,141 @@ function computeCodeActions(uri, diagnostics, workspace) {
   }
   return actions;
 }
-function fixUndefinedMacro(diag) {
+function fixUndefinedMacro(uri, diag, workspace, options) {
   const match2 = diag.message.match(/\{(\w[\w-]*)\}/);
   if (!match2) return null;
   const macroName = match2[1];
-  const configUri = "file:///spindle.config.yaml";
-  const yamlSnippet = `
-  ${macroName}:
-    description: ""
-`;
-  return {
-    title: `Add '${macroName}' to spindle.config.yaml`,
+  const root = resolveConfigRoot(uri, options.workspaceRoot);
+  if (!root) return null;
+  const existingPath = findConfigFile(root);
+  const configPath = existingPath ?? join3(root, DEFAULT_CONFIG_FILENAME);
+  const configUri = pathToFileURL4(configPath).toString();
+  const action = {
+    title: `Add '${macroName}' to ${basename(configPath)}`,
     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
-    }]
+    diagnosticCodes: [DiagnosticCode.UndefinedMacro]
+  };
+  if (!existingPath) {
+    const start = { line: 0, character: 0 };
+    return {
+      ...action,
+      createFile: configUri,
+      edits: [{
+        uri: configUri,
+        range: { start, end: start },
+        newText: (0, import_yaml2.stringify)({ macros: { [macroName]: NEW_MACRO_ENTRY } })
+      }]
+    };
+  }
+  let text = workspace.documents.getText(configUri);
+  if (text === void 0) {
+    try {
+      text = readFileSync7(existingPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  const edit = configPath.toLowerCase().endsWith(".json") ? addMacroToJsonConfig(text, macroName) : addMacroToYamlConfig(text, macroName);
+  if (!edit) return null;
+  return { ...action, edits: [{ uri: configUri, ...edit }] };
+}
+function resolveConfigRoot(uri, workspaceRoot) {
+  if (workspaceRoot) {
+    return workspaceRoot.startsWith("file:") ? fileURLToPath6(workspaceRoot) : workspaceRoot;
+  }
+  if (!uri.startsWith("file:")) return null;
+  const docDir = dirname2(fileURLToPath6(uri));
+  let search = docDir;
+  for (let i = 0; i < 10; i++) {
+    if (findConfigFile(search)) return search;
+    const parent = dirname2(search);
+    if (parent === search) break;
+    search = parent;
+  }
+  return docDir;
+}
+function macrosPath(root) {
+  const legacy = root?.["spindle-0"];
+  return legacy !== null && typeof legacy === "object" ? ["spindle-0", "macros"] : ["macros"];
+}
+function definesMacro(macros, macroName) {
+  if (macros === null || typeof macros !== "object") return false;
+  const lower = macroName.toLowerCase();
+  return Object.keys(macros).some((k) => k.toLowerCase() === lower);
+}
+function addMacroToYamlConfig(text, macroName) {
+  const doc = (0, import_yaml2.parseDocument)(text);
+  if (doc.errors.length > 0) return null;
+  if (doc.contents !== null && !(0, import_yaml2.isMap)(doc.contents)) return null;
+  const path2 = macrosPath(doc.toJS());
+  const parent = path2.length > 1 ? doc.getIn(path2.slice(0, -1), true) : doc.contents;
+  const macros = doc.getIn(path2, true);
+  if ((0, import_yaml2.isMap)(macros) && definesMacro(macros.toJS(doc), macroName)) return null;
+  if ((0, import_yaml2.isMap)(parent) && (0, import_yaml2.isMap)(macros) && !macros.flow && macros.items.length > 0 && macros.range) {
+    const macrosKey = parent.items.find((p) => (0, import_yaml2.isScalar)(p.key) && p.key.value === "macros")?.key;
+    const firstKey = macros.items[0].key;
+    if ((0, import_yaml2.isScalar)(macrosKey) && macrosKey.range && (0, import_yaml2.isScalar)(firstKey) && firstKey.range) {
+      const indent = columnOf(text, firstKey.range[0]);
+      const step = Math.max(indent - columnOf(text, macrosKey.range[0]), 1);
+      const entry = (0, import_yaml2.stringify)({ [macroName]: NEW_MACRO_ENTRY }, { indent: step }).replace(/^(?=.)/gm, " ".repeat(indent));
+      let offset = macros.range[1];
+      if (offset > 0 && text[offset - 1] !== "\n") {
+        const nl = text.indexOf("\n", offset);
+        offset = nl === -1 ? text.length : nl + 1;
+      }
+      const lead = offset === text.length && text.length > 0 && !text.endsWith("\n") ? "\n" : "";
+      const pos = offsetToPosition2(text, offset);
+      return { range: { start: pos, end: pos }, newText: lead + entry };
+    }
+  }
+  if ((0, import_yaml2.isMap)(macros)) {
+    macros.set(macroName, doc.createNode(NEW_MACRO_ENTRY));
+  } else {
+    doc.setIn(path2, doc.createNode({ [macroName]: NEW_MACRO_ENTRY }));
+  }
+  return minimalEdit(text, doc.toString({ lineWidth: 0 }));
+}
+function addMacroToJsonConfig(text, macroName) {
+  let raw;
+  try {
+    raw = text.trim() ? JSON.parse(text) : {};
+  } catch {
+    return null;
+  }
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const path2 = macrosPath(raw);
+  const container = path2.length > 1 ? raw[path2[0]] : raw;
+  const macros = container.macros;
+  if (definesMacro(macros, macroName)) return null;
+  if (macros !== null && typeof macros === "object" && !Array.isArray(macros)) {
+    macros[macroName] = NEW_MACRO_ENTRY;
+  } else {
+    container.macros = { [macroName]: NEW_MACRO_ENTRY };
+  }
+  const indent = text.match(/^[ \t]+(?=")/m)?.[0] ?? "  ";
+  const newline = text.endsWith("\n") || !text.trim() ? "\n" : "";
+  return minimalEdit(text, JSON.stringify(raw, null, indent) + newline);
+}
+function columnOf(text, offset) {
+  return offset - (text.lastIndexOf("\n", offset - 1) + 1);
+}
+function offsetToPosition2(text, offset) {
+  const before = text.slice(0, offset);
+  const lineStart = before.lastIndexOf("\n") + 1;
+  return { line: before.split("\n").length - 1, character: offset - lineStart };
+}
+function minimalEdit(oldText, newText) {
+  const max = Math.min(oldText.length, newText.length);
+  let prefix = 0;
+  while (prefix < max && oldText[prefix] === newText[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < max - prefix && oldText[oldText.length - 1 - suffix] === newText[newText.length - 1 - suffix]) suffix++;
+  return {
+    range: {
+      start: offsetToPosition2(oldText, prefix),
+      end: offsetToPosition2(oldText, oldText.length - suffix)
+    },
+    newText: newText.slice(prefix, newText.length - suffix)
   };
 }
 function fixUndeclaredVariable(diag, workspace) {
@@ -59669,11 +60261,15 @@ function toLspRange6(r) {
     end: { line: r.end.line, character: r.end.character }
   };
 }
-var codeActionsPlugin;
+var import_yaml2, DEFAULT_CONFIG_FILENAME, NEW_MACRO_ENTRY, codeActionsPlugin;
 var init_code_actions = __esm({
   "src/plugins/code-actions.ts"() {
     "use strict";
+    import_yaml2 = __toESM(require_dist(), 1);
     init_diagnostic_codes();
+    init_config_loader();
+    DEFAULT_CONFIG_FILENAME = "spindle.config.yaml";
+    NEW_MACRO_ENTRY = { description: "" };
     codeActionsPlugin = {
       id: "code-actions",
       capabilities: {
@@ -59696,7 +60292,8 @@ var init_code_actions = __esm({
           const actions = computeCodeActions(
             params.textDocument.uri,
             diagnostics,
-            ctx.workspace
+            ctx.workspace,
+            { workspaceRoot: ctx.config.workspaceRoot }
           );
           return actions.map((a) => ({
             title: a.title,
@@ -59704,7 +60301,16 @@ var init_code_actions = __esm({
             diagnostics: params.context.diagnostics.filter(
               (d) => a.diagnosticCodes.includes(String(d.code))
             ),
-            edit: {
+            edit: a.createFile ? {
+              // Resource operations are only expressible via documentChanges
+              documentChanges: [
+                { kind: "create", uri: a.createFile, options: { ignoreIfExists: true } },
+                ...a.edits.map((e) => ({
+                  textDocument: { uri: e.uri, version: null },
+                  edits: [{ range: toLspRange6(e.range), newText: e.newText }]
+                }))
+              ]
+            } : {
               changes: Object.fromEntries(
                 a.edits.map((e) => [
                   e.uri,
@@ -59744,7 +60350,7 @@ function computeDocumentSymbols(uri, workspace) {
     if (passage.tags?.includes("widget")) {
       const contentStart = passage.range.start.line + 1;
       const contentEnd = passage.range.end.line + 1;
-      const widgetDefRegex2 = /\{widget\s+"([^"]+)"[^}]*\}/gi;
+      const widgetDefRegex2 = /\{widget\s+["']?([^\s"'}]+)["']?[^}]*\}/gi;
       for (let i = contentStart; i < contentEnd && i < lines.length; i++) {
         widgetDefRegex2.lastIndex = 0;
         let match2;
@@ -59849,14 +60455,19 @@ function searchWorkspaceSymbols(query, workspace) {
       range: widget.range
     });
   }
-  for (const [name, decl] of workspace.variables.getDeclared()) {
-    const displayName = "$" + name;
+  const declarations = [
+    ...workspace.variables.getDeclared().values(),
+    ...workspace.variables.getDeclaredTransient().values()
+  ];
+  for (const decl of declarations) {
+    const displayName = decl.sigil + decl.name;
     if (lowerQuery && !displayName.toLowerCase().includes(lowerQuery)) continue;
+    if (!decl.declarationUri || !decl.declarationRange) continue;
     results.push({
       name: displayName,
       kind: import_vscode_languageserver3.SymbolKind.Variable,
-      uri: decl.declarationUri ?? "",
-      range: decl.declarationRange ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+      uri: decl.declarationUri,
+      range: decl.declarationRange
     });
   }
   return results;
@@ -59912,7 +60523,11 @@ function computeFoldingRanges(uri, workspace) {
     }
   }
   const macros = parseMacros(text);
-  pairMacros(macros, (name) => workspace.macros.isBlock(name));
+  pairMacros(
+    macros,
+    (name) => workspace.macros.isBlock(name),
+    passages.map((p) => p.range.start.line)
+  );
   for (const macro of macros) {
     if (macro.open && macro.pair !== -1) {
       const closingMacro = macros[macro.pair];
@@ -60059,17 +60674,22 @@ var server_exports2 = {};
 __export(server_exports2, {
   startServer: () => startServer
 });
-import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL4 } from "node:url";
-import { readFileSync as readFileSync7 } from "node:fs";
+import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL5 } from "node:url";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { basename as basename2 } from "node:path";
 function uriToFsPath(uri) {
   try {
-    return fileURLToPath6(uri);
+    return fileURLToPath7(uri);
   } catch {
     return uri;
   }
 }
 function fsPathToUri(fsPath) {
-  return pathToFileURL4(fsPath).toString();
+  return pathToFileURL5(fsPath).toString();
+}
+function isConfigFileUri(uri) {
+  const name = basename2(uriToFsPath(uri));
+  return name.startsWith("spindle.config.") || name.includes("twee-config.");
 }
 function startServer(_args) {
   const connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
@@ -60087,15 +60707,17 @@ function startServer(_args) {
       diagnostics: initOptions.diagnostics,
       workspaceRoot
     };
-    workspace = new WorkspaceModel();
+    workspace = new WorkspaceModel(workspaceRoot ? { workspaceRoot } : void 0);
     console.error("[spindle-lsp] workspaceRoot:", workspaceRoot ?? "undefined");
+    console.error("[spindle-lsp] builtin macros:", workspace.macros.builtinsPath ?? "not found");
+    for (const warning of workspace.macros.warnings) console.error("[spindle-lsp]", warning);
     activePlugins = loadPlugins(allPlugins, config2);
     console.error("[spindle-lsp] plugins loaded:", activePlugins.map((p) => p.id).join(", "));
     for (const plugin of activePlugins) {
       plugin.initialize({ connection, workspace, config: config2 });
     }
     if (Object.keys(projectConfig.macros).length > 0) {
-      workspace.macros.loadSupplements(projectConfig.macros);
+      workspace.macros.loadConfig(projectConfig.macros);
       console.error("[spindle-lsp] loaded config macros:", Object.keys(projectConfig.macros).length);
     }
     return {
@@ -60119,6 +60741,9 @@ function startServer(_args) {
         try {
           const fileContents = await scanWorkspaceFiles(workspaceRoot);
           console.error("[spindle-lsp] scanned", fileContents.size, "files from root:", workspaceRoot ?? "undefined");
+          for (const uri of documents.keys()) {
+            fileContents.delete(uri);
+          }
           workspace.initialize(fileContents);
           console.error("[spindle-lsp] workspace initialized, macros:", workspace.macros.getAllMacros().length);
         } catch (err) {
@@ -60158,23 +60783,40 @@ function startServer(_args) {
     if (workspace) {
       try {
         const fsPath = uriToFsPath(textDocument.uri);
-        const text = readFileSync7(fsPath, "utf-8");
+        const text = readFileSync8(fsPath, "utf-8");
         workspace.documents.update(textDocument.uri, text);
       } catch {
         workspace.documents.close(textDocument.uri);
       }
     }
   });
+  function reloadProjectConfig() {
+    if (!workspaceRoot) return;
+    try {
+      const projectConfig = loadConfigFromDisk(workspaceRoot);
+      workspace.macros.loadConfig(projectConfig.macros);
+      console.error("[spindle-lsp] reloaded config macros:", Object.keys(projectConfig.macros).length);
+    } catch (err) {
+      console.error("[spindle-lsp] config reload failed:", err);
+      return;
+    }
+    workspace.refresh();
+  }
   connection.onDidChangeWatchedFiles(({ changes }) => {
     if (!workspace) return;
+    let configChanged = false;
     for (const change of changes) {
+      if (isConfigFileUri(change.uri)) {
+        configChanged = true;
+        continue;
+      }
+      if (documents.has(change.uri)) continue;
       if (change.type === import_node.FileChangeType.Deleted) {
         workspace.documents.close(change.uri);
-        documents.delete(change.uri);
       } else {
         try {
           const fsPath = uriToFsPath(change.uri);
-          const text = readFileSync7(fsPath, "utf-8");
+          const text = readFileSync8(fsPath, "utf-8");
           if (workspace.documents.has(change.uri)) {
             workspace.documents.update(change.uri, text);
           } else {
@@ -60184,6 +60826,9 @@ function startServer(_args) {
         }
       }
     }
+    if (configChanged) {
+      reloadProjectConfig();
+    }
   });
   connection.onShutdown(() => {
     for (const plugin of activePlugins) {
@@ -60204,7 +60849,7 @@ async function scanWorkspaceFiles(root) {
     });
     for (const filePath of files) {
       try {
-        const text = readFileSync7(filePath, "utf-8");
+        const text = readFileSync8(filePath, "utf-8");
         const uri = fsPathToUri(filePath);
         contents.set(uri, text);
       } catch {
@@ -60231,7 +60876,7 @@ var init_server4 = __esm({
 
 // src/bin.ts
 var args = process.argv.slice(2);
-var VERSION = "0.9.0";
+var VERSION = "0.9.2";
 var HELP = `spindle-lsp v${VERSION}
 Language Server Protocol server for Spindle story format