@rohal12/spindle-lsp 0.9.3 → 0.11.0

package/dist/bin.js

@@ -6694,7 +6694,7 @@ var init_macro_registry = __esm({
   }
 });
 
-// src/core/parsing/macro-parser.ts
+// src/core/parsing/code-scanner.ts
 function buildCodeScanner(input, from) {
   const n = input.length;
   const close = new Int32Array(n + 2).fill(-1);
@@ -6745,6 +6745,293 @@ function buildCodeScanner(input, from) {
 function createCodeScanner(input) {
   return buildCodeScanner(input, 0);
 }
+var NON_STRING_QUOTE_PREFIX;
+var init_code_scanner = __esm({
+  "src/core/parsing/code-scanner.ts"() {
+    "use strict";
+    NON_STRING_QUOTE_PREFIX = /[\p{L}\p{N}_\\]/u;
+  }
+});
+
+// src/core/parsing/html-scanner.ts
+function plainBraceMatches(input) {
+  const match2 = new Int32Array(input.length).fill(-1);
+  const open = [];
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] === "{") open.push(i);
+    else if (input[i] === "}" && open.length > 0) match2[open.pop()] = i;
+  }
+  return match2;
+}
+function scanHtmlTags(text) {
+  const n = text.length;
+  const tags = [];
+  const macros = [];
+  const code = createCodeScanner(text);
+  const plain = plainBraceMatches(text);
+  const rawBodies = [];
+  let doCloses;
+  let nextDoClose = 0;
+  const rawBody = (end) => {
+    doCloses ??= [...text.matchAll(/\{\/do\s*\}/gi)].map((match2) => match2.index);
+    while (nextDoClose < doCloses.length && doCloses[nextDoClose] < end) nextDoClose++;
+    if (nextDoClose < doCloses.length) rawBodies.push([end, doCloses[nextDoClose]]);
+  };
+  const rawBodyLimit = (limit2) => {
+    if (rawBodies.length === 0) return limit2;
+    const macroStarts = new Set(macros);
+    let t = 0;
+    for (const [start, close] of rawBodies) {
+      if (start >= limit2) break;
+      if (close < limit2 && !macroStarts.has(close)) {
+        limit2 = start;
+        break;
+      }
+      while (t < tags.length && tags[t].start < start) t++;
+      if (t < tags.length && tags[t].start < Math.min(close, limit2)) limit2 = tags[t].start;
+    }
+    return limit2;
+  };
+  const braceEnd = (open) => {
+    const close = code.closeBrace(open + 1);
+    if (close !== plain[open]) return GIVE_UP;
+    return close === -1 ? open + 1 : close + 1;
+  };
+  const displayEnd = (open, sigil) => {
+    let j = sigil + 1;
+    while (j < n && DISPLAY_NAME_CHAR.test(text[j])) j++;
+    return text[j] === "}" ? j + 1 : braceEnd(open);
+  };
+  const afterBrace = (i2) => {
+    let at = i2 + 1;
+    const selectors = text[at] === "." || text[at] === "#";
+    if (selectors) {
+      at = selectorsEnd(text, at);
+      if (text[at] === " ") at++;
+    }
+    const c3 = text[at];
+    if (c3 === "$" || c3 === "_" || c3 === "@" || c3 === "%") return displayEnd(i2, at);
+    if (c3 === void 0) return i2 + 1;
+    if (LETTER.test(c3) || c3 === "/" && !selectors) {
+      const end = braceEnd(i2);
+      if (end > i2 + 1) {
+        macros.push(i2);
+        if (/^do$/i.test(text.slice(at, end - 1).trim().split(/\s/)[0])) rawBody(end);
+      }
+      return end;
+    }
+    return i2 + 1;
+  };
+  const readTag = (i2) => {
+    let j = i2 + 1;
+    const isClose = text[j] === "/";
+    if (isClose) j++;
+    const nameStart = j;
+    while (j < n && TAG_NAME_CHAR.test(text[j])) j++;
+    const name = text.slice(nameStart, j);
+    if (!name || !LETTER.test(name[0])) return i2 + 1;
+    const isVoid = VOID_ELEMENTS.has(name.toLowerCase());
+    if (isClose) {
+      while (j < n && WHITESPACE.test(text[j])) j++;
+      if (text[j] !== ">") return i2 + 1;
+      if (!isVoid) tags.push({ name, kind: "close", start: i2, end: j + 1 });
+      return j + 1;
+    }
+    const attrs = readAttributes(j);
+    if (attrs.end === GIVE_UP) return GIVE_UP;
+    j = attrs.end;
+    let selfClosing = isVoid;
+    if (text[j] === "/") {
+      selfClosing = true;
+      j++;
+    }
+    if (text[j] === ">") {
+      tags.push({ name, kind: selfClosing ? "void" : "open", start: i2, end: j + 1, values: attrs.values });
+      return j + 1;
+    }
+    return attrs.count > 0 ? GIVE_UP : i2 + 1;
+  };
+  const readAttributes = (j) => {
+    let count = 0;
+    const values = [];
+    while (j < n) {
+      while (j < n && WHITESPACE.test(text[j])) j++;
+      if (j >= n || text[j] === ">" || text[j] === "/" && text[j + 1] === ">") break;
+      const nameStart = j;
+      while (j < n && ATTR_NAME_CHAR.test(text[j])) j++;
+      if (j === nameStart) break;
+      count++;
+      if (text[j] !== "=") continue;
+      j++;
+      const quote = text[j];
+      if (quote === '"' || quote === "'") {
+        const close = quotedValueEnd(j + 1, quote);
+        if (close === GIVE_UP) return { end: GIVE_UP, count, values };
+        values.push([j + 1, close]);
+        j = close < n ? close + 1 : close;
+      } else {
+        const start = j;
+        while (j < n && !WHITESPACE.test(text[j]) && text[j] !== ">") j++;
+        values.push([start, j]);
+      }
+    }
+    return { end: j, count, values };
+  };
+  const quotedValueEnd = (from, quote) => {
+    let depth = 0;
+    let sawBrace = false;
+    let k = from;
+    for (; k < n; k++) {
+      const c3 = text[k];
+      if (c3 === "{") {
+        depth++;
+        sawBrace = true;
+      } else if (c3 === "}") {
+        depth--;
+        sawBrace = true;
+      } else if (c3 === quote && depth <= 0) {
+        break;
+      }
+    }
+    if (!sawBrace) return k;
+    let d = from;
+    while (d < n) {
+      if (text[d] === "{") {
+        const close = code.closeBrace(d + 1);
+        if (close !== -1) {
+          d = close + 1;
+          continue;
+        }
+      } else if (text[d] === quote) {
+        break;
+      }
+      d++;
+    }
+    return d === k ? k : GIVE_UP;
+  };
+  let i = 0;
+  let stoppedAt = -1;
+  while (i < n) {
+    const c3 = text[i];
+    let next;
+    if (c3 === "\\") {
+      let k = i + 1;
+      while (text[k] === "\\") k++;
+      if (text[k] === "{" || text[k] === "}") next = (k - i) % 2 === 1 ? k + 1 : GIVE_UP;
+      else next = k;
+    } else if (c3 === "[" && text[i + 1] === "[") {
+      next = linkEnd(text, i);
+    } else if (c3 === "{") {
+      next = afterBrace(i);
+    } else if (c3 === "<") {
+      next = readTag(i);
+    } else {
+      next = i + 1;
+    }
+    if (next === GIVE_UP) {
+      stoppedAt = i;
+      break;
+    }
+    i = next;
+  }
+  const limit = rawBodyLimit(stoppedAt === -1 ? n : stoppedAt);
+  if (limit === stoppedAt || limit === n) return { tags, stoppedAt, macros };
+  return {
+    tags: tags.filter((tag) => tag.start < limit),
+    stoppedAt: limit,
+    macros: macros.filter((at) => at < limit)
+  };
+}
+function selectorsEnd(text, i) {
+  const n = text.length;
+  while (i < n && (text[i] === "." || text[i] === "#")) {
+    i++;
+    while (i < n) {
+      if (SELECTOR_NAME_CHAR.test(text[i])) {
+        i++;
+      } else if (text[i] === "{" && (text[i + 1] === "$" || text[i + 1] === "_" || text[i + 1] === "@")) {
+        let j = i + 2;
+        while (j < n && DISPLAY_NAME_CHAR.test(text[j])) j++;
+        if (text[j] !== "}") break;
+        i = j + 1;
+      } else {
+        break;
+      }
+    }
+  }
+  return i;
+}
+function linkEnd(text, i) {
+  const n = text.length;
+  let depth = 1;
+  let j = i + 2;
+  while (j < n) {
+    if (text[j] === "[" && text[j + 1] === "[") {
+      depth++;
+      j += 2;
+    } else if (text[j] === "]" && text[j + 1] === "]") {
+      if (--depth === 0) return j + 2;
+      j += 2;
+    } else {
+      j++;
+    }
+  }
+  return GIVE_UP;
+}
+function attributeValueSpans(text) {
+  const spans = [];
+  if (!text.includes("<")) return spans;
+  const headers = [...text.matchAll(/^::.*$/gm)];
+  const scan = (from2, to) => {
+    const content = text.slice(from2, to);
+    if (!content.includes("<")) return;
+    for (const tag of scanHtmlTags(content).tags) {
+      for (const [start, end] of tag.values ?? []) spans.push([from2 + start, from2 + end]);
+    }
+  };
+  let from = 0;
+  for (const header of headers) {
+    scan(from, header.index);
+    from = header.index + header[0].length;
+  }
+  scan(from, text.length);
+  return spans;
+}
+function inAttributeValue(text, offset) {
+  return attributeValueSpans(text).some(([start, end]) => start <= offset && offset < end);
+}
+var VOID_ELEMENTS, TAG_NAME_CHAR, LETTER, ATTR_NAME_CHAR, WHITESPACE, SELECTOR_NAME_CHAR, DISPLAY_NAME_CHAR, GIVE_UP;
+var init_html_scanner = __esm({
+  "src/core/parsing/html-scanner.ts"() {
+    "use strict";
+    init_code_scanner();
+    VOID_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    TAG_NAME_CHAR = /[a-zA-Z0-9-]/;
+    LETTER = /[a-zA-Z]/;
+    ATTR_NAME_CHAR = /[a-zA-Z0-9_\-:@]/;
+    WHITESPACE = /[^\S ]/;
+    SELECTOR_NAME_CHAR = /[a-zA-Z0-9_-]/;
+    DISPLAY_NAME_CHAR = /[\w.]/;
+    GIVE_UP = -2;
+  }
+});
+
+// src/core/parsing/macro-parser.ts
 function buildLineStarts(text) {
   const starts = [0];
   for (let i = 0; i < text.length; i++) {
@@ -6775,10 +7062,20 @@ function parseMacros(text) {
   const scanner = createCodeScanner(cleaned);
   const macros = [];
   let id = 0;
+  const attributeValues = attributeValueSpans(text);
+  let value = 0;
+  const inAttributeValue2 = (offset) => {
+    while (value < attributeValues.length && attributeValues[value][1] <= offset) value++;
+    return value < attributeValues.length && attributeValues[value][0] <= offset;
+  };
   macroHeadRegex.lastIndex = 0;
   let match2;
-  while ((match2 = macroHeadRegex.exec(cleaned)) !== null) {
+  while ((match2 = macroHeadRegex.exec(text)) !== null) {
     const matchStart = match2.index;
+    if (inAttributeValue2(matchStart)) {
+      macroHeadRegex.lastIndex = matchStart + 1;
+      continue;
+    }
     const closeIdx = scanner.closeBrace(matchStart + 1);
     if (closeIdx === -1) {
       macroHeadRegex.lastIndex = matchStart + 1;
@@ -6787,7 +7084,7 @@ function parseMacros(text) {
     const matchEnd = closeIdx + 1;
     macroHeadRegex.lastIndex = matchEnd;
     const closeSlash = match2[1];
-    const cssPrefix = (match2[2] || "").trim();
+    const cssPrefix = match2[2] || "";
     const macroName = match2[3];
     const rawArgs = cleaned.slice(matchStart + match2[0].length, closeIdx).replace(/^\s+/, "");
     const open = closeSlash !== "/";
@@ -6838,13 +7135,345 @@ function pairMacros(macros, isBlock, passageStartLines = []) {
     }
   }
 }
-var variableInterpolationRegex, macroHeadRegex, NON_STRING_QUOTE_PREFIX;
+var variableInterpolationRegex, SELECTOR_PATTERN, macroHeadRegex;
 var init_macro_parser = __esm({
   "src/core/parsing/macro-parser.ts"() {
     "use strict";
+    init_code_scanner();
+    init_html_scanner();
+    init_code_scanner();
     variableInterpolationRegex = /(?<!\\)\{([$_@%][A-Za-z_$][\w$.]*)\}/g;
-    macroHeadRegex = /(?<!\\)\{(\/)?(?:((?:[#.][a-zA-Z][\w-]*\s*)*)([A-Za-z][\w-]*))(?=[\s}])/gi;
-    NON_STRING_QUOTE_PREFIX = /[\p{L}\p{N}_\\]/u;
+    SELECTOR_PATTERN = String.raw`(?:[.#](?:[\w-]|\{[$_@][\w.]*\})*)+`;
+    macroHeadRegex = new RegExp(
+      String.raw`(?<!\\)\{(?:(\/)|(${SELECTOR_PATTERN}) )?([A-Za-z][\w-]*)(?=[\s}]|\{[$_@%][A-Za-z_$][\w$.]*\})`,
+      "gi"
+    );
+  }
+});
+
+// src/core/workspace/variable-schema.ts
+function inferDefaultSchema(expr) {
+  const parser = new LiteralParser(expr.trim());
+  try {
+    const schema = parser.value();
+    parser.skipSpace();
+    return schema && parser.atEnd() ? schema : void 0;
+  } catch (err) {
+    if (err instanceof Unparsable) return void 0;
+    throw err;
+  }
+}
+function findUnsupportedValue(expr) {
+  const offset = expr.length - expr.trimStart().length;
+  const parser = new LiteralParser(expr.trim());
+  try {
+    const read = parser.read();
+    parser.skipSpace();
+    const value = read.unsupported;
+    if (!parser.atEnd() || !value) return void 0;
+    return { ...value, start: value.start + offset, end: value.end + offset };
+  } catch (err) {
+    if (err instanceof Unparsable) return void 0;
+    throw err;
+  }
+}
+function bigintString(literal2) {
+  const digits = literal2.slice(0, -1).replace(/_/g, "");
+  const negative = digits.startsWith("-");
+  try {
+    const value = BigInt(negative ? digits.slice(1) : digits);
+    return String(negative ? -value : value);
+  } catch {
+    return digits;
+  }
+}
+function findPrimitiveFieldAccess(schema, fields) {
+  let current = schema;
+  for (let i = 0; i < fields.length; i++) {
+    if (current.type === "array") return void 0;
+    if (current.type !== "object") return { index: i, type: current.type };
+    const next = current.fields?.get(fields[i]);
+    if (!next) return void 0;
+    current = next;
+  }
+  return void 0;
+}
+var Unparsable, IDENTIFIER_RE, BIGINT_RE, NUMBER_RE, INDEX_KEY_RE, UNKNOWN2, LiteralParser;
+var init_variable_schema = __esm({
+  "src/core/workspace/variable-schema.ts"() {
+    "use strict";
+    Unparsable = class extends Error {
+    };
+    IDENTIFIER_RE = /[A-Za-z_$][\w$]*/y;
+    BIGINT_RE = /-?(?:0[xX][\da-fA-F_]+|0[oO][0-7_]+|0[bB][01_]+|0|[1-9][\d_]*)n(?![\w$])/y;
+    NUMBER_RE = /[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?/y;
+    INDEX_KEY_RE = /(?:0|[1-9]\d{0,14})(?![\w$.])/y;
+    UNKNOWN2 = { schema: null };
+    LiteralParser = class {
+      constructor(text) {
+        this.text = text;
+      }
+      pos = 0;
+      atEnd() {
+        return this.pos >= this.text.length;
+      }
+      skipSpace() {
+        while (/\s/.test(this.text[this.pos] ?? "")) this.pos++;
+      }
+      /** A value up to the `,` / `}` / `]` that ends it; null when its type is unknown. */
+      value() {
+        return this.read().schema;
+      }
+      /** A value up to the `,` / `}` / `]` that ends it. */
+      read() {
+        this.skipSpace();
+        const start = this.pos;
+        const read = this.literal();
+        this.skipSpace();
+        const next = this.text[this.pos];
+        if (read && (next === void 0 || next === "," || next === "}" || next === "]")) return read;
+        this.pos = start;
+        this.skipExpression();
+        return UNKNOWN2;
+      }
+      /** A literal, consumed; undefined when the code here is not one. */
+      literal() {
+        const start = this.pos;
+        const ch = this.text[this.pos];
+        if (ch === "{") return this.object();
+        if (ch === "[") {
+          this.pos++;
+          this.skipList("]");
+          return { schema: { type: "array" } };
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+          this.stringLiteral();
+          return { schema: { type: "string" } };
+        }
+        if (ch === "(") return this.functionLiteral(start);
+        const word = this.match(IDENTIFIER_RE);
+        if (word === "true" || word === "false") return { schema: { type: "boolean" } };
+        if (word === "null") return this.unsupported("object", start);
+        if (word === "undefined") return this.unsupported("undefined", start);
+        if (word === "void") {
+          this.skipSpace();
+          if (this.match(NUMBER_RE) === void 0) return void 0;
+          return this.unsupported("undefined", start, "undefined");
+        }
+        if (word !== void 0) return this.functionLiteral(start);
+        if (this.match(BIGINT_RE) !== void 0) {
+          return this.unsupported("bigint", start, bigintString(this.text.slice(start, this.pos)));
+        }
+        if (this.match(NUMBER_RE) !== void 0) return { schema: { type: "number" } };
+        return void 0;
+      }
+      /** The value from `start` to here, which Spindle rejects. */
+      unsupported(type, start, text) {
+        const end = this.pos;
+        return { schema: null, unsupported: { type, text: text ?? this.text.slice(start, end), path: [], start, end } };
+      }
+      /**
+       * A function, arrow function or class expression at `start`, consumed;
+       * undefined, with nothing consumed, for any other code.
+       */
+      functionLiteral(start) {
+        this.pos = start;
+        try {
+          if (this.functionSyntax()) return this.unsupported("function", start);
+        } catch (err) {
+          if (!(err instanceof Unparsable)) throw err;
+        }
+        this.pos = start;
+        return void 0;
+      }
+      functionSyntax() {
+        let word = this.match(IDENTIFIER_RE);
+        if (word === "async") {
+          this.skipSpace();
+          word = this.match(IDENTIFIER_RE);
+        }
+        this.skipSpace();
+        if (word === "function") {
+          if (this.text[this.pos] === "*") this.pos++;
+          this.skipSpace();
+          this.match(IDENTIFIER_RE);
+          this.skipSpace();
+          if (!this.skipBracketed("(", ")")) return false;
+          this.skipSpace();
+          return this.skipBracketed("{", "}");
+        }
+        if (word === "class") {
+          if (this.match(IDENTIFIER_RE) !== void 0) this.skipSpace();
+          return this.skipBracketed("{", "}");
+        }
+        if (word === void 0 && !this.skipBracketed("(", ")")) return false;
+        this.skipSpace();
+        if (!this.text.startsWith("=>", this.pos)) return false;
+        this.pos += 2;
+        this.skipSpace();
+        if (this.text[this.pos] === "{") return this.skipBracketed("{", "}");
+        const bodyStart = this.pos;
+        this.skipExpression();
+        while (this.pos > bodyStart && /\s/.test(this.text[this.pos - 1])) this.pos--;
+        return this.pos > bodyStart;
+      }
+      /** Skip a bracketed list that opens here; false if none does. */
+      skipBracketed(open, close) {
+        if (this.text[this.pos] !== open) return false;
+        this.pos++;
+        this.skipList(close);
+        return true;
+      }
+      object() {
+        this.pos++;
+        let fields = /* @__PURE__ */ new Map();
+        const unsupported = /* @__PURE__ */ new Map();
+        for (; ; ) {
+          this.skipSpace();
+          if (this.text[this.pos] === "}") {
+            this.pos++;
+            break;
+          }
+          const key = this.propertyKey();
+          this.skipSpace();
+          if (key !== void 0 && key !== "__proto__" && this.text[this.pos] === ":") {
+            this.pos++;
+            const read = this.read();
+            fields?.set(key, read.schema);
+            unsupported.delete(key);
+            if (read.unsupported) {
+              unsupported.set(key, { ...read.unsupported, path: [key, ...read.unsupported.path] });
+            }
+          } else {
+            fields = void 0;
+            this.skipExpression();
+          }
+          this.skipSpace();
+          const sep2 = this.text[this.pos++];
+          if (sep2 === "}") break;
+          if (sep2 !== ",") throw new Unparsable();
+        }
+        if (!fields) return { schema: { type: "object" } };
+        const [first] = unsupported.values();
+        return { schema: { type: "object", fields }, unsupported: first };
+      }
+      /** A plain property key, consumed; undefined (possibly consumed) for any other. */
+      propertyKey() {
+        const ch = this.text[this.pos];
+        if (ch === '"' || ch === "'") {
+          const raw = this.stringLiteral();
+          return raw.includes("\\") ? void 0 : raw;
+        }
+        return this.match(IDENTIFIER_RE) ?? this.match(INDEX_KEY_RE);
+      }
+      /** Consume a string or template literal and return its raw text. */
+      stringLiteral() {
+        const quote = this.text[this.pos];
+        const start = ++this.pos;
+        while (this.pos < this.text.length) {
+          const ch = this.text[this.pos];
+          if (ch === "\\") {
+            this.pos += 2;
+            continue;
+          }
+          if (quote === "`" && ch === "$" && this.text[this.pos + 1] === "{") throw new Unparsable();
+          if (ch === quote) return this.text.slice(start, this.pos++);
+          this.pos++;
+        }
+        throw new Unparsable();
+      }
+      /** Skip comma-separated expressions up to and including `close`. */
+      skipList(close) {
+        for (; ; ) {
+          this.skipExpression();
+          const ch = this.text[this.pos++];
+          if (ch === close) return;
+          if (ch !== ",") throw new Unparsable();
+        }
+      }
+      /** Skip code up to a `,`, `)`, `]` or `}` that closes nothing, or the end. */
+      skipExpression() {
+        let depth = 0;
+        while (this.pos < this.text.length) {
+          const ch = this.text[this.pos];
+          if (ch === '"' || ch === "'" || ch === "`") {
+            this.stringLiteral();
+            continue;
+          }
+          if (ch === "/") throw new Unparsable();
+          if (ch === "(" || ch === "[" || ch === "{") depth++;
+          else if (ch === ")" || ch === "]" || ch === "}") {
+            if (depth === 0) return;
+            depth--;
+          } else if (ch === "," && depth === 0) return;
+          this.pos++;
+        }
+        if (depth > 0) throw new Unparsable();
+      }
+      match(re) {
+        re.lastIndex = this.pos;
+        const m = re.exec(this.text);
+        if (!m) return void 0;
+        this.pos += m[0].length;
+        return m[0];
+      }
+    };
+  }
+});
+
+// src/core/workspace/declaration-check.ts
+function declaredName(line, sigil) {
+  return DECLARATION_RE[sigil].exec(line.trim())?.[1];
+}
+function checkDeclaration(rawLine, sigil) {
+  const line = rawLine.trim();
+  if (!line || line.includes("\r") || line.includes("\xA0")) return void 0;
+  const passage = PASSAGE[sigil];
+  const match2 = DECLARATION_RE[sigil].exec(line);
+  if (!match2) {
+    const comment = /^(?:\/\/|\/\*|<!--|#)/.test(line) ? ` ${passage} has no comment syntax.` : "";
+    return {
+      kind: "invalid",
+      message: `${passage}: Invalid declaration: "${line}". Expected: ${sigil}name = value.${comment}`
+    };
+  }
+  const [, name, expr] = match2;
+  const error48 = compileError(expr);
+  if (error48 !== void 0) {
+    const comment = compileError(expr + "\n") === void 0 ? ` A comment runs to the end of the line and hides the ")" Spindle closes the value with; ${passage} has no comment syntax.` : "";
+    return {
+      kind: "evaluate",
+      message: `${passage}: Failed to evaluate "${sigil}${name} = ${expr}": ${error48}.${comment}`
+    };
+  }
+  const value = findUnsupportedValue(expr);
+  if (!value) return void 0;
+  const exprStart = rawLine.length - rawLine.trimStart().length + line.length - expr.length;
+  if (value.type === "object") {
+    return { kind: "null", field: value.path, start: exprStart + value.start, end: exprStart + value.end };
+  }
+  const where = value.path.length > 0 ? ` (${sigil}${[name, ...value.path].join(".")})` : "";
+  return {
+    kind: "unsupported",
+    message: `${passage}: Unsupported type "${value.type}" for value ${value.text}${where}. Expected number, string, boolean, array, or object.`
+  };
+}
+function compileError(expr) {
+  try {
+    new Function("return (" + expr + ")");
+    return void 0;
+  } catch (err) {
+    if (!(err instanceof SyntaxError) || /regular expression/i.test(err.message)) return void 0;
+    return err.message;
+  }
+}
+var DECLARATION_RE, PASSAGE;
+var init_declaration_check = __esm({
+  "src/core/workspace/declaration-check.ts"() {
+    "use strict";
+    init_variable_schema();
+    DECLARATION_RE = { "$": /^\$(\w+)\s*=\s*(.+)$/, "%": /^%(\w+)\s*=\s*(.+)$/ };
+    PASSAGE = { "$": "StoryVariables", "%": "StoryTransients" };
   }
 });
 
@@ -6853,6 +7482,14 @@ function replaceCodeLiterals(text, replace) {
   const scanner = createCodeScanner(text);
   let result = "";
   let copied = 0;
+  for (const [open, close] of codeBlocks(text, scanner)) {
+    result += text.slice(copied, open + 1) + replaceLiterals(text, scanner, open + 1, close, replace);
+    copied = close;
+  }
+  return result + text.slice(copied);
+}
+function codeBlocks(text, scanner) {
+  const blocks = [];
   for (let i = 0; i < text.length; i++) {
     if (text[i] === "\\" && (text[i + 1] === "{" || text[i + 1] === "}")) {
       i++;
@@ -6861,11 +7498,10 @@ function replaceCodeLiterals(text, replace) {
     if (text[i] !== "{") continue;
     const close = scanner.closeBrace(i + 1);
     if (close === -1) continue;
-    result += text.slice(copied, i + 1) + replaceLiterals(text, scanner, i + 1, close, replace);
-    copied = close;
+    blocks.push([i, close]);
     i = close;
   }
-  return result + text.slice(copied);
+  return blocks;
 }
 function replaceLiterals(text, scanner, from, to, replace) {
   let result = "";
@@ -6891,7 +7527,7 @@ function blankLiteralText(literal2) {
   for (let i = 1; i < literal2.length - 1; i++) {
     if (literal2[i] !== "{") continue;
     const templateCode = literal2[0] === "`" && literal2[i - 1] === "$" && literal2[i - 2] !== "\\";
-    if (!templateCode && !/^[$%][A-Za-z_$]/.test(literal2.slice(i + 1, i + 3))) continue;
+    if (!templateCode && !/^[$%][\w$]/.test(literal2.slice(i + 1, i + 3))) continue;
     let depth = 0;
     for (let j = i; j < literal2.length - 1; j++) {
       if (literal2[j] === "{") depth++;
@@ -6904,6 +7540,43 @@ function blankLiteralText(literal2) {
   }
   return literal2.replace(/[^\r\n]/g, (ch, i) => keep[i] ? ch : " ");
 }
+function checkDeclarations(lines, contentStartLine, sigil) {
+  const check2 = { problems: [], nestedNulls: [], names: /* @__PURE__ */ new Map() };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("::")) break;
+    const absLine = contentStartLine + i;
+    const problem = checkDeclaration(line, sigil);
+    if (!problem) {
+      const name = /[\r\u00a0]/.test(line.trim()) ? void 0 : declaredName(line, sigil);
+      if (name !== void 0 && !check2.names.has(name)) {
+        check2.names.set(name, declarationLocation(line, name, absLine, void 0).declarationRange);
+      }
+    } else if (problem.kind === "null") {
+      if (problem.field.length > 0) {
+        check2.nestedNulls.push({
+          name: declaredName(line, sigil),
+          sigil,
+          field: problem.field,
+          range: {
+            start: { line: absLine, character: problem.start },
+            end: { line: absLine, character: problem.end }
+          }
+        });
+      }
+    } else {
+      const start = line.length - line.trimStart().length;
+      check2.problems.push({
+        message: problem.message,
+        range: {
+          start: { line: absLine, character: start },
+          end: { line: absLine, character: line.trimEnd().length }
+        }
+      });
+    }
+  }
+  return check2;
+}
 function findLiteralEnd(text, start) {
   const open = text[start];
   if (open === '"' || open === "'" || open === "`") {
@@ -6960,14 +7633,48 @@ function declarationLocation(line, name, absLine, uri) {
   if (uri !== void 0) location.declarationUri = uri;
   return location;
 }
-var varRefRegex, transientRefRegex, EXCLUDED_PASSAGES, UNCHECKED_PASSAGES, COMMENT_PATTERNS, BUILTIN_STORE_VAR_MACROS, QUOTED_RECEIVER_RE, ARRAY_MEMBERS, VariableTracker;
+function validatedReferences(lines, passages) {
+  const refs = [];
+  for (let pi = 0; pi < passages.length; pi++) {
+    const passage = passages[pi];
+    if (UNVALIDATED_PASSAGES.has(passage.name) || isScriptOrStylesheetPassage(passage)) continue;
+    const contentStartLine = passage.startLine + 1;
+    const contentEndLine = pi + 1 < passages.length ? passages[pi + 1].startLine : lines.length;
+    const contentLines = lines.slice(contentStartLine, contentEndLine);
+    const forLocals = /* @__PURE__ */ new Set();
+    for (const m of contentLines.join("\n").matchAll(VALIDATED_FOR_LOCAL_RE)) {
+      forLocals.add(m[1]);
+      if (m[2]) forLocals.add(m[2]);
+    }
+    for (let i = 0; i < contentLines.length; i++) {
+      for (const m of contentLines[i].matchAll(VALIDATED_REF_RE)) {
+        const baseName = m[1].split(".")[0];
+        if (forLocals.has(baseName)) continue;
+        const line = contentStartLine + i;
+        refs.push({
+          baseName,
+          path: m[1],
+          range: {
+            start: { line, character: m.index },
+            end: { line, character: m.index + m[0].length }
+          }
+        });
+      }
+    }
+  }
+  return refs;
+}
+var varRefRegex, transientRefRegex, DECLARATION_RE2, EXCLUDED_PASSAGES, VALIDATED_REF_RE, VALIDATED_FOR_LOCAL_RE, UNVALIDATED_PASSAGES, COMMENT_PATTERNS, BUILTIN_STORE_VAR_MACROS, QUOTED_RECEIVER_RE, NO_DECLARATIONS, ARRAY_MEMBERS, VariableTracker;
 var init_variable_tracker = __esm({
   "src/core/workspace/variable-tracker.ts"() {
     "use strict";
     init_passage_parser();
     init_macro_parser();
-    varRefRegex = /\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
-    transientRefRegex = /(?<!\w)%([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+    init_variable_schema();
+    init_declaration_check();
+    varRefRegex = /\$([\w$]+(?:\.[A-Za-z_$][\w$]*)*)/g;
+    transientRefRegex = /(?<!\w)%([\w$]+(?:\.[A-Za-z_$][\w$]*)*)/g;
+    DECLARATION_RE2 = { "$": /^\$(\w+)\s*=\s*(.*)$/, "%": /^%(\w+)\s*=\s*(.*)$/ };
     EXCLUDED_PASSAGES = /* @__PURE__ */ new Set([
       "StoryVariables",
       "StoryTransients",
@@ -6975,7 +7682,14 @@ var init_variable_tracker = __esm({
       "StoryScript",
       "StoryInterface"
     ]);
-    UNCHECKED_PASSAGES = /* @__PURE__ */ new Set(["StoryInit"]);
+    VALIDATED_REF_RE = /\$(\w+(?:\.\w+)*)/g;
+    VALIDATED_FOR_LOCAL_RE = /\{for\s+@(\w+)(?:\s*,\s*@(\w+))?\s+of\b/g;
+    UNVALIDATED_PASSAGES = /* @__PURE__ */ new Set([
+      "StoryVariables",
+      "StoryTransients",
+      "StoryData",
+      "StoryTitle"
+    ]);
     COMMENT_PATTERNS = [
       /<!--[\s\S]*?-->/g,
       // HTML comments
@@ -6993,7 +7707,11 @@ var init_variable_tracker = __esm({
       "textarea",
       "textbox"
     ]);
-    QUOTED_RECEIVER_RE = /(?<!\\)(\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\s+(["']))\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\3?(?=[\s}])/g;
+    QUOTED_RECEIVER_RE = new RegExp(
+      String.raw`(?<!\\)(\{(?:${SELECTOR_PATTERN} )?([A-Za-z][\w-]*)\s+(["']))\$([\w$]+(?:\.[A-Za-z_$][\w$]*)*)\3?(?=[\s}])`,
+      "g"
+    );
+    NO_DECLARATIONS = { problems: [], nestedNulls: [], names: /* @__PURE__ */ new Map() };
     ARRAY_MEMBERS = /* @__PURE__ */ new Set([
       ...Object.getOwnPropertyNames(Array.prototype),
       ...Object.getOwnPropertyNames(Object.prototype),
@@ -7012,13 +7730,17 @@ var init_variable_tracker = __esm({
       declared = /* @__PURE__ */ new Map();
       _hasStoryVariables = false;
       _nullDeclarations = [];
+      _variablesCheck = NO_DECLARATIONS;
       declaredTransient = /* @__PURE__ */ new Map();
       _hasStoryTransients = false;
       _nullTransientDeclarations = [];
+      _transientsCheck = NO_DECLARATIONS;
       /** Per-URI list of variable usages. */
       usagesByUri = /* @__PURE__ */ new Map();
       /** Per-URI list of transient variable usages. */
       transientUsagesByUri = /* @__PURE__ */ new Map();
+      /** Per-URI list of the `$` references Spindle validates at startup. */
+      validatedRefsByUri = /* @__PURE__ */ new Map();
       /**
        * Parse the StoryVariables passage content for declarations.
        * Each line like `$name = value` becomes a declaration.
@@ -7028,10 +7750,11 @@ var init_variable_tracker = __esm({
         this._hasStoryVariables = true;
         this._nullDeclarations = [];
         const lines = content.split("\n");
+        this._variablesCheck = checkDeclarations(lines, contentStartLine, "$");
         for (let i = 0; i < lines.length; i++) {
           const trimmed2 = lines[i].trim();
           if (!trimmed2 || trimmed2.startsWith("//") || trimmed2.startsWith("<!--")) continue;
-          const match2 = /^\$([A-Za-z_$][\w$]*)\s*=\s*(.*)$/.exec(trimmed2);
+          const match2 = DECLARATION_RE2.$.exec(trimmed2);
           if (!match2) continue;
           const name = match2[1];
           const expr = match2[2].trim();
@@ -7053,6 +7776,8 @@ var init_variable_tracker = __esm({
           const decl = { name, sigil: "$", ...location };
           const type = inferLiteralType(expr);
           if (type) decl.type = type;
+          const schema = inferDefaultSchema(expr);
+          if (schema) decl.schema = schema;
           if (expr.startsWith("{")) {
             const fieldRegex = /(\w+)\s*:/g;
             let fieldMatch;
@@ -7072,12 +7797,14 @@ var init_variable_tracker = __esm({
         this.declared.clear();
         this._hasStoryVariables = false;
         this._nullDeclarations = [];
+        this._variablesCheck = NO_DECLARATIONS;
       }
       /** Forget StoryTransients declarations, e.g. after the passage was removed. */
       clearStoryTransients() {
         this.declaredTransient.clear();
         this._hasStoryTransients = false;
         this._nullTransientDeclarations = [];
+        this._transientsCheck = NO_DECLARATIONS;
       }
       /**
        * Parse the StoryTransients passage content for declarations.
@@ -7088,10 +7815,11 @@ var init_variable_tracker = __esm({
         this._hasStoryTransients = true;
         this._nullTransientDeclarations = [];
         const lines = content.split("\n");
+        this._transientsCheck = checkDeclarations(lines, contentStartLine, "%");
         for (let i = 0; i < lines.length; i++) {
           const trimmed2 = lines[i].trim();
           if (!trimmed2 || trimmed2.startsWith("//") || trimmed2.startsWith("<!--")) continue;
-          const match2 = /^%([A-Za-z_$][\w$]*)\s*=\s*(.*)$/.exec(trimmed2);
+          const match2 = DECLARATION_RE2["%"].exec(trimmed2);
           if (!match2) continue;
           const name = match2[1];
           const expr = match2[2].trim();
@@ -7136,6 +7864,7 @@ var init_variable_tracker = __esm({
       scanDocument(uri, text, _macros, storeVarMacros = BUILTIN_STORE_VAR_MACROS) {
         this.usagesByUri.delete(uri);
         this.transientUsagesByUri.delete(uri);
+        this.validatedRefsByUri.delete(uri);
         const lines = text.split("\n");
         const usages = [];
         const transientUsages = [];
@@ -7170,14 +7899,15 @@ var init_variable_tracker = __esm({
           for (let i = 0; i < cleaned.length; i++) {
             if (cleaned[i] === "\n") lineOffsets.push(i + 1);
           }
-          const checkedPassage = !UNCHECKED_PASSAGES.has(passage.name);
+          const blocks = codeBlocks(uncommented, createCodeScanner(uncommented));
+          const inCode = (offset) => blocks.some(([open, close]) => open < offset && offset < close);
           const scans = [
-            [varRefRegex, usages],
-            [transientRefRegex, transientUsages]
+            [varRefRegex, usages, false],
+            [transientRefRegex, transientUsages, true]
           ];
-          for (const [regex, out] of scans) {
+          for (const [regex, out, digitsOnlyInCode] of scans) {
             const seen = /* @__PURE__ */ new Set();
-            for (const [source, checked] of [[cleaned, checkedPassage], [referenced, false]]) {
+            for (const source of [cleaned, referenced]) {
               const re = new RegExp(regex.source, "g");
               let match2;
               while ((match2 = re.exec(source)) !== null) {
@@ -7186,6 +7916,7 @@ var init_variable_tracker = __esm({
                 seen.add(charOffset);
                 const fullName = match2[1];
                 const baseName = fullName.split(".")[0];
+                if (digitsOnlyInCode && /^\d/.test(baseName) && !inCode(charOffset)) continue;
                 let localLine = 0;
                 for (let i = 0; i < lineOffsets.length; i++) {
                   if (lineOffsets[i] > charOffset) break;
@@ -7197,7 +7928,7 @@ var init_variable_tracker = __esm({
                   start: { line: absoluteLine, character },
                   end: { line: absoluteLine, character: character + match2[0].length }
                 };
-                out.push({ uri, baseName, fullName, range: range2, checked });
+                out.push({ uri, baseName, fullName, range: range2 });
               }
             }
           }
@@ -7208,11 +7939,16 @@ var init_variable_tracker = __esm({
         if (transientUsages.length > 0) {
           this.transientUsagesByUri.set(uri, transientUsages);
         }
+        const validated = validatedReferences(lines, passageBoundaries);
+        if (validated.length > 0) {
+          this.validatedRefsByUri.set(uri, validated);
+        }
       }
       /** Forget the usages recorded for a document, e.g. after it was deleted. */
       removeDocument(uri) {
         this.usagesByUri.delete(uri);
         this.transientUsagesByUri.delete(uri);
+        this.validatedRefsByUri.delete(uri);
       }
       /** Get all declared variables. */
       getDeclared() {
@@ -7230,20 +7966,52 @@ var init_variable_tracker = __esm({
         }
         return results;
       }
-      /** Get undeclared variable usages in a specific document. */
+      /**
+       * Get undeclared variable references in a specific document: the ones
+       * Spindle rejects when the story starts, wherever they are in the text.
+       */
       getUndeclared(uri) {
-        const usages = this.usagesByUri.get(uri);
-        if (!usages) return [];
+        const refs = this.validatedRefsByUri.get(uri);
+        if (!refs) return [];
         const results = [];
         const seen = /* @__PURE__ */ new Set();
-        for (const u of usages) {
-          if (u.checked && !this.declared.has(u.baseName) && !seen.has(u.baseName)) {
+        for (const u of refs) {
+          if (!this.declared.has(u.baseName) && !seen.has(u.baseName)) {
             seen.add(u.baseName);
             results.push({ name: u.baseName, range: u.range });
           }
         }
         return results;
       }
+      /**
+       * Get the `$var.a.b` paths in a document that Spindle rejects at startup
+       * because they access a field of a number, string or boolean, judged by
+       * the StoryVariables defaults as Spindle's validateRef() does. Every
+       * occurrence is reported; defaults that are not literals are not checked.
+       */
+      getPrimitiveFieldAccesses(uri) {
+        const results = [];
+        for (const ref of this.validatedRefsByUri.get(uri) ?? []) {
+          const schema = this.declared.get(ref.baseName)?.schema;
+          if (!schema) continue;
+          const parts = ref.path.split(".");
+          const found = findPrimitiveFieldAccess(schema, parts.slice(1));
+          if (!found) continue;
+          const owner = parts.slice(0, found.index + 1).join(".");
+          const field = parts[found.index + 1];
+          const start = ref.range.start.character + 1 + owner.length + 1;
+          results.push({
+            path: `$${owner}`,
+            field,
+            type: found.type,
+            range: {
+              start: { line: ref.range.start.line, character: start },
+              end: { line: ref.range.start.line, character: start + field.length }
+            }
+          });
+        }
+        return results;
+      }
       /** Whether a StoryVariables passage has been parsed. */
       hasStoryVariables() {
         return this._hasStoryVariables;
@@ -7271,7 +8039,7 @@ var init_variable_tracker = __esm({
         const results = [];
         const seen = /* @__PURE__ */ new Set();
         for (const u of usages) {
-          if (u.checked && !this.declaredTransient.has(u.baseName) && !seen.has(u.baseName)) {
+          if (!this.declaredTransient.has(u.baseName) && !seen.has(u.baseName)) {
             seen.add(u.baseName);
             results.push({ name: u.baseName, range: u.range });
           }
@@ -7296,7 +8064,6 @@ var init_variable_tracker = __esm({
         for (const [sigil, usages, declared] of sources) {
           if (!usages) continue;
           for (const u of usages) {
-            if (!u.checked) continue;
             const member = u.fullName.split(".")[1];
             if (member === void 0) continue;
             if (declared.get(u.baseName)?.type !== "array") continue;
@@ -7308,11 +8075,32 @@ var init_variable_tracker = __esm({
       }
       /** Get variables declared with null values in StoryVariables. */
       getNullDeclarations() {
-        return this._nullDeclarations;
+        return [...this._nullDeclarations, ...this._variablesCheck.nestedNulls];
+      }
+      /** StoryVariables lines that stop Spindle from starting, apart from null values. */
+      getInvalidDeclarations() {
+        return this._variablesCheck.problems;
+      }
+      /**
+       * StoryTransients lines that stop Spindle from starting, apart from null
+       * values, and the names it declares that StoryVariables declares too.
+       */
+      getInvalidTransientDeclarations() {
+        const collisions = [];
+        if (this._hasStoryVariables) {
+          for (const [name, range2] of this._transientsCheck.names) {
+            if (!this._variablesCheck.names.has(name)) continue;
+            collisions.push({
+              message: `StoryTransients: Variable "${name}" is already declared in StoryVariables. Names must be unique across scopes.`,
+              range: range2
+            });
+          }
+        }
+        return [...this._transientsCheck.problems, ...collisions].sort((a, b) => a.range.start.line - b.range.start.line);
       }
       /** Get transient variables declared with null values in StoryTransients. */
       getNullTransientDeclarations() {
-        return this._nullTransientDeclarations;
+        return [...this._nullTransientDeclarations, ...this._transientsCheck.nestedNulls];
       }
     };
   }
@@ -7513,11 +8301,11 @@ function discoverMacrosFromSource(source) {
   }
   return macros;
 }
-function discoverMacrosFromStoryInit(passageContent2) {
+function discoverMacrosFromStoryInit(passageContent3) {
   const macros = [];
   doBlockRegex.lastIndex = 0;
   let doMatch;
-  while ((doMatch = doBlockRegex.exec(passageContent2)) !== null) {
+  while ((doMatch = doBlockRegex.exec(passageContent3)) !== null) {
     const jsContent = doMatch[1];
     const found = discoverMacrosFromSource(jsContent);
     macros.push(...found);
@@ -14924,8 +15712,11 @@ function isExcludedMacroSource(path2, root) {
   return (root ? relative(root, path2) : path2).split(/[\\/]/).some(isExcludedSegment);
 }
 function findMacroSourceFiles(root) {
+  return findProjectFiles(root, MACRO_SOURCE_GLOB);
+}
+function findProjectFiles(root, pattern) {
   const excluded = (p) => isExcludedMacroSource(p.fullpath(), root);
-  return glob(MACRO_SOURCE_GLOB, {
+  return glob(pattern, {
     cwd: root,
     absolute: true,
     nodir: true,
@@ -14975,6 +15766,82 @@ var init_macro_sources = __esm({
   }
 });
 
+// src/core/workspace/story-format.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+function isSpindleFormatName(name) {
+  return name.trim().toLowerCase() === "spindle";
+}
+function readStoryDataFormat(content) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return void 0;
+  const format = data.format;
+  if (typeof format !== "string") return void 0;
+  return format.trim() || void 0;
+}
+function resolveStoryFormat(declared) {
+  let foreign;
+  for (const name of declared) {
+    if (name === void 0) continue;
+    if (isSpindleFormatName(name)) return { name: name.trim(), isSpindle: true };
+    foreign ??= name.trim();
+  }
+  return foreign === void 0 ? UNDECLARED_STORY_FORMAT : { name: foreign, isSpindle: false };
+}
+function passageContent(passage, text) {
+  return text.split("\n").slice(passage.headerEnd.end.line + 1, passage.range.end.line + 1).join("\n");
+}
+function storyDataFormats(passages, getText) {
+  const formats = [];
+  for (const passage of passages) {
+    if (passage.name !== "StoryData") continue;
+    const text = getText(passage.uri);
+    formats.push(text === void 0 ? void 0 : readStoryDataFormat(passageContent(passage, text)));
+  }
+  return formats;
+}
+function storyFormatOfTexts(texts) {
+  const index = new PassageIndex();
+  const byUri = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    if (!text.includes("StoryData")) continue;
+    const uri = `story-format:${byUri.size}`;
+    byUri.set(uri, text);
+    index.rebuild(uri, text);
+  }
+  const formats = storyDataFormats(index.getAllPassages(), (uri) => byUri.get(uri));
+  return { ...resolveStoryFormat(formats), hasStoryData: formats.length > 0 };
+}
+async function findStoryFormat(texts, dir) {
+  const own = storyFormatOfTexts(texts);
+  if (own.hasStoryData) return { name: own.name, isSpindle: own.isSpindle };
+  const projectTexts = [];
+  for (const file2 of await findProjectFiles(findProjectRoot(dir), "**/*.{tw,twee}")) {
+    try {
+      projectTexts.push(readFileSync5(file2, "utf-8"));
+    } catch {
+    }
+  }
+  const { name, isSpindle } = storyFormatOfTexts(projectTexts);
+  return { name, isSpindle };
+}
+function skippedFormatNote(format) {
+  return `Skipped: story format is ${format.name}, not Spindle`;
+}
+var UNDECLARED_STORY_FORMAT;
+var init_story_format = __esm({
+  "src/core/workspace/story-format.ts"() {
+    "use strict";
+    init_passage_index();
+    init_macro_sources();
+    UNDECLARED_STORY_FORMAT = { name: void 0, isSpindle: true };
+  }
+});
+
 // src/macro-supplements.json
 var macro_supplements_default;
 var init_macro_supplements = __esm({
@@ -15004,9 +15871,6 @@ var init_macro_supplements = __esm({
       },
       for: {
         name: "for",
-        children: [
-          { name: "stop" }
-        ],
         container: true,
         description: "Loop block. Usage: `{for @item of $list}...{/for}` or `{for @item, @index of $list}...{/for}`",
         skipArgs: true
@@ -15019,8 +15883,8 @@ var init_macro_supplements = __esm({
       },
       stop: {
         name: "stop",
-        parents: ["for", "repeat"],
-        description: "Breaks out of a `{for}` or `{repeat}` loop.\n\nUsage: `{stop}`",
+        parents: ["repeat"],
+        description: "Stops the enclosing `{repeat}` loop. It has no effect anywhere else, including in a `{for}` loop.\n\nUsage: `{stop}`",
         parameters: []
       },
       switch: {
@@ -15089,8 +15953,8 @@ var init_macro_supplements = __esm({
           { name: "next" }
         ],
         container: true,
-        description: "Displays its contents after a specified delay.\n\nUsage:\n\n```\n{timed delay}\n  ...\n  {next delay}\n  ...\n{/timed}\n```",
-        parameters: ["text"]
+        description: "Displays its contents after a specified delay (immediately when omitted).\n\nUsage:\n\n```\n{timed delay}\n  ...\n  {next delay}\n  ...\n{/timed}\n```",
+        parameters: ["text", ""]
       },
       repeat: {
         name: "repeat",
@@ -15284,6 +16148,7 @@ var init_workspace_model = __esm({
     init_macro_parser();
     init_macro_discovery();
     init_macro_sources();
+    init_story_format();
     init_macro_supplements();
     WorkspaceModel = class extends EventEmitter3 {
       documents;
@@ -15293,6 +16158,8 @@ var init_workspace_model = __esm({
       widgets;
       /** True after initialize() has completed (full workspace scan done). */
       initialized = false;
+      /** The story format declared by StoryData, updated with the passages. */
+      format = UNDECLARED_STORY_FORMAT;
       debounceTimer = null;
       DEBOUNCE_MS = 200;
       /** Bound listeners for cleanup in dispose(). */
@@ -15347,6 +16214,22 @@ var init_workspace_model = __esm({
       isContainer(name) {
         return this.macros.isBlock(name) || (this.widgets.getWidget(name)?.block ?? false);
       }
+      /**
+       * The story format named by the project's StoryData passage (trimmed), or
+       * undefined if no StoryData passage names one.
+       */
+      get storyFormat() {
+        return this.format.name;
+      }
+      /**
+       * Whether Spindle semantics apply to this project. False only if a
+       * StoryData passage names another story format (SugarCube, Harlowe, ...)
+       * and none names Spindle; a missing or unreadable StoryData counts as
+       * Spindle.
+       */
+      isSpindleProject() {
+        return this.format.isSpindle;
+      }
       /** Clean up listeners and timers. */
       dispose() {
         this.documents.removeListener("documentChanged", this.onDocumentChanged);
@@ -15366,6 +16249,7 @@ var init_workspace_model = __esm({
         }
         this.refreshDiscoveredMacros();
         this.cascade();
+        this.updateStoryFormat();
         this.emit("documentChanged", uri);
         this.emit("passagesUpdated", uri);
         this.scheduleModelReady();
@@ -15376,6 +16260,7 @@ var init_workspace_model = __esm({
         this.variables.removeDocument(uri);
         this.refreshDiscoveredMacros();
         this.cascade();
+        this.updateStoryFormat();
         this.emit("documentClosed", uri);
         this.emit("passagesUpdated", uri);
         this.scheduleModelReady();
@@ -15390,6 +16275,21 @@ var init_workspace_model = __esm({
         }
         this.refreshDiscoveredMacros();
         this.cascade();
+        this.updateStoryFormat();
+      }
+      /**
+       * Re-read the story format from the StoryData passages after the passage
+       * index changed, emitting 'storyFormatChanged' if it differs. Called after
+       * the cascade, so listeners see up-to-date indices.
+       */
+      updateStoryFormat() {
+        const format = resolveStoryFormat(storyDataFormats(
+          this.passages.getAllPassages(),
+          (uri) => this.documents.getText(uri)
+        ));
+        if (format.name === this.format.name && format.isSpindle === this.format.isSpindle) return;
+        this.format = format;
+        this.emit("storyFormatChanged", format);
       }
       /**
        * Re-run static macro discovery over the workspace and replace the
@@ -15505,6 +16405,8 @@ var init_diagnostic_codes = __esm({
     DiagnosticCode = {
       UndefinedMacro: "SP100",
       MalformedContainer: "SP101",
+      MalformedElement: "SP102",
+      UnevaluatedAttributeBlock: "SP103",
       IllegalClosingTag: "SP104",
       InvalidChildren: "SP107",
       ExpectedNoArguments: "SP108",
@@ -15515,12 +16417,13 @@ var init_diagnostic_codes = __esm({
       ChildMaxExceeded: "SP114",
       ChildMinNotMet: "SP115",
       UndeclaredVariable: "SP200",
-      UndeclaredField: "SP201",
+      PrimitiveFieldAccess: "SP201",
       NoStoryVariables: "SP202",
       UndeclaredTransient: "SP203",
       NullVariableValue: "SP204",
       TemporaryAssignedInLoop: "SP205",
       ArrayMemberAccess: "SP206",
+      InvalidDeclaration: "SP207",
       BrokenPassageLink: "SP300",
       WidgetArgCountMismatch: "SP301",
       IncludeWidgetPassage: "SP302",
@@ -15532,6 +16435,8 @@ var init_diagnostic_codes = __esm({
     severityMap = {
       SP100: "warning",
       SP101: "error",
+      SP102: "error",
+      SP103: "warning",
       SP104: "error",
       SP107: "error",
       SP108: "error",
@@ -15542,12 +16447,13 @@ var init_diagnostic_codes = __esm({
       SP114: "error",
       SP115: "error",
       SP200: "error",
-      SP201: "warning",
+      SP201: "error",
       SP202: "info",
       SP203: "warning",
       SP204: "error",
       SP205: "warning",
       SP206: "warning",
+      SP207: "error",
       SP300: "warning",
       SP301: "warning",
       SP302: "warning",
@@ -15829,6 +16735,162 @@ var init_argument_lexer = __esm({
   }
 });
 
+// src/core/parsing/attribute-blocks.ts
+function findUnevaluatedBlocks(value, lookup) {
+  const blocks = [];
+  if (!value.includes("{")) return blocks;
+  const code = createCodeScanner(value);
+  let i = 0;
+  while (i < value.length) {
+    i = value.indexOf("{", i);
+    if (i === -1) break;
+    const block = readBlock(value, code, i);
+    if (block.kind === "skip") {
+      i = block.next;
+      continue;
+    }
+    const inner = value.slice(i + 1, block.close);
+    const head = MACRO_HEAD.exec(inner);
+    if (head && lookup.isMacro(head[2])) {
+      const closing = head[1] === "/";
+      let end = block.close + 1;
+      if (!closing && lookup.isContainer(head[2])) {
+        end = containerEnd(value, code, end, head[2]) ?? end;
+      }
+      blocks.push({ start: i, end, kind: "macro", macro: closing ? `/${head[2]}` : head[2] });
+      i = end;
+    } else if (usesVariable(inner)) {
+      blocks.push({ start: i, end: block.close + 1, kind: "expression" });
+      i = block.close + 1;
+    } else {
+      i++;
+    }
+  }
+  return blocks;
+}
+function readBlock(value, code, i) {
+  if (i > 0 && value[i - 1] === "\\") return { kind: "skip", next: i + 1 };
+  if (SIGILS.has(value[i + 1])) {
+    const end = Math.max(plainClose(value, i + 1), code.closeBrace(i + 1));
+    return { kind: "skip", next: end === -1 ? i + 1 : end + 1 };
+  }
+  const close = code.closeBrace(i + 1);
+  return close === -1 ? { kind: "skip", next: i + 1 } : { kind: "text", close };
+}
+function plainClose(value, i) {
+  let depth = 1;
+  for (; i < value.length; i++) {
+    if (value[i] === "{") depth++;
+    else if (value[i] === "}" && --depth === 0) return i;
+  }
+  return -1;
+}
+function containerEnd(value, code, from, name) {
+  const lower = name.toLowerCase();
+  let depth = 1;
+  let i = from;
+  while (i < value.length) {
+    i = value.indexOf("{", i);
+    if (i === -1) break;
+    const block = readBlock(value, code, i);
+    if (block.kind === "skip") {
+      i = block.next;
+      continue;
+    }
+    const head = MACRO_HEAD.exec(value.slice(i + 1, block.close));
+    if (head && head[2].toLowerCase() === lower) {
+      depth += head[1] === "/" ? -1 : 1;
+      if (depth === 0) return block.close + 1;
+      i = block.close + 1;
+    } else {
+      i++;
+    }
+  }
+  return void 0;
+}
+function usesVariable(inner) {
+  const code = createCodeScanner(inner);
+  let masked = "";
+  let i = 0;
+  while (i < inner.length) {
+    const literal2 = code.literalEnd(i);
+    if (literal2 !== -1) {
+      masked += " ".repeat(literal2 - i);
+      i = literal2;
+      continue;
+    }
+    if (inner[i] === "{" && SIGILS.has(inner[i + 1])) {
+      const close = code.closeBrace(i + 1);
+      if (close !== -1) {
+        masked += " ".repeat(close + 1 - i);
+        i = close + 1;
+        continue;
+      }
+    }
+    masked += inner[i];
+    i++;
+  }
+  return VARIABLE_REFERENCE.test(masked);
+}
+function conditionalExpression(source) {
+  const match2 = IF_ELSE.exec(source);
+  if (!match2) return null;
+  const condition = match2[1].trim();
+  const [whenTrue, whenFalse = ""] = [match2[2], match2[3]];
+  if (!/^[$_@%]\w/.test(condition)) return null;
+  if (/[`\r\n]/.test(condition) || /[\r\n]/.test(whenTrue + whenFalse)) return null;
+  const code = createCodeScanner(condition);
+  let operators = "";
+  for (let i = 0; i < condition.length; ) {
+    const literal2 = code.literalEnd(i);
+    if (literal2 !== -1) {
+      i = literal2;
+      continue;
+    }
+    operators += condition[i];
+    i++;
+  }
+  if (/(?:<<|>>)=/.test(operators)) return null;
+  const rest = operators.replace(/\?\?|\?\./g, "").replace(/[!=]==?|[<>]=/g, "");
+  if (/[?=,;]/.test(rest)) return null;
+  const quote = (s) => `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  return `{${condition} ? ${quote(whenTrue)} : ${quote(whenFalse)}}`;
+}
+function printExpression(source) {
+  const match2 = /^\{print\s+([^{}\r\n]*)\}$/.exec(source);
+  if (!match2) return null;
+  const expr = match2[1].trim();
+  if (!/^[$_@%]\w/.test(expr)) return null;
+  const code = createCodeScanner(expr);
+  let depth = 0;
+  for (let i = 0; i < expr.length; ) {
+    const literal2 = code.literalEnd(i);
+    if (literal2 !== -1) {
+      i = literal2;
+      continue;
+    }
+    const c3 = expr[i];
+    if (c3 === "(" || c3 === "[") depth++;
+    else if (c3 === ")" || c3 === "]") depth--;
+    else if (c3 === ";" || c3 === "," && depth <= 0) return null;
+    i++;
+  }
+  return SIMPLE_PATH.test(expr) && expr.includes(".") ? `{${expr} ?? ''}` : `{${expr}}`;
+}
+var SIGILS, MACRO_HEAD, VARIABLE_REFERENCE, IF_ELSE, SIMPLE_PATH;
+var init_attribute_blocks = __esm({
+  "src/core/parsing/attribute-blocks.ts"() {
+    "use strict";
+    init_code_scanner();
+    init_macro_parser();
+    SIGILS = /* @__PURE__ */ new Set(["$", "_", "@", "%"]);
+    MACRO_HEAD = new RegExp(String.raw`^(?:(\/)|${SELECTOR_PATTERN} )?([A-Za-z][\w-]*)(?=\s|$|\{[$_@%])`);
+    VARIABLE_REFERENCE = /(?:^|[^\w$.@%])[$_@%][A-Za-z_$]/;
+    IF_ELSE = /^\{if\s+([^{}]*)\}([^{}]*?)(?:\{else\s*\}([^{}]*))?\{\/if\s*\}$/;
+    SIMPLE_PATH = /^[$_@%][\w.]+$/;
+  }
+});
+
 // src/core/parsing/widget-arguments.ts
 function splitWidgetArguments(raw) {
   const args2 = [];
@@ -16331,7 +17393,7 @@ var init_parameter_validator = __esm({
           if (/^[_@%]/.test(name)) {
             return new TypeError2(`Variable receiver must be a story variable ($name), got '${name}'`);
           }
-          if (!/^\$?[A-Za-z_][\w$]*(?:\.[\w$]+)*$/.test(name)) {
+          if (!/^(?:\$\w|[A-Za-z_])[\w$]*(?:\.[\w$]+)*$/.test(name)) {
             return new TypeError2(`Argument is not a valid variable receiver: '${name}'`);
           }
           return null;
@@ -16664,6 +17726,7 @@ var init_link_parser = __esm({
 // src/plugins/diagnostics.ts
 function computeDiagnostics(uri, workspace, options) {
   if (!workspace.initialized) return [];
+  if (!workspace.isSpindleProject()) return [];
   try {
     const text = workspace.documents.getText(uri);
     if (text === void 0) return [];
@@ -16679,8 +17742,19 @@ function computeDiagnostics(uri, workspace, options) {
     );
     const allPassages = workspace.passages.getAllPassages();
     const passageNames = new Set(allPassages.map((p) => p.name));
+    let elements = /* @__PURE__ */ new Map();
     try {
-      validateMacros(macros, workspace, diagnostics);
+      const replay = replayElements(markupText, macros, passages, workspace);
+      elements = replay.elements;
+      diagnostics.push(...replay.errors);
+    } catch {
+    }
+    try {
+      validateAttributeBlocks(markupText, passages, workspace, diagnostics);
+    } catch {
+    }
+    try {
+      validateMacros(macros, elements, workspace, diagnostics);
     } catch {
     }
     try {
@@ -16738,7 +17812,7 @@ function maskScriptAndStylesheetPassages(text, passages) {
   }
   return lines.join("\n");
 }
-function validateMacros(macros, workspace, diagnostics) {
+function validateMacros(macros, elements, workspace, diagnostics) {
   for (let curIndex = 0; curIndex < macros.length; curIndex++) {
     const macro = macros[curIndex];
     const info = workspace.macros.getMacro(macro.name);
@@ -16767,7 +17841,7 @@ function validateMacros(macros, workspace, diagnostics) {
         ));
       }
       if (info?.children && info.children.length > 0 && macro.open && macro.pair !== -1) {
-        validateChildren(macros, curIndex, macro, info.children, workspace, diagnostics);
+        validateChildren(macros, curIndex, macro, info.children, elements, workspace, diagnostics);
       }
     } else if (!macro.open) {
       diagnostics.push(makeDiag(
@@ -16777,8 +17851,20 @@ function validateMacros(macros, workspace, diagnostics) {
       ));
     }
     if (info?.parents && info.parents.length > 0 && macro.open) {
-      if (!isInsideParent(macros, curIndex, info.parents, workspace)) {
-        const parentList = info.parents.join(", ");
+      const parentList = info.parents.join(", ");
+      if (DIRECT_CHILD_MACROS.has(macro.name.toLowerCase())) {
+        const element = elements.get(curIndex);
+        const enclosing = element === void 0 ? innermostContainer(macros, curIndex, workspace) : void 0;
+        const parentSet = new Set(info.parents.map((p) => p.toLowerCase()));
+        if (element !== void 0 || !enclosing || !parentSet.has(enclosing.name.toLowerCase())) {
+          const where = element !== void 0 ? `, not inside <${element}>` : enclosing ? `, not inside {${enclosing.name}}` : "";
+          diagnostics.push(makeDiag(
+            macro.range,
+            DiagnosticCode.InvalidChildren,
+            `Invalid: {${macro.name}} can only be directly inside {${parentList}}${where}`
+          ));
+        }
+      } else if (!isInsideParent(macros, curIndex, info.parents, workspace)) {
         diagnostics.push(makeDiag(
           macro.range,
           DiagnosticCode.InvalidChildren,
@@ -16788,6 +17874,146 @@ function validateMacros(macros, workspace, diagnostics) {
     }
   }
 }
+function innermostContainer(macros, index, workspace) {
+  for (let i = index - 1; i >= 0; i--) {
+    const candidate = macros[i];
+    if (!candidate.open || candidate.pair <= index) continue;
+    if (workspace.isContainer(candidate.name)) return candidate;
+  }
+  return void 0;
+}
+function isMarkupPassage(passage) {
+  return !NON_MARKUP_PASSAGES.has(passage.name) && !isScriptOrStylesheetPassage(passage);
+}
+function replayElements(text, macros, passages, workspace) {
+  const replay = { elements: /* @__PURE__ */ new Map(), errors: [] };
+  if (!text.includes("<")) return replay;
+  const lineStarts = buildLineStarts(text);
+  const lineOffset = (line) => lineStarts[line] ?? text.length;
+  const ordered = [...passages].sort((a, b) => a.range.start.line - b.range.start.line);
+  let m = 0;
+  for (const passage of ordered) {
+    const contentStart = lineOffset(passage.range.start.line + 1);
+    const contentEnd = lineOffset(passage.range.end.line + 1);
+    while (m < macros.length && positionToOffset(macros[m].range.start, lineStarts) < contentStart) m++;
+    const first = m;
+    while (m < macros.length && positionToOffset(macros[m].range.start, lineStarts) < contentEnd) m++;
+    const content = text.slice(contentStart, contentEnd);
+    if (!content.includes("<") || !isMarkupPassage(passage)) continue;
+    replayPassage(macros, first, m, scanHtmlTags(content), contentStart, lineStarts, workspace, replay);
+  }
+  return replay;
+}
+function replayPassage(macros, from, to, scan, base, lineStarts, workspace, replay) {
+  const { tags } = scan;
+  const macroStart = (k) => positionToOffset(macros[k].range.start, lineStarts) - base;
+  let certainUntil = scan.stoppedAt === -1 ? Infinity : scan.stoppedAt;
+  const parsed = /* @__PURE__ */ new Set();
+  for (let k = from; k < to; k++) parsed.add(macroStart(k));
+  const unparsed = scan.macros.find((at) => !parsed.has(at));
+  if (unparsed !== void 0) certainUntil = Math.min(certainUntil, unparsed);
+  const stack = [];
+  let t = 0;
+  let s = 0;
+  let lastMacroEnd = -1;
+  const report2 = (range2, message) => {
+    replay.errors.push(makeDiag(range2, DiagnosticCode.MalformedElement, `Malformed element: ${message}`));
+  };
+  const tagRange = (tag) => ({
+    start: offsetToPosition(base + tag.start, lineStarts),
+    end: offsetToPosition(base + tag.end, lineStarts)
+  });
+  const applyTags = (until) => {
+    for (; t < tags.length; t++) {
+      const tag = tags[t];
+      const at = tag.kind === "close" ? tag.start : tag.end;
+      if (at > until) break;
+      if (tag.start >= certainUntil) return false;
+      if (tag.start < lastMacroEnd) return false;
+      if (tag.kind === "open") {
+        stack.push({ element: tag });
+      } else if (tag.kind === "close") {
+        const top = stack[stack.length - 1];
+        const found = `</${tag.name}>`;
+        if (!top) {
+          report2(tagRange(tag), `unexpected closing ${found}`);
+          return false;
+        }
+        if ("macro" in top) {
+          report2(tagRange(tag), `expected {/${macros[top.macro].name}} but found ${found}`);
+          return false;
+        }
+        if (top.element.name.toLowerCase() !== tag.name.toLowerCase()) {
+          report2(tagRange(tag), `expected </${top.element.name}> but found ${found}`);
+          return false;
+        }
+        stack.pop();
+      }
+    }
+    return true;
+  };
+  for (let k = from; k < to; k++) {
+    const macro = macros[k];
+    const start = macroStart(k);
+    if (!applyTags(start)) return;
+    if (start >= certainUntil) return;
+    while (s < scan.macros.length && scan.macros[s] < start) s++;
+    if (scan.macros[s] !== start) return;
+    lastMacroEnd = positionToOffset(macro.range.end, lineStarts) - base;
+    const top = stack[stack.length - 1];
+    if (top && "element" in top) replay.elements.set(k, top.element.name);
+    if (!workspace.isContainer(macro.name)) continue;
+    if (macro.pair === -1) return;
+    if (macro.open) {
+      stack.push({ macro: k });
+      continue;
+    }
+    const opener = stack.pop();
+    if (opener && "element" in opener) {
+      report2(macro.range, `expected </${opener.element.name}> but found {/${macro.name}}`);
+      return;
+    }
+    if (!opener || opener.macro !== macro.pair) return;
+  }
+  if (!applyTags(Infinity) || certainUntil !== Infinity) return;
+  for (const entry of stack) {
+    if ("element" in entry) report2(tagRange(entry.element), `unclosed <${entry.element.name}>`);
+  }
+}
+function validateAttributeBlocks(text, passages, workspace, diagnostics) {
+  if (!text.includes("<")) return;
+  const lineStarts = buildLineStarts(text);
+  const lineOffset = (line) => lineStarts[line] ?? text.length;
+  const lookup = {
+    isMacro: (name) => workspace.macros.getMacro(name) !== void 0 || workspace.widgets.getWidget(name) !== void 0,
+    isContainer: (name) => workspace.isContainer(name)
+  };
+  for (const passage of passages) {
+    if (!isMarkupPassage(passage)) continue;
+    const base = lineOffset(passage.range.start.line + 1);
+    const content = text.slice(base, lineOffset(passage.range.end.line + 1));
+    if (!content.includes("<") || !content.includes("{")) continue;
+    let rawText;
+    for (const tag of scanHtmlTags(content).tags) {
+      const name = tag.name.toLowerCase();
+      if (rawText !== void 0) {
+        if (tag.kind === "close" && name === rawText) rawText = void 0;
+        continue;
+      }
+      for (const [start, end] of tag.values ?? []) {
+        for (const block of findUnevaluatedBlocks(content.slice(start, end), lookup)) {
+          const range2 = {
+            start: offsetToPosition(base + start + block.start, lineStarts),
+            end: offsetToPosition(base + start + block.end, lineStarts)
+          };
+          const message = block.kind === "macro" ? MACRO_IN_ATTRIBUTE(block.macro) : EXPRESSION_IN_ATTRIBUTE;
+          diagnostics.push(makeDiag(range2, DiagnosticCode.UnevaluatedAttributeBlock, message));
+        }
+      }
+      if (tag.kind === "open" && RAW_TEXT_ELEMENTS.has(name)) rawText = name;
+    }
+  }
+}
 function isInsideParent(macros, index, parents, workspace) {
   const parentSet = new Set(parents.map((p) => p.toLowerCase()));
   for (let i = index - 1; i >= 0; i--) {
@@ -16803,18 +18029,18 @@ function isInsideParent(macros, index, parents, workspace) {
   }
   return false;
 }
-function validateChildren(macros, curIndex, parentMacro, childConstraints, workspace, diagnostics) {
+function validateChildren(macros, curIndex, parentMacro, childConstraints, elements, workspace, diagnostics) {
   const children = /* @__PURE__ */ Object.create(null);
   const startIndex = curIndex + 1;
   const endIndex = parentMacro.pair;
   for (let i = startIndex; i < endIndex; i++) {
     const child = macros[i];
-    const childInfo = workspace.macros.getMacro(child.name);
-    if (!childInfo) continue;
-    if (childInfo.block && child.open && child.pair !== -1) {
+    if (child.open && child.pair !== -1 && workspace.isContainer(child.name)) {
       i = child.pair;
       continue;
     }
+    if (elements.has(i)) continue;
+    if (!workspace.macros.getMacro(child.name)) continue;
     const childKey = child.name.toLowerCase();
     if (childConstraints.some((c3) => c3.name.toLowerCase() === childKey)) {
       children[childKey] = (children[childKey] ?? 0) + 1;
@@ -16929,15 +18155,25 @@ function validateVariables(uri, workspace, diagnostics) {
         `Variable '$${u.name}' is not declared in StoryVariables`
       ));
     }
+    for (const a of workspace.variables.getPrimitiveFieldAccesses(uri)) {
+      diagnostics.push(makeDiag(
+        a.range,
+        DiagnosticCode.PrimitiveFieldAccess,
+        `Cannot access field "${a.field}" on ${a.path} (type: ${a.type}). Spindle checks field access against the StoryVariables defaults and will not start the story.`
+      ));
+    }
     const storyVars = workspace.passages.getStoryVariables();
     if (storyVars && storyVars.uri === uri) {
       for (const nd of workspace.variables.getNullDeclarations()) {
         diagnostics.push(makeDiag(
           nd.range,
           DiagnosticCode.NullVariableValue,
-          `Variable '$${nd.name}' is set to null. Spindle does not support null \u2014 use a valid default (number, string, boolean, array, or object).`
+          `${nullSubject(nd)} is set to null. Spindle does not support null \u2014 use a valid default (number, string, boolean, array, or object).`
         ));
       }
+      for (const d of workspace.variables.getInvalidDeclarations()) {
+        diagnostics.push(makeDiag(d.range, DiagnosticCode.InvalidDeclaration, `${d.message} ${WILL_NOT_START}`));
+      }
     }
   }
   if (workspace.variables.hasStoryTransients()) {
@@ -16955,12 +18191,20 @@ function validateVariables(uri, workspace, diagnostics) {
         diagnostics.push(makeDiag(
           nd.range,
           DiagnosticCode.NullVariableValue,
-          `Transient variable '%${nd.name}' is set to null. Spindle does not support null \u2014 use a valid default (number, string, boolean, array, or object).`
+          `${nullSubject(nd)} is set to null. Spindle does not support null \u2014 use a valid default (number, string, boolean, array, or object).`
         ));
       }
+      for (const d of workspace.variables.getInvalidTransientDeclarations()) {
+        diagnostics.push(makeDiag(d.range, DiagnosticCode.InvalidDeclaration, `${d.message} ${WILL_NOT_START}`));
+      }
     }
   }
 }
+function nullSubject(nd) {
+  const variable = nd.sigil === "%" ? "Transient variable" : "Variable";
+  if (nd.field?.length) return `Field '${nd.sigil}${[nd.name, ...nd.field].join(".")}'`;
+  return `${variable} '${nd.sigil}${nd.name}'`;
+}
 function validateLinks(text, passages, passageNames, diagnostics) {
   const links = parseLinks(text);
   for (const link of links) {
@@ -17177,7 +18421,7 @@ function widgetDefinitionNames(content) {
   while ((m = re.exec(content)) !== null) names.push(m[2]);
   return names;
 }
-function passageContent(passage, workspace) {
+function passageContent2(passage, workspace) {
   const text = workspace.documents.getText(passage.uri) ?? "";
   return text.split("\n").slice(passage.range.start.line + 1, passage.range.end.line + 1).join("\n");
 }
@@ -17190,7 +18434,7 @@ function validateWidgetIncludes(text, macros, workspace, diagnostics) {
     if (target === null) continue;
     const passage = workspace.passages.getPassage(target);
     if (!passage?.tags?.includes("widget")) continue;
-    const widgets = widgetDefinitionNames(passageContent(passage, workspace));
+    const widgets = widgetDefinitionNames(passageContent2(passage, workspace));
     if (widgets.length === 0) continue;
     const list = widgets.map((w) => `{${w}}`).join(", ");
     diagnostics.push(makeDiag(
@@ -17263,18 +18507,32 @@ function toLspDiagnostic(d) {
     message: d.message
   };
 }
-var DEFERRED_CONTAINERS, EXPRESSION_BUILTINS2, diagnosticsPlugin;
+var DIRECT_CHILD_MACROS, NON_MARKUP_PASSAGES, RAW_TEXT_ELEMENTS, MACRO_IN_ATTRIBUTE, EXPRESSION_IN_ATTRIBUTE, WILL_NOT_START, DEFERRED_CONTAINERS, EXPRESSION_BUILTINS2, diagnosticsPlugin;
 var init_diagnostics = __esm({
   "src/plugins/diagnostics.ts"() {
     "use strict";
     init_diagnostic_codes();
     init_macro_parser();
     init_argument_lexer();
+    init_html_scanner();
+    init_attribute_blocks();
     init_widget_arguments();
     init_parameter_validator();
     init_link_parser();
     init_passage_parser();
     init_macro_sources();
+    DIRECT_CHILD_MACROS = /* @__PURE__ */ new Set(["elseif", "else", "case", "default", "next", "option"]);
+    NON_MARKUP_PASSAGES = /* @__PURE__ */ new Set([
+      "StoryTitle",
+      "StoryData",
+      "StoryVariables",
+      "StoryTransients",
+      "SaveTitle"
+    ]);
+    RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style"]);
+    MACRO_IN_ATTRIBUTE = (macro) => `Macros are not evaluated inside HTML attributes, so Spindle outputs this {${macro}} as text. Use an expression such as {$x ? 'a' : 'b'}`;
+    EXPRESSION_IN_ATTRIBUTE = "Spindle evaluates {\u2026} in an HTML attribute only when $, _, @ or % follows the brace, so it outputs this block as text. Start the expression with a variable, as in {$x ? 'a' : 'b'}";
+    WILL_NOT_START = "Spindle will not start the story.";
     DEFERRED_CONTAINERS = /* @__PURE__ */ new Set(["link", "button"]);
     EXPRESSION_BUILTINS2 = /* @__PURE__ */ new Set([
       "currentPassage",
@@ -17302,12 +18560,14 @@ var init_diagnostics = __esm({
             diagnostics: diags.filter(isEnabled).map((d) => toLspDiagnostic(d))
           });
         };
-        ctx.workspace.on("modelReady", () => {
+        const publishAll = () => {
           for (const uri of ctx.workspace.documents.getUris()) {
             if (isMacroSource(uri)) continue;
             publishFor(uri);
           }
-        });
+        };
+        ctx.workspace.on("modelReady", publishAll);
+        ctx.workspace.on("storyFormatChanged", publishAll);
         ctx.workspace.on("documentChanged", publishFor);
         ctx.workspace.on("documentClosed", (uri) => {
           ctx.connection.sendDiagnostics({ uri, diagnostics: [] });
@@ -17484,7 +18744,7 @@ var check_exports = {};
 __export(check_exports, {
   runCheck: () => runCheck
 });
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 function parseArgs(args2) {
@@ -17605,16 +18865,22 @@ async function runCheck(args2) {
     }
     projectConfig = loadConfigFromDisk(configRoot);
   }
-  const workspace = new WorkspaceModel({ workspaceRoot: commonDir });
   const fileContents = /* @__PURE__ */ new Map();
   for (const filePath of uniqueFiles) {
     try {
-      const text = readFileSync5(filePath, "utf-8");
+      const text = readFileSync6(filePath, "utf-8");
       const uri = pathToFileURL3(filePath).toString();
       fileContents.set(uri, text);
     } catch {
     }
   }
+  const storyFormat = await findStoryFormat(fileContents.values(), commonDir);
+  if (!storyFormat.isSpindle) {
+    console.error(skippedFormatNote(storyFormat));
+    report(options.format, []);
+    return 0;
+  }
+  const workspace = new WorkspaceModel({ workspaceRoot: commonDir });
   const workspaceContents = new Map(fileContents);
   await addProjectMacroSources(workspaceContents, commonDir);
   workspace.initialize(workspaceContents);
@@ -17639,19 +18905,22 @@ async function runCheck(args2) {
       }
     }
   }
-  switch (options.format) {
+  report(options.format, allResults);
+  workspace.dispose();
+  return hasErrors ? 1 : 0;
+}
+function report(format, results) {
+  switch (format) {
     case "pretty":
-      console.log(formatPretty(allResults));
+      console.log(formatPretty(results));
       break;
     case "json":
-      console.log(formatJson(allResults));
+      console.log(formatJson(results));
       break;
     case "sarif":
-      console.log(formatSarif(allResults));
+      console.log(formatSarif(results));
       break;
   }
-  workspace.dispose();
-  return hasErrors ? 1 : 0;
 }
 var SEVERITY_ORDER;
 var init_check = __esm({
@@ -17662,6 +18931,7 @@ var init_check = __esm({
     init_diagnostics();
     init_config_loader();
     init_macro_sources();
+    init_story_format();
     init_pretty();
     init_json();
     init_sarif();
@@ -17705,13 +18975,17 @@ function splitPassages(text) {
   return passages;
 }
 function classifyPassage(header) {
-  const tagMatch = header.match(/\[([^\]]*)\]/g);
-  if (!tagMatch) return "normal";
-  const tags = tagMatch.flatMap((t) => t.slice(1, -1).toLowerCase().split(/\s+/));
+  const tags = headerTags(header).map((t) => t.toLowerCase());
   if (tags.includes("script")) return "script";
   if (tags.includes("stylesheet")) return "stylesheet";
   return "normal";
 }
+function headerTags(header) {
+  const parsed = parsePassageHeader(header, 0);
+  if (parsed) return parsed.tags;
+  const unescaped = header.replace(/\\./g, "ec");
+  return (unescaped.match(/\[[^\]]*\]/g) ?? []).flatMap((t) => t.slice(1, -1).split(/\s+/));
+}
 function segmentRegions(body) {
   const lines = body.split("\n");
   if (lines.length > 0 && lines[lines.length - 1] === "") {
@@ -17758,7 +19032,7 @@ function segmentRegions(body) {
     if (/^<([a-zA-Z][\w-]*)/.test(trimmed2)) {
       const tagMatch = trimmed2.match(/^<([a-zA-Z][\w-]*)/);
       const tagName = tagMatch[1].toLowerCase();
-      if (VOID_ELEMENTS.has(tagName) && !lines[i + 1]?.trim().startsWith("<")) {
+      if (VOID_ELEMENTS2.has(tagName) && !lines[i + 1]?.trim().startsWith("<")) {
         pushSpindleLine(regions, line);
         i++;
         continue;
@@ -17795,12 +19069,13 @@ function pushSpindleLine(regions, line) {
     regions.push({ type: "spindle", lines: [line] });
   }
 }
-var PASSAGE_HEADER_REGEX, VOID_ELEMENTS;
+var PASSAGE_HEADER_REGEX, VOID_ELEMENTS2;
 var init_segment = __esm({
   "src/plugins/format/segment.ts"() {
     "use strict";
+    init_passage_parser();
     PASSAGE_HEADER_REGEX = /^::\s+/;
-    VOID_ELEMENTS = /* @__PURE__ */ new Set([
+    VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
       "area",
       "base",
       "br",
@@ -18287,11 +19562,12 @@ var init_format = __esm({
   "src/plugins/format.ts"() {
     "use strict";
     init_macro_supplements();
+    init_macro_parser();
     init_segment();
     init_prettier_bridge();
     init_placeholders();
     PASSAGE_HEADER_REGEX2 = /^(::)\s+/;
-    MACRO_OPEN_REGEX = /^\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\b/;
+    MACRO_OPEN_REGEX = new RegExp(String.raw`^\{(?:${SELECTOR_PATTERN} )?([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]|$)/;
@@ -18304,7 +19580,8 @@ var init_format = __esm({
       },
       initialize(ctx) {
         const formatOpts = {
-          isBlock: (name) => ctx.workspace.macros.isBlock(name),
+          // Block widgets (whose body renders {@children}) are containers too
+          isBlock: (name) => ctx.workspace.isContainer(name),
           isDedentingSubMacro: (name) => DEFAULT_DEDENTING.has(name.toLowerCase())
         };
         ctx.connection.onDocumentFormatting(async (params) => {
@@ -18349,7 +19626,7 @@ var format_exports = {};
 __export(format_exports, {
   runFormat: () => runFormat
 });
-import { readFileSync as readFileSync6, writeFileSync } from "node:fs";
+import { readFileSync as readFileSync7, writeFileSync } from "node:fs";
 function parseArgs2(args2) {
   const options = {
     check: false,
@@ -18399,14 +19676,25 @@ async function runFormat(args2) {
     console.log("No files found");
     return 0;
   }
+  const texts = /* @__PURE__ */ new Map();
+  for (const filePath of uniqueFiles) {
+    try {
+      texts.set(filePath, readFileSync7(filePath, "utf-8"));
+    } catch {
+    }
+  }
+  const storyFormat = await findStoryFormat(texts.values(), commonDirectory(uniqueFiles));
+  if (!storyFormat.isSpindle) {
+    console.error(skippedFormatNote(storyFormat));
+    return 0;
+  }
   const formatOpts = {};
   if (options.maxLineLength !== null) {
     formatOpts.maxLineLength = options.maxLineLength;
   }
   const unformatted = [];
-  for (const filePath of uniqueFiles) {
+  for (const [filePath, text] of texts) {
     try {
-      const text = readFileSync6(filePath, "utf-8");
       const formatted = await formatDocument(text, formatOpts);
       if (formatted !== text) {
         if (options.check) {
@@ -18437,6 +19725,8 @@ var init_format2 = __esm({
     "use strict";
     init_esm6();
     init_format();
+    init_macro_sources();
+    init_story_format();
   }
 });
 
@@ -49584,9 +50874,12 @@ var init_stdio2 = __esm({
 var server_exports = {};
 __export(server_exports, {
   checkFiles: () => checkFiles,
+  checkFormatting: () => checkFormatting,
+  checkProject: () => checkProject,
+  formatFiles: () => formatFiles,
   startMcpServer: () => startMcpServer
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 function filterBySeverity2(diagnostics, minSeverity) {
@@ -49618,20 +50911,28 @@ function findConfigRoot(commonDir) {
   }
   return configRoot;
 }
-async function createWorkspace(files) {
-  const commonDir = commonDirectory(files);
-  const configRoot = findConfigRoot(commonDir);
-  const projectConfig = loadConfigFromDisk(configRoot);
-  const workspace = new WorkspaceModel({ workspaceRoot: configRoot });
+function readFiles(files) {
   const fileContents = /* @__PURE__ */ new Map();
   for (const filePath of files) {
     try {
-      const text = readFileSync7(filePath, "utf-8");
+      const text = readFileSync8(filePath, "utf-8");
       const uri = pathToFileURL4(filePath).toString();
       fileContents.set(uri, text);
     } catch {
     }
   }
+  return fileContents;
+}
+async function skippedReason(fileContents, files) {
+  const format = await findStoryFormat(fileContents.values(), commonDirectory(files));
+  return format.isSpindle ? void 0 : skippedFormatNote(format);
+}
+async function createWorkspace(files, fileContents) {
+  const commonDir = commonDirectory(files);
+  const configRoot = findConfigRoot(commonDir);
+  const projectConfig = loadConfigFromDisk(configRoot);
+  const workspace = new WorkspaceModel({ workspaceRoot: configRoot });
+  fileContents = new Map(fileContents);
   await addProjectMacroSources(fileContents, commonDir);
   workspace.initialize(fileContents);
   if (Object.keys(projectConfig.macros).length > 0) {
@@ -49640,9 +50941,15 @@ async function createWorkspace(files) {
   return workspace;
 }
 async function checkFiles(pattern, severity, cwd = process.cwd()) {
+  return (await checkProject(pattern, severity, cwd)).results;
+}
+async function checkProject(pattern, severity, cwd = process.cwd()) {
   const files = await resolveFiles(pattern, cwd);
-  if (files.length === 0) return [];
-  const workspace = await createWorkspace(files);
+  if (files.length === 0) return { results: [] };
+  const fileContents = readFiles(files);
+  const skipped = await skippedReason(fileContents, files);
+  if (skipped) return { results: [], skipped };
+  const workspace = await createWorkspace(files, fileContents);
   try {
     const results = [];
     for (const filePath of files) {
@@ -49664,11 +50971,57 @@ async function checkFiles(pattern, severity, cwd = process.cwd()) {
         });
       }
     }
-    return results;
+    return { results };
   } finally {
     workspace.dispose();
   }
 }
+function relativeTo(cwd, filePath) {
+  return filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+}
+async function formatFiles(pattern, cwd = process.cwd()) {
+  const files = await resolveFiles(pattern, cwd);
+  const contents = readFiles(files);
+  const skipped = files.length > 0 ? await skippedReason(contents, files) : void 0;
+  if (skipped) return { formatted: 0, unchanged: 0, files: [], skipped };
+  let formatted = 0;
+  let unchanged = 0;
+  const changedFiles = [];
+  for (const filePath of files) {
+    const text = contents.get(pathToFileURL4(filePath).toString());
+    if (text === void 0) continue;
+    try {
+      const result = await formatDocument(text);
+      if (result !== text) {
+        writeFileSync2(filePath, result, "utf-8");
+        formatted++;
+        changedFiles.push(relativeTo(cwd, filePath));
+      } else {
+        unchanged++;
+      }
+    } catch {
+    }
+  }
+  return { formatted, unchanged, files: changedFiles };
+}
+async function checkFormatting(pattern, cwd = process.cwd()) {
+  const files = await resolveFiles(pattern, cwd);
+  const contents = readFiles(files);
+  const skipped = files.length > 0 ? await skippedReason(contents, files) : void 0;
+  if (skipped) return { needsFormatting: [], alreadyFormatted: [], skipped };
+  const needsFormatting = [];
+  const alreadyFormatted = [];
+  for (const filePath of files) {
+    const text = contents.get(pathToFileURL4(filePath).toString());
+    if (text === void 0) continue;
+    try {
+      const result = await formatDocument(text);
+      (result !== text ? needsFormatting : alreadyFormatted).push(relativeTo(cwd, filePath));
+    } catch {
+    }
+  }
+  return { needsFormatting, alreadyFormatted };
+}
 async function startMcpServer() {
   const server = new McpServer({
     name: "spindle-lsp",
@@ -49682,9 +51035,12 @@ async function startMcpServer() {
       severity: external_exports3.enum(["error", "warning", "info", "hint"]).optional().describe("Minimum severity to include")
     },
     async (args2) => {
-      const results = await checkFiles(args2.path, args2.severity);
+      const { results, skipped } = await checkProject(args2.path, args2.severity);
       return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        content: [
+          { type: "text", text: JSON.stringify(results, null, 2) },
+          ...skipped ? [{ type: "text", text: skipped }] : []
+        ]
       };
     }
   );
@@ -49695,27 +51051,7 @@ async function startMcpServer() {
       path: external_exports3.string().default("**/*.{tw,twee}").describe("Glob pattern or directory to format")
     },
     async (args2) => {
-      const cwd = process.cwd();
-      const files = await resolveFiles(args2.path, cwd);
-      let formatted = 0;
-      let unchanged = 0;
-      const changedFiles = [];
-      for (const filePath of files) {
-        try {
-          const text = readFileSync7(filePath, "utf-8");
-          const result = await formatDocument(text);
-          if (result !== text) {
-            writeFileSync2(filePath, result, "utf-8");
-            formatted++;
-            const relativePath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-            changedFiles.push(relativePath);
-          } else {
-            unchanged++;
-          }
-        } catch {
-        }
-      }
-      const output = { formatted, unchanged, files: changedFiles };
+      const output = await formatFiles(args2.path);
       return {
         content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
       };
@@ -49728,24 +51064,7 @@ async function startMcpServer() {
       path: external_exports3.string().default("**/*.{tw,twee}").describe("Glob pattern or directory to check")
     },
     async (args2) => {
-      const cwd = process.cwd();
-      const files = await resolveFiles(args2.path, cwd);
-      const needsFormatting = [];
-      const alreadyFormatted = [];
-      for (const filePath of files) {
-        try {
-          const text = readFileSync7(filePath, "utf-8");
-          const result = await formatDocument(text);
-          const relativePath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-          if (result !== text) {
-            needsFormatting.push(relativePath);
-          } else {
-            alreadyFormatted.push(relativePath);
-          }
-        } catch {
-        }
-      }
-      const output = { needsFormatting, alreadyFormatted };
+      const output = await checkFormatting(args2.path);
       return {
         content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
       };
@@ -49767,6 +51086,7 @@ var init_server3 = __esm({
     init_macro_sources();
     init_diagnostics();
     init_format();
+    init_story_format();
     SEVERITY_ORDER2 = ["hint", "info", "warning", "error"];
   }
 });
@@ -58894,6 +60214,62 @@ var init_capabilities = __esm({
   }
 });
 
+// src/server/story-format-gate.ts
+function gateRegistrations(target, methods, enabled, nested = {}) {
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof prop !== "string") return value;
+      if (Object.hasOwn(nested, prop) && value !== null && (typeof value === "object" || typeof value === "function")) {
+        return nested[prop](value);
+      }
+      if (methods.includes(prop) && typeof value === "function") {
+        return (handler, ...rest) => Reflect.apply(value, obj, [
+          (...args2) => enabled() ? handler(...args2) : null,
+          ...rest
+        ]);
+      }
+      return value;
+    }
+  });
+}
+function gateConnection(connection, enabled) {
+  const languageFeatures = {};
+  for (const [feature, methods] of Object.entries(GATED_LANGUAGE_FEATURES)) {
+    languageFeatures[feature] = (value) => gateRegistrations(value, methods, enabled);
+  }
+  return gateRegistrations(connection, GATED_REQUESTS, enabled, {
+    languages: (value) => gateRegistrations(value, [], enabled, languageFeatures)
+  });
+}
+var GATED_REQUESTS, GATED_LANGUAGE_FEATURES;
+var init_story_format_gate = __esm({
+  "src/server/story-format-gate.ts"() {
+    "use strict";
+    GATED_REQUESTS = [
+      "onCompletion",
+      "onHover",
+      "onSignatureHelp",
+      "onDefinition",
+      "onReferences",
+      "onPrepareRename",
+      "onRenameRequest",
+      "onCodeLens",
+      "onCodeAction",
+      "onDocumentFormatting",
+      "onDocumentRangeFormatting",
+      "onDocumentSymbol",
+      "onWorkspaceSymbol",
+      "onFoldingRanges",
+      "onDocumentLinks"
+    ];
+    GATED_LANGUAGE_FEATURES = {
+      semanticTokens: ["on"],
+      inlayHint: ["on"]
+    };
+  }
+});
+
 // src/plugins/completions.ts
 function getCompletions(uri, position, triggerChar, workspace) {
   const text = workspace.documents.getText(uri);
@@ -58901,14 +60277,15 @@ function getCompletions(uri, position, triggerChar, workspace) {
   const lines = text.split("\n");
   if (position.line >= lines.length) return [];
   const lineText = lines[position.line].substring(0, position.character);
+  const inAttribute = () => inAttributeValue(text, (buildLineStarts(text)[position.line] ?? 0) + position.character - 1);
   if (/\{\/[A-Za-z\w-]*$/.test(lineText)) {
-    return getClosingMacroCompletions(uri, text, position, workspace);
+    return inAttribute() ? [] : getClosingMacroCompletions(uri, text, position, workspace);
   }
-  const transientDotPathMatch = /%([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)?$/.exec(lineText);
+  const transientDotPathMatch = /%([\w$]+)\.([A-Za-z_$][\w$]*)?$/.exec(lineText);
   if (transientDotPathMatch) {
     return getTransientDotPathCompletions(transientDotPathMatch[1], workspace);
   }
-  const dotPathMatch = /\$([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)?$/.exec(lineText);
+  const dotPathMatch = /\$([\w$]+)\.([A-Za-z_$][\w$]*)?$/.exec(lineText);
   if (dotPathMatch) {
     return getDotPathCompletions(dotPathMatch[1], workspace);
   }
@@ -58928,7 +60305,7 @@ function getCompletions(uri, position, triggerChar, workspace) {
     return getPassageNameCompletions(workspace);
   }
   if (/(?:^|[^\\])\{[A-Za-z\w-]*$/.test(lineText)) {
-    return getMacroCompletions(workspace);
+    return inAttribute() ? [] : getMacroCompletions(workspace);
   }
   return [];
 }
@@ -59100,6 +60477,7 @@ var init_completions = __esm({
   "src/plugins/completions.ts"() {
     "use strict";
     init_macro_parser();
+    init_html_scanner();
     completionsPlugin = {
       id: "completions",
       capabilities: {
@@ -59122,6 +60500,215 @@ var init_completions = __esm({
   }
 });
 
+// src/plugins/references.ts
+function findReferences(uri, position, workspace, includeDeclaration) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return [];
+  const lines = text.split("\n");
+  if (position.line >= lines.length) return [];
+  const line = lines[position.line];
+  const header = parsePassageHeader(line, position.line);
+  if (header) {
+    const { start, end } = header.nameRange;
+    if (position.character >= start.character && position.character <= end.character) {
+      return findPassageReferences(header.name, workspace, includeDeclaration);
+    }
+  }
+  {
+    const varRegex = /\$([\w$]+)/g;
+    let match2;
+    while ((match2 = varRegex.exec(line)) !== null) {
+      const start = match2.index;
+      const end = start + match2[0].length;
+      if (position.character >= start && position.character <= end) {
+        const varName = match2[1];
+        return findVariableReferences(varName, workspace, includeDeclaration);
+      }
+    }
+  }
+  {
+    const transRegex = /(?<!\w)%([\w$]+)/g;
+    let match2;
+    while ((match2 = transRegex.exec(line)) !== null) {
+      const start = match2.index;
+      const end = start + match2[0].length;
+      if (position.character >= start && position.character <= end) {
+        const varName = match2[1];
+        if (!isTransientAt(varName, uri, position.line, start, workspace)) break;
+        return findTransientReferences(varName, workspace, includeDeclaration);
+      }
+    }
+  }
+  {
+    const widgetRegex = /\{\/?([A-Za-z_$][\w$]*)/g;
+    let match2;
+    while ((match2 = widgetRegex.exec(line)) !== null) {
+      const name = match2[1];
+      const nameStart = match2.index + match2[0].length - name.length;
+      const nameEnd = nameStart + name.length;
+      if (position.character >= nameStart && position.character <= nameEnd) {
+        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));
+    const wordRegex = /[A-Za-z_$][\w$\s]*/g;
+    let match2;
+    while ((match2 = wordRegex.exec(line)) !== null) {
+      const start = match2.index;
+      const end = start + match2[0].length;
+      if (position.character >= start && position.character <= end) {
+        const word = match2[0].trim();
+        if (passageNames.has(word)) {
+          return findPassageReferences(word, workspace, includeDeclaration);
+        }
+      }
+    }
+  }
+  return [];
+}
+function findPassageReferences(passageName, workspace, includeDeclaration) {
+  const locations = [];
+  if (includeDeclaration) {
+    const passage = workspace.passages.getPassage(passageName);
+    if (passage) {
+      locations.push({
+        uri: passage.uri,
+        range: passage.nameRange
+      });
+    }
+  }
+  for (const docUri of workspace.documents.getUris()) {
+    if (isMacroSource(docUri)) continue;
+    const docText = workspace.documents.getText(docUri);
+    if (!docText) continue;
+    for (const ref of [...parseLinks(docText), ...parseMacroPassageRefs(docText)]) {
+      if (ref.name === passageName) {
+        locations.push({ uri: docUri, range: ref.range });
+      }
+    }
+  }
+  return locations;
+}
+function findVariableReferences(varName, workspace, includeDeclaration) {
+  const locations = [];
+  if (includeDeclaration) {
+    const decl = workspace.variables.getDeclared().get(varName);
+    if (decl?.declarationRange && decl.declarationUri) {
+      locations.push({
+        uri: decl.declarationUri,
+        range: decl.declarationRange
+      });
+    }
+  }
+  const usages = workspace.variables.getUsages(varName);
+  for (const u of usages) {
+    locations.push({ uri: u.uri, range: u.range });
+  }
+  return locations;
+}
+function isTransientAt(name, uri, line, character, workspace) {
+  if (!/^\d/.test(name)) return true;
+  const at = (u) => u.uri === uri && u.range?.start.line === line && u.range.start.character === character;
+  const decl = workspace.variables.getDeclaredTransient().get(name);
+  if (decl && at({ uri: decl.declarationUri, range: decl.declarationRange })) return true;
+  return workspace.variables.getTransientUsages(name).some(at);
+}
+function findTransientReferences(varName, workspace, includeDeclaration) {
+  const results = [];
+  if (includeDeclaration) {
+    const decl = workspace.variables.getDeclaredTransient().get(varName);
+    if (decl?.declarationUri && decl.declarationRange) {
+      results.push({ uri: decl.declarationUri, range: decl.declarationRange });
+    }
+  }
+  const usages = workspace.variables.getTransientUsages(varName);
+  for (const u of usages) {
+    results.push({ uri: u.uri, range: u.range });
+  }
+  return results;
+}
+function findWidgetReferences(widgetName, workspace, includeDeclaration) {
+  const locations = [];
+  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 lowerName = widgetName.toLowerCase();
+  const isBlock = widget?.block ?? false;
+  for (const docUri of workspace.documents.getUris()) {
+    if (isMacroSource(docUri)) continue;
+    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];
+      widgetInvocationRegex.lastIndex = 0;
+      let match2;
+      while ((match2 = widgetInvocationRegex.exec(line)) !== null) {
+        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 + match2[2].length }
+            }
+          });
+        }
+      }
+    }
+  }
+  return locations;
+}
+function toLspRange(r) {
+  return {
+    start: { line: r.start.line, character: r.start.character },
+    end: { line: r.end.line, character: r.end.character }
+  };
+}
+var referencesPlugin;
+var init_references = __esm({
+  "src/plugins/references.ts"() {
+    "use strict";
+    init_link_parser();
+    init_passage_parser();
+    init_macro_sources();
+    referencesPlugin = {
+      id: "references",
+      capabilities: {
+        referencesProvider: true
+      },
+      initialize(ctx) {
+        ctx.connection.onReferences((params) => {
+          const refs = findReferences(
+            params.textDocument.uri,
+            { line: params.position.line, character: params.position.character },
+            ctx.workspace,
+            params.context.includeDeclaration
+          );
+          return refs.map((r) => ({
+            uri: r.uri,
+            range: toLspRange(r.range)
+          }));
+        });
+      }
+    };
+  }
+});
+
 // src/plugins/hover.ts
 function getHoverInfo(uri, position, workspace) {
   const text = workspace.documents.getText(uri);
@@ -59129,20 +60716,22 @@ function getHoverInfo(uri, position, workspace) {
   const lines = text.split("\n");
   if (position.line >= lines.length) return null;
   const line = lines[position.line];
-  const macroResult = getMacroHover(line, position, workspace);
+  const offset = (buildLineStarts(text)[position.line] ?? 0) + position.character;
+  const inAttribute = inAttributeValue(text, offset);
+  const macroResult = inAttribute ? null : getMacroHover(line, position, workspace);
   if (macroResult) return macroResult;
-  const varResult = getVariableHover(line, position, workspace);
+  const varResult = getVariableHover(uri, line, position, workspace);
   if (varResult) return varResult;
-  const widgetResult = getWidgetHover(line, position, workspace);
+  const widgetResult = inAttribute ? null : getWidgetHover(line, position, workspace);
   if (widgetResult) return widgetResult;
   return null;
 }
 function getMacroHover(line, position, workspace) {
-  const macroRegex = /\{(\/)?(?:(?:[#.][a-zA-Z][\w-]*\s*)*)([A-Za-z][\w-]*)/g;
+  const macroRegex = new RegExp(String.raw`\{(?:(\/)|${SELECTOR_PATTERN} )?([A-Za-z][\w-]*)`, "g");
   let match2;
   while ((match2 = macroRegex.exec(line)) !== null) {
     const name = match2[2];
-    const nameStart = match2.index + match2[0].indexOf(name);
+    const nameStart = match2.index + match2[0].length - name.length;
     const nameEnd = nameStart + name.length;
     if (position.character >= nameStart && position.character <= nameEnd) {
       const info = workspace.macros.getMacro(name);
@@ -59171,9 +60760,9 @@ function getMacroHover(line, position, workspace) {
   }
   return null;
 }
-function getVariableHover(line, position, workspace) {
+function getVariableHover(uri, line, position, workspace) {
   {
-    const re = /\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+    const re = /\$([\w$]+(?:\.[A-Za-z_$][\w$]*)*)/g;
     let match2;
     while ((match2 = re.exec(line)) !== null) {
       const start = match2.index;
@@ -59229,13 +60818,14 @@ Fields: ${decl.fields.map((f) => `\`${f}\``).join(", ")}` : "";
     }
   }
   {
-    const re = /(?<!\w)%([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+    const re = /(?<!\w)%([\w$]+(?:\.[A-Za-z_$][\w$]*)*)/g;
     let match2;
     while ((match2 = re.exec(line)) !== null) {
       const start = match2.index;
       const end = start + match2[0].length;
       if (position.character >= start && position.character <= end) {
         const baseName = match2[1].split(".")[0];
+        if (!isTransientAt(baseName, uri, position.line, start, workspace)) break;
         const decl = workspace.variables.getDeclaredTransient().get(baseName);
         const typeInfo = decl?.fields && decl.fields.length > 0 ? `
 
@@ -59282,7 +60872,7 @@ Defined in: \`${widget.uri}\``,
     }
   };
 }
-function toLspRange(r) {
+function toLspRange2(r) {
   return {
     start: { line: r.start.line, character: r.start.character },
     end: { line: r.end.line, character: r.end.character }
@@ -59292,6 +60882,9 @@ var hoverPlugin;
 var init_hover = __esm({
   "src/plugins/hover.ts"() {
     "use strict";
+    init_macro_parser();
+    init_references();
+    init_html_scanner();
     hoverPlugin = {
       id: "hover",
       capabilities: {
@@ -59307,7 +60900,7 @@ var init_hover = __esm({
           if (!result) return null;
           return {
             contents: { kind: "markdown", value: result.contents },
-            range: toLspRange(result.range)
+            range: toLspRange2(result.range)
           };
         });
       }
@@ -59374,7 +60967,7 @@ var init_signature = __esm({
     init_argument_lexer();
     init_widget_arguments();
     init_macro_parser();
-    macroHeadRegex2 = /(?<!\\)\{(?:[#.][a-zA-Z][\w-]*\s*)*([A-Za-z][\w-]*)\s+/g;
+    macroHeadRegex2 = new RegExp(String.raw`(?<!\\)\{(?:${SELECTOR_PATTERN} )?([A-Za-z][\w-]*)\s+`, "g");
     signaturePlugin = {
       id: "signature",
       capabilities: {
@@ -59449,7 +61042,7 @@ function getWidgetDefinition(line, position, workspace) {
   }
   return null;
 }
-function toLspRange2(r) {
+function toLspRange3(r) {
   return {
     start: { line: r.start.line, character: r.start.character },
     end: { line: r.end.line, character: r.end.character }
@@ -59475,7 +61068,7 @@ var init_definition = __esm({
           if (!result) return null;
           return {
             uri: result.uri,
-            range: toLspRange2(result.range)
+            range: toLspRange3(result.range)
           };
         });
       }
@@ -59483,211 +61076,6 @@ var init_definition = __esm({
   }
 });
 
-// src/plugins/references.ts
-function findReferences(uri, position, workspace, includeDeclaration) {
-  const text = workspace.documents.getText(uri);
-  if (text === void 0) return [];
-  const lines = text.split("\n");
-  if (position.line >= lines.length) return [];
-  const line = lines[position.line];
-  const passageHeaderRegex2 = /^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/;
-  if (line.trimStart().startsWith("::")) {
-    const headerMatch = passageHeaderRegex2.exec(line);
-    if (headerMatch) {
-      const passageName = headerMatch[1].trim();
-      const nameStart = line.indexOf(passageName);
-      const nameEnd = nameStart + passageName.length;
-      if (position.character >= nameStart && position.character <= nameEnd) {
-        return findPassageReferences(passageName, workspace, includeDeclaration);
-      }
-    }
-  }
-  {
-    const varRegex = /\$([A-Za-z_$][\w$]*)/g;
-    let match2;
-    while ((match2 = varRegex.exec(line)) !== null) {
-      const start = match2.index;
-      const end = start + match2[0].length;
-      if (position.character >= start && position.character <= end) {
-        const varName = match2[1];
-        return findVariableReferences(varName, workspace, includeDeclaration);
-      }
-    }
-  }
-  {
-    const transRegex = /(?<!\w)%([A-Za-z_$][\w$]*)/g;
-    let match2;
-    while ((match2 = transRegex.exec(line)) !== null) {
-      const start = match2.index;
-      const end = start + match2[0].length;
-      if (position.character >= start && position.character <= end) {
-        const varName = match2[1];
-        return findTransientReferences(varName, workspace, includeDeclaration);
-      }
-    }
-  }
-  {
-    const widgetRegex = /\{\/?([A-Za-z_$][\w$]*)/g;
-    let match2;
-    while ((match2 = widgetRegex.exec(line)) !== null) {
-      const name = match2[1];
-      const nameStart = match2.index + match2[0].length - name.length;
-      const nameEnd = nameStart + name.length;
-      if (position.character >= nameStart && position.character <= nameEnd) {
-        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));
-    const wordRegex = /[A-Za-z_$][\w$\s]*/g;
-    let match2;
-    while ((match2 = wordRegex.exec(line)) !== null) {
-      const start = match2.index;
-      const end = start + match2[0].length;
-      if (position.character >= start && position.character <= end) {
-        const word = match2[0].trim();
-        if (passageNames.has(word)) {
-          return findPassageReferences(word, workspace, includeDeclaration);
-        }
-      }
-    }
-  }
-  return [];
-}
-function findPassageReferences(passageName, workspace, includeDeclaration) {
-  const locations = [];
-  if (includeDeclaration) {
-    const passage = workspace.passages.getPassage(passageName);
-    if (passage) {
-      locations.push({
-        uri: passage.uri,
-        range: passage.nameRange
-      });
-    }
-  }
-  for (const docUri of workspace.documents.getUris()) {
-    if (isMacroSource(docUri)) continue;
-    const docText = workspace.documents.getText(docUri);
-    if (!docText) continue;
-    for (const ref of [...parseLinks(docText), ...parseMacroPassageRefs(docText)]) {
-      if (ref.name === passageName) {
-        locations.push({ uri: docUri, range: ref.range });
-      }
-    }
-  }
-  return locations;
-}
-function findVariableReferences(varName, workspace, includeDeclaration) {
-  const locations = [];
-  if (includeDeclaration) {
-    const decl = workspace.variables.getDeclared().get(varName);
-    if (decl?.declarationRange && decl.declarationUri) {
-      locations.push({
-        uri: decl.declarationUri,
-        range: decl.declarationRange
-      });
-    }
-  }
-  const usages = workspace.variables.getUsages(varName);
-  for (const u of usages) {
-    locations.push({ uri: u.uri, range: u.range });
-  }
-  return locations;
-}
-function findTransientReferences(varName, workspace, includeDeclaration) {
-  const results = [];
-  if (includeDeclaration) {
-    const decl = workspace.variables.getDeclaredTransient().get(varName);
-    if (decl?.declarationUri && decl.declarationRange) {
-      results.push({ uri: decl.declarationUri, range: decl.declarationRange });
-    }
-  }
-  const usages = workspace.variables.getTransientUsages(varName);
-  for (const u of usages) {
-    results.push({ uri: u.uri, range: u.range });
-  }
-  return results;
-}
-function findWidgetReferences(widgetName, workspace, includeDeclaration) {
-  const locations = [];
-  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 lowerName = widgetName.toLowerCase();
-  const isBlock = widget?.block ?? false;
-  for (const docUri of workspace.documents.getUris()) {
-    if (isMacroSource(docUri)) continue;
-    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];
-      widgetInvocationRegex.lastIndex = 0;
-      let match2;
-      while ((match2 = widgetInvocationRegex.exec(line)) !== null) {
-        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 + match2[2].length }
-            }
-          });
-        }
-      }
-    }
-  }
-  return locations;
-}
-function toLspRange3(r) {
-  return {
-    start: { line: r.start.line, character: r.start.character },
-    end: { line: r.end.line, character: r.end.character }
-  };
-}
-var referencesPlugin;
-var init_references = __esm({
-  "src/plugins/references.ts"() {
-    "use strict";
-    init_link_parser();
-    init_macro_sources();
-    referencesPlugin = {
-      id: "references",
-      capabilities: {
-        referencesProvider: true
-      },
-      initialize(ctx) {
-        ctx.connection.onReferences((params) => {
-          const refs = findReferences(
-            params.textDocument.uri,
-            { line: params.position.line, character: params.position.character },
-            ctx.workspace,
-            params.context.includeDeclaration
-          );
-          return refs.map((r) => ({
-            uri: r.uri,
-            range: toLspRange3(r.range)
-          }));
-        });
-      }
-    };
-  }
-});
-
 // src/plugins/rename.ts
 function prepareRename(uri, position, workspace) {
   const symbol2 = resolveSymbolAtCursor(uri, position, workspace);
@@ -59705,8 +61093,11 @@ function computeRename(uri, position, newName, workspace) {
   }
   switch (symbol2.kind) {
     case "passage": {
-      const refs = findPassageReferences(symbol2.name, workspace, true);
-      for (const ref of refs) {
+      const declaration = workspace.passages.getPassage(symbol2.name);
+      if (declaration) {
+        addEdit(declaration.uri, declaration.nameRange, escapePassageName(newName));
+      }
+      for (const ref of findPassageReferences(symbol2.name, workspace, false)) {
         addEdit(ref.uri, ref.range, newName);
       }
       break;
@@ -59737,33 +61128,24 @@ function computeRename(uri, position, newName, workspace) {
   }
   return edits;
 }
+function escapePassageName(name) {
+  return name.replace(/[[\]{}\\]/g, "\\$&");
+}
 function resolveSymbolAtCursor(uri, position, workspace) {
   const text = workspace.documents.getText(uri);
   if (text === void 0) return null;
   const lines = text.split("\n");
   if (position.line >= lines.length) return null;
   const line = lines[position.line];
-  const passageHeaderRegex2 = /^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/;
-  if (line.trimStart().startsWith("::")) {
-    const headerMatch = passageHeaderRegex2.exec(line);
-    if (headerMatch) {
-      const passageName = headerMatch[1].trim();
-      const nameStart = line.indexOf(passageName);
-      const nameEnd = nameStart + passageName.length;
-      if (position.character >= nameStart && position.character <= nameEnd) {
-        return {
-          kind: "passage",
-          name: passageName,
-          range: {
-            start: { line: position.line, character: nameStart },
-            end: { line: position.line, character: nameEnd }
-          }
-        };
-      }
+  const header = parsePassageHeader(line, position.line);
+  if (header) {
+    const { start, end } = header.nameRange;
+    if (position.character >= start.character && position.character <= end.character) {
+      return { kind: "passage", name: header.name, range: header.nameRange };
     }
   }
   {
-    const varRegex = /\$([A-Za-z_$][\w$]*)/g;
+    const varRegex = /\$([\w$]+)/g;
     let match2;
     while ((match2 = varRegex.exec(line)) !== null) {
       const start = match2.index;
@@ -59782,12 +61164,13 @@ function resolveSymbolAtCursor(uri, position, workspace) {
     }
   }
   {
-    const transRegex = /(?<!\w)%([A-Za-z_$][\w$]*)/g;
+    const transRegex = /(?<!\w)%([\w$]+)/g;
     let match2;
     while ((match2 = transRegex.exec(line)) !== null) {
       const start = match2.index;
       const end = start + match2[0].length;
       if (position.character >= start && position.character <= end) {
+        if (!isTransientAt(match2[1], uri, position.line, start, workspace)) break;
         return {
           kind: "variable",
           name: match2[1],
@@ -59846,6 +61229,7 @@ var init_rename = __esm({
   "src/plugins/rename.ts"() {
     "use strict";
     init_link_parser();
+    init_passage_parser();
     init_references();
     renamePlugin = {
       id: "rename",
@@ -59898,9 +61282,9 @@ function computeCodeLenses(uri, workspace) {
   const isStoryVarsFile = storyVarsPassage && storyVarsPassage.uri === uri;
   for (let lineNum = 0; lineNum < lines.length; lineNum++) {
     const line = lines[lineNum];
-    const passageMatch = line.match(/^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/);
-    if (passageMatch) {
-      const passageName = passageMatch[1].trim();
+    const header = parsePassageHeader(line, lineNum);
+    if (header) {
+      const passageName = header.name;
       if (passageName === "StoryData") continue;
       const refs = findPassageReferences(passageName, workspace, true);
       const refCount = Math.max(0, refs.length - 1);
@@ -59931,7 +61315,7 @@ function computeCodeLenses(uri, workspace) {
       });
     }
     if (isStoryVarsFile) {
-      const varDeclMatch = line.match(/^\$([A-Za-z_$][\w$]*)\s*=/);
+      const varDeclMatch = line.match(/^\$(\w+)\s*=/);
       if (varDeclMatch) {
         const varName = varDeclMatch[1];
         const refs = findVariableReferences(varName, workspace, true);
@@ -59960,6 +61344,7 @@ var codeLensPlugin;
 var init_code_lens = __esm({
   "src/plugins/code-lens.ts"() {
     "use strict";
+    init_passage_parser();
     init_references();
     codeLensPlugin = {
       id: "code-lens",
@@ -60025,7 +61410,7 @@ function addVariableTypeHints(uri, text, range2, workspace, hints) {
   const endLine = Math.min(range2.end.line, lines.length - 1);
   for (let lineNum = startLine; lineNum <= endLine; lineNum++) {
     const line = lines[lineNum];
-    const declMatch = line.match(/^\$([A-Za-z_$][\w$]*)\s*=\s*(.+)$/);
+    const declMatch = line.match(/^\$(\w+)\s*=\s*(.+)$/);
     if (!declMatch) continue;
     const valueStr = declMatch[2].trim();
     const inferredType = inferType(valueStr);
@@ -60047,7 +61432,7 @@ function addTransientTypeHints(uri, text, range2, workspace, hints) {
   const endLine = Math.min(range2.end.line, lines.length - 1);
   for (let lineNum = startLine; lineNum <= endLine; lineNum++) {
     const line = lines[lineNum];
-    const declMatch = line.match(/^%([A-Za-z_$][\w$]*)\s*=\s*(.+)$/);
+    const declMatch = line.match(/^%(\w+)\s*=\s*(.+)$/);
     if (!declMatch) continue;
     const valueStr = declMatch[2].trim();
     const inferredType = inferType(valueStr);
@@ -60123,7 +61508,6 @@ function computeSemanticTokensAbsolute(uri, workspace) {
   for (const passage of passages) {
     const headerLine = passage.headerEnd.start.line;
     headerLines.add(headerLine);
-    const rawLine = lines[headerLine] ?? "";
     tokens.push({
       line: headerLine,
       startChar: 0,
@@ -60131,18 +61515,14 @@ function computeSemanticTokensAbsolute(uri, workspace) {
       tokenType: encodeType("namespace"),
       tokenModifiers: 0
     });
-    const nameMatch = rawLine.match(/^::\s*(\S.*?)(?:\s*\[|\s*\{|\s*$)/);
-    if (nameMatch) {
-      const name = nameMatch[1].trim();
-      const nameStart = rawLine.indexOf(name);
-      tokens.push({
-        line: headerLine,
-        startChar: nameStart,
-        length: name.length,
-        tokenType: encodeType("namespace"),
-        tokenModifiers: encodeModifiers(["declaration"])
-      });
-    }
+    const { start, end } = passage.nameRange;
+    tokens.push({
+      line: headerLine,
+      startChar: start.character,
+      length: end.character - start.character,
+      tokenType: encodeType("namespace"),
+      tokenModifiers: encodeModifiers(["declaration"])
+    });
   }
   const macros = parseMacros(text);
   for (const macro of macros) {
@@ -60161,10 +61541,10 @@ function computeSemanticTokensAbsolute(uri, workspace) {
       tokenModifiers: encodeModifiers(isDefined ? ["defaultLibrary"] : [])
     });
   }
-  const storyVarRegex = /(?<!\w)\$([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+  const storyVarRegex = /(?<!\w)\$([\w$]+(?:\.[A-Za-z_$][\w$]*)*)/g;
   const tempVarRegex = /(?<!\w)_([A-Za-z_$][\w$]*)/g;
   const localVarRegex = /(?<!\w)@([A-Za-z_$][\w$]*)/g;
-  const transientVarRegex = /(?<!\w)%([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/g;
+  const transientVarRegex = /(?<!\w)%([\w$]+(?:\.[A-Za-z_$][\w$]*)*)/g;
   const sugarKeywordRegex = /\b(to|is|isnot|eq|neq|gt|gte|lt|lte|and|or|not|def|ndef)\b/g;
   for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
     if (headerLines.has(lineIndex)) continue;
@@ -60202,6 +61582,7 @@ function computeSemanticTokensAbsolute(uri, workspace) {
     }
     transientVarRegex.lastIndex = 0;
     while ((m = transientVarRegex.exec(line)) !== null) {
+      if (!isTransientAt(m[1].split(".")[0], uri, lineIndex, m.index, workspace)) continue;
       tokens.push({
         line: lineIndex,
         startChar: m.index,
@@ -60246,6 +61627,7 @@ var init_semantic_tokens = __esm({
   "src/plugins/semantic-tokens.ts"() {
     "use strict";
     init_macro_parser();
+    init_references();
     tokenTypesLegend = [
       "function",
       "variable",
@@ -60295,7 +61677,7 @@ var init_semantic_tokens = __esm({
 });
 
 // src/plugins/code-actions.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import { basename, dirname as dirname3, join as join4 } from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
 function computeCodeActions(uri, diagnostics, workspace, options = {}) {
@@ -60327,6 +61709,11 @@ function computeCodeActions(uri, diagnostics, workspace, options = {}) {
         if (action) actions.push(action);
         break;
       }
+      case DiagnosticCode.UnevaluatedAttributeBlock: {
+        const action = fixAttributeMacro(uri, diag, workspace);
+        if (action) actions.push(action);
+        break;
+      }
     }
   }
   return actions;
@@ -60360,7 +61747,7 @@ function fixUndefinedMacro(uri, diag, workspace, options) {
   let text = workspace.documents.getText(configUri);
   if (text === void 0) {
     try {
-      text = readFileSync8(existingPath, "utf-8");
+      text = readFileSync9(existingPath, "utf-8");
     } catch {
       return null;
     }
@@ -60569,6 +61956,21 @@ function fixNullVariableValue(uri, diag) {
     }]
   };
 }
+function fixAttributeMacro(uri, diag, workspace) {
+  const text = workspace.documents.getText(uri);
+  if (text === void 0) return null;
+  const lineStarts = buildLineStarts(text);
+  const offset = (p) => (lineStarts[p.line] ?? text.length) + p.character;
+  const source = text.slice(offset(diag.range.start), offset(diag.range.end));
+  const expression = conditionalExpression(source) ?? printExpression(source);
+  if (!expression) return null;
+  return {
+    title: `Rewrite as ${expression}`,
+    kind: "quickfix",
+    diagnosticCodes: [DiagnosticCode.UnevaluatedAttributeBlock],
+    edits: [{ uri, range: diag.range, newText: expression }]
+  };
+}
 function toLspRange6(r) {
   return {
     start: { line: r.start.line, character: r.start.character },
@@ -60583,6 +61985,8 @@ var init_code_actions = __esm({
     init_diagnostic_codes();
     init_config_loader();
     init_macro_sources();
+    init_attribute_blocks();
+    init_macro_parser();
     DEFAULT_CONFIG_FILENAME = "spindle.config.yaml";
     NEW_MACRO_ENTRY = { description: "" };
     codeActionsPlugin = {
@@ -60691,7 +62095,7 @@ function computeDocumentSymbols(uri, workspace) {
       const contentStart = passage.range.start.line + 1;
       const contentEnd = passage.range.end.line + 1;
       for (let i = contentStart; i < contentEnd && i < lines.length; i++) {
-        const varMatch = lines[i].match(/^\$([A-Za-z_$][\w$]*)\s*=/);
+        const varMatch = lines[i].match(/^\$(\w+)\s*=/);
         if (varMatch) {
           const charEnd = varMatch[0].length;
           passageSymbol.children.push({
@@ -60990,7 +62394,7 @@ __export(server_exports2, {
   startServer: () => startServer
 });
 import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 import { basename as basename2 } from "node:path";
 function uriToFsPath(uri) {
   try {
@@ -61028,9 +62432,27 @@ function startServer(_args) {
     for (const warning of workspace.macros.warnings) console.error("[spindle-lsp]", warning);
     activePlugins = loadPlugins(allPlugins, config2);
     console.error("[spindle-lsp] plugins loaded:", activePlugins.map((p) => p.id).join(", "));
+    const model = workspace;
+    const pluginConnection = gateConnection(connection, () => model.isSpindleProject());
     for (const plugin of activePlugins) {
-      plugin.initialize({ connection, workspace, config: config2 });
-    }
+      plugin.initialize({ connection: pluginConnection, workspace, config: config2 });
+    }
+    const refresh = params.capabilities.workspace;
+    let spindle = workspace.isSpindleProject();
+    workspace.on("storyFormatChanged", (format) => {
+      if (format.isSpindle === spindle) return;
+      spindle = format.isSpindle;
+      console.error(format.isSpindle ? "[spindle-lsp] story format is Spindle; language features enabled" : `[spindle-lsp] story format "${format.name}" is not Spindle; language features disabled`);
+      const requests = [
+        refresh?.semanticTokens?.refreshSupport && "workspace/semanticTokens/refresh",
+        refresh?.inlayHint?.refreshSupport && "workspace/inlayHint/refresh",
+        refresh?.codeLens?.refreshSupport && "workspace/codeLens/refresh"
+      ];
+      for (const method of requests) {
+        if (method) connection.sendRequest(method).catch(() => {
+        });
+      }
+    });
     if (Object.keys(projectConfig.macros).length > 0) {
       workspace.macros.loadConfig(projectConfig.macros);
       console.error("[spindle-lsp] loaded config macros:", Object.keys(projectConfig.macros).length);
@@ -61097,7 +62519,7 @@ function startServer(_args) {
     if (workspace) {
       try {
         const fsPath = uriToFsPath(textDocument.uri);
-        const text = readFileSync9(fsPath, "utf-8");
+        const text = readFileSync10(fsPath, "utf-8");
         workspace.documents.update(textDocument.uri, text);
       } catch {
         workspace.documents.close(textDocument.uri);
@@ -61133,7 +62555,7 @@ function startServer(_args) {
       } else {
         try {
           const fsPath = uriToFsPath(change.uri);
-          const text = readFileSync9(fsPath, "utf-8");
+          const text = readFileSync10(fsPath, "utf-8");
           if (workspace.documents.has(change.uri)) {
             workspace.documents.update(change.uri, text);
           } else {
@@ -61169,7 +62591,7 @@ async function scanWorkspaceFiles(root) {
     ];
     for (const filePath of files) {
       try {
-        const text = readFileSync9(filePath, "utf-8");
+        const text = readFileSync10(filePath, "utf-8");
         const uri = fsPathToUri(filePath);
         contents.set(uri, text);
       } catch {
@@ -61189,6 +62611,7 @@ var init_server4 = __esm({
     init_workspace_model();
     init_plugin_loader();
     init_capabilities();
+    init_story_format_gate();
     init_plugins();
     init_config_loader();
     init_macro_sources();
@@ -61197,7 +62620,7 @@ var init_server4 = __esm({
 
 // src/bin.ts
 var args = process.argv.slice(2);
-var VERSION = "0.9.3";
+var VERSION = "0.11.0";
 var HELP = `spindle-lsp v${VERSION}
 Language Server Protocol server for Spindle story format