@rohal12/spindle-lsp 0.9.0 → 0.9.1

package/dist/bin.js

@@ -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
@@ -6443,6 +6448,12 @@ var init_macro_registry = __esm({
     "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();
       /**
        * Load built-in macro metadata from @rohal12/spindle's macro-registry.json.
        * This is the base layer that provides name, block, subMacros, flags, source.
@@ -6499,10 +6510,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,20 +6592,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));
+      }
+      /**
+       * Compose the effective entry for a lowercase key: builtins/supplements/
+       * config (stored in `macros`), overlaid by discovered metadata, with user
+       * config re-applied on top so it keeps precedence.
+       */
+      resolve(key) {
+        const base = this.macros.get(key);
+        const found = this.discovered.get(key);
+        if (!found) return base;
+        const info = {
+          ...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 info;
       }
       /**
        * Walk up directory tree from `startDir` to find the
@@ -6647,6 +6749,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 +6818,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 +6830,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 +6842,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 +6862,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 +6890,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 +6902,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 +6936,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 +7104,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 +7237,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 +7307,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 +7605,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 +7615,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 +7666,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 +7723,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;
@@ -7517,6 +7771,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 +7796,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 +7805,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 +7819,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 +7871,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 +7890,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 +8652,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 +8828,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 resolve3 = macroTargetResolvers[macro.name.toLowerCase()];
+    if (!resolve3) continue;
+    const argsEnd = lineStarts[macro.range.end.line] + macro.range.end.character - 1;
+    const argsStart = argsEnd - macro.rawArgs.length;
+    const target = resolve3(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 +9009,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 +9031,7 @@ function computeDiagnostics(uri, workspace, options) {
     } catch {
     }
     try {
-      validateLinks(text, passages, passageNames, diagnostics);
+      validateLinks(markupText, passages, passageNames, diagnostics);
     } catch {
     }
     try {
@@ -8620,6 +9065,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 +9189,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 +9235,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 +9346,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 +9422,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 +9491,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 +9502,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 +9530,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 +9556,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 +9607,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 +9616,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 +9636,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 +9671,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 +9695,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 +9707,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 +13812,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 +13850,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 +13890,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 +13913,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 +13945,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 +13961,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 +15244,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 +15328,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 +16841,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 +16867,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 +16903,7 @@ var require_public_api = __commonJS({
     }
     exports.parse = parse3;
     exports.parseAllDocuments = parseAllDocuments;
-    exports.parseDocument = parseDocument;
+    exports.parseDocument = parseDocument2;
     exports.stringify = stringify;
   }
 });
@@ -16515,6 +16993,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) {
@@ -16782,6 +17276,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(resolve(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,12 +17305,12 @@ async function runCheck(args2) {
     }
     return 0;
   }
-  let configRoot;
-  if (options.configPath) {
-    configRoot = resolve(cwd, options.configPath, "..");
+  let projectConfig;
+  if (explicitConfig) {
+    projectConfig = explicitConfig;
   } else {
     const dirs = uniqueFiles.map((f) => resolve(f, ".."));
-    configRoot = dirs.reduce((a, b) => {
+    let configRoot = dirs.reduce((a, b) => {
       while (!b.startsWith(a)) a = resolve(a, "..");
       return a;
     });
@@ -16821,8 +17324,8 @@ async function runCheck(args2) {
       if (parent === search) break;
       search = parent;
     }
+    projectConfig = loadConfigFromDisk(configRoot);
   }
-  const projectConfig = loadConfigFromDisk(configRoot);
   const workspace = new WorkspaceModel();
   const fileContents = /* @__PURE__ */ new Map();
   for (const filePath of uniqueFiles) {
@@ -16835,7 +17338,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 +17425,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 +17444,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 +17672,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 +17720,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 +17764,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 +17793,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 +17831,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 +17938,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 +17999,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 +18011,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: {
@@ -48795,7 +49353,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;
 }
@@ -58061,7 +58619,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 +58649,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 +58711,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 +58986,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 +59060,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 +59116,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 +59230,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 +59274,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 +59322,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 +59413,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 +59430,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 +59472,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 +59491,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 +59500,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 +59610,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 +59690,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 +59990,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 +60026,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 +60270,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 +60301,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 +60310,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 +60359,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 +60464,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 +60532,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 +60683,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);
@@ -60095,7 +60724,7 @@ function startServer(_args) {
       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 +60748,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 +60790,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 +60833,9 @@ function startServer(_args) {
         }
       }
     }
+    if (configChanged) {
+      reloadProjectConfig();
+    }
   });
   connection.onShutdown(() => {
     for (const plugin of activePlugins) {
@@ -60204,7 +60856,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 +60883,7 @@ var init_server4 = __esm({
 
 // src/bin.ts
 var args = process.argv.slice(2);
-var VERSION = "0.9.0";
+var VERSION = "0.9.1";
 var HELP = `spindle-lsp v${VERSION}
 Language Server Protocol server for Spindle story format