@rohal12/spindle-lsp 0.15.3 → 0.15.5

package/dist/bin.js

@@ -55,7 +55,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = false ? pkg.version : "0.15.3";
+    VERSION = false ? pkg.version : "0.15.5";
   }
 });
 
@@ -23448,6 +23448,7 @@ var init_passage_parser = __esm({
       "StoryTitle",
       "StoryBanner",
       "StoryCaption",
+      "StoryContext",
       "StoryMenu",
       "StoryInterface",
       "StoryAuthor"
@@ -31694,7 +31695,7 @@ var init_variable_tracker = __esm({
             const member = u.fullName.split(".")[1];
             if (member === void 0) continue;
             if (declared.get(u.baseName)?.type !== "array") continue;
-            if (ARRAY_MEMBERS.has(member)) continue;
+            if (ARRAY_MEMBERS.has(member) || /^(0|[1-9]\d*)$/.test(member) && Number(member) < 4294967295) continue;
             results.push({ sigil, name: u.baseName, member, range: u.range });
           }
         }
@@ -32580,11 +32581,27 @@ var init_workspace_model = __esm({
     WorkspaceModel = class extends EventEmitter2 {
       documents;
       passages;
-      macros;
-      variables;
-      widgets;
+      _macros;
+      get macros() {
+        this.ensureCurrent();
+        return this._macros;
+      }
+      _variables;
+      get variables() {
+        this.ensureCurrent();
+        return this._variables;
+      }
+      _widgets;
+      get widgets() {
+        this.ensureCurrent();
+        return this._widgets;
+      }
       /** Every document's markup, read through Spindle's tooling API. */
-      markup;
+      _markup;
+      get markup() {
+        this.ensureCurrent();
+        return this._markup;
+      }
       /** True after initialize() has completed (full workspace scan done). */
       initialized = false;
       /** The story format declared by StoryData, updated with the passages. */
@@ -32594,12 +32611,17 @@ var init_workspace_model = __esm({
        * workspace root, else StoryData's `format-version`. Only a version below
        * {@link MINIMUM_SPINDLE_VERSION} matters (it is reported, not emulated).
        */
-      target;
+      _target;
+      get target() {
+        this.ensureCurrent();
+        return this._target;
+      }
       workspaceRoot;
       /** The version installed under the workspace root, read at startup and on refresh(). */
       installedVersion;
       /** The `format-version` StoryData declares. */
       declaredVersion;
+      analysisPending = false;
       debounceTimer = null;
       DEBOUNCE_MS = 200;
       /** Bound listeners for cleanup in dispose(). */
@@ -32610,11 +32632,11 @@ var init_workspace_model = __esm({
         super();
         this.documents = new DocumentStore();
         this.passages = new PassageIndex();
-        this.macros = new MacroRegistry();
+        this._macros = new MacroRegistry();
         this.macros.onChange = () => this.markup?.invalidate();
-        this.variables = new VariableTracker();
-        this.widgets = new WidgetRegistry();
-        this.markup = new MarkupIndex({
+        this._variables = new VariableTracker();
+        this._widgets = new WidgetRegistry();
+        this._markup = new MarkupIndex({
           text: (uri) => this.documents.getText(uri),
           passages: (uri) => this.passages.getPassagesInDocument(uri),
           context: () => ({
@@ -32624,7 +32646,7 @@ var init_workspace_model = __esm({
         });
         this.workspaceRoot = config2?.workspaceRoot;
         this.installedVersion = this.workspaceRoot ? readInstalledSpindleVersion(this.workspaceRoot) : void 0;
-        this.target = resolveSpindleTarget(this.installedVersion);
+        this._target = resolveSpindleTarget(this.installedVersion);
         this.macros.loadBuiltins();
         this.macros.loadSupplements(macro_supplements_default);
         this.onDocumentChanged = (uri) => this.handleDocumentChange(uri);
@@ -32656,7 +32678,8 @@ var init_workspace_model = __esm({
        */
       refresh() {
         if (this.workspaceRoot) this.installedVersion = readInstalledSpindleVersion(this.workspaceRoot);
-        this.cascade();
+        this.analysisPending = true;
+        this.ensureCurrent();
         this.scheduleModelReady();
       }
       /**
@@ -32680,6 +32703,7 @@ var init_workspace_model = __esm({
        * undefined if no StoryData passage names one.
        */
       get storyFormat() {
+        this.ensureCurrent();
         return this.format.name;
       }
       /**
@@ -32689,6 +32713,7 @@ var init_workspace_model = __esm({
        * Spindle.
        */
       isSpindleProject() {
+        this.ensureCurrent();
         return this.format.isSpindle;
       }
       /** Clean up listeners and timers. */
@@ -32702,25 +32727,23 @@ var init_workspace_model = __esm({
         }
         this.removeAllListeners();
       }
-      /** Handle a document change: rebuild passages for that document, then cascade. */
+      /** Index local headers immediately; defer expensive cross-document analysis. */
       handleDocumentChange(uri) {
         const text3 = this.documents.getText(uri);
         if (text3 !== void 0 && !isMacroSource(uri)) {
           this.passages.rebuild(uri, text3);
         }
-        this.refreshDiscoveredMacros();
-        this.cascade();
+        this.analysisPending = true;
         this.updateStoryFormat();
         this.emit("documentChanged", uri);
         this.emit("passagesUpdated", uri);
         this.scheduleModelReady();
       }
-      /** Handle a document close: remove its passages and variable usages, then cascade. */
+      /** Remove local indices immediately and schedule cross-document analysis. */
       handleDocumentClose(uri) {
         this.passages.remove(uri);
-        this.variables.removeDocument(uri);
-        this.refreshDiscoveredMacros();
-        this.cascade();
+        this._variables.removeDocument(uri);
+        this.analysisPending = true;
         this.updateStoryFormat();
         this.emit("documentClosed", uri);
         this.emit("passagesUpdated", uri);
@@ -32734,14 +32757,21 @@ var init_workspace_model = __esm({
             this.passages.rebuild(uri, text3);
           }
         }
+        this.analysisPending = true;
+        this.ensureCurrent();
+      }
+      /** Finish pending cross-document work once, before a feature reads the indices. */
+      ensureCurrent() {
+        if (!this.analysisPending) return;
+        this.analysisPending = false;
         this.refreshDiscoveredMacros();
         this.cascade();
         this.updateStoryFormat();
       }
       /**
        * Re-read the story format from the StoryData passages after the passage
-       * index changed, emitting 'storyFormatChanged' if it differs. Called after
-       * the cascade, so listeners see up-to-date indices.
+       * index changed, emitting 'storyFormatChanged' if it differs. Listeners
+       * that read the analysis indices finish pending analysis through getters.
        */
       updateStoryFormat() {
         const format = resolveStoryFormat(storyDataFormats(
@@ -32763,7 +32793,8 @@ var init_workspace_model = __esm({
        */
       refreshDiscoveredMacros() {
         const found = [];
-        for (const uri of this.documents.getUris()) {
+        const init = [];
+        for (const uri of this.documents.getUris().sort()) {
           const text3 = this.documents.getText(uri);
           if (!text3) continue;
           if (isMacroSource(uri)) {
@@ -32777,10 +32808,11 @@ var init_workspace_model = __esm({
             if (!isStoryInit && !isScript) continue;
             lines ??= text3.split("\n");
             const content2 = lines.slice(passage.headerEnd.end.line + 1, passage.range.end.line + 1).join("\n");
-            found.push(...isScript ? discoverMacros(content2) : storyInitMacros(content2));
+            if (isScript) found.push(...discoverMacros(content2));
+            else init.push(...storyInitMacros(content2));
           }
         }
-        this.macros.setDiscoveredMacros(found);
+        this.macros.setDiscoveredMacros([...found, ...init]);
       }
       /**
        * Cascade: rescan variables and widgets based on current passages.
@@ -32794,7 +32826,7 @@ var init_workspace_model = __esm({
       cascade() {
         this.markup.invalidate();
         this.declaredVersion = storyDataFormatVersion(this.passages.getAllPassages(), (uri) => this.documents.getText(uri));
-        this.target = resolveSpindleTarget(this.installedVersion, this.declaredVersion);
+        this._target = resolveSpindleTarget(this.installedVersion, this.declaredVersion);
         const declarations = (name) => {
           const passage = this.passages.getPassage(name);
           return passage ? this.markup.get(passage.uri)?.passages.find((p) => p.passage === passage) : void 0;
@@ -32827,13 +32859,14 @@ var init_workspace_model = __esm({
         const macros = this.macros.toolingMacros();
         return [...macros, ...this.widgets.getAllWidgets().filter((widget) => !this.macros.getMacro(widget.name)).map((widget) => ({ name: widget.name, block: widget.block, subMacros: [], widget: widget.tooling }))];
       }
-      /** Debounce modelReady emission. */
+      /** Coalesce analysis and diagnostics across a burst of document changes. */
       scheduleModelReady() {
         if (this.debounceTimer) {
           clearTimeout(this.debounceTimer);
         }
         this.debounceTimer = setTimeout(() => {
           this.debounceTimer = null;
+          this.ensureCurrent();
           this.emit("modelReady");
         }, this.DEBOUNCE_MS);
       }
@@ -33043,17 +33076,10 @@ function lexFormat(formatString) {
         throw new Error(`Lex: Invalid character after '|': '${next}'`);
       }
     } else if (quoteRe.test(ch)) {
-      const openQuote = ch;
-      const start = pos;
-      pos++;
-      while (pos < formatString.length && formatString[pos] !== openQuote) {
-        if (++iter > LEX_LIMIT) throw new Error("Format lex string iteration limit exceeded");
-        pos++;
-      }
-      if (pos >= formatString.length) throw new Error("Lex: Unterminated string literal");
-      const value = formatString.slice(start + 1, pos);
-      pos++;
-      lexed.push({ kind: 1 /* Literal */, value });
+      const quoted = readQuoted(formatString, pos);
+      if (!quoted) throw new Error("Lex: Unterminated string literal");
+      pos = quoted.end;
+      lexed.push({ kind: 1 /* Literal */, value: quoted.value });
     } else if (ch === "(" || ch === ")") {
       pos++;
       lexed.push({ kind: 2 /* Group */, open: ch === "(" });
@@ -33201,114 +33227,111 @@ function isFail(s) {
   return s === 1 /* Failure */ || s === 0 /* NotFound */;
 }
 function crawlValidate(format, args2, startIndex, state) {
-  let iter = 0;
+  const memo2 = /* @__PURE__ */ new Map();
+  function append(left, right) {
+    return { ...right, rank: left.rank + right.rank, warnings: left.warnings.concat(right.warnings) };
+  }
+  function follow(left, right) {
+    return left.flatMap((matched) => isFail(matched.status) ? [matched] : crawl(right, matched.argIndex).map((result2) => append(matched, result2)));
+  }
   function crawl(fmt, argIdx) {
-    if (++iter > VALIDATE_LIMIT) {
+    let positions = memo2.get(fmt);
+    if (!positions) memo2.set(fmt, positions = /* @__PURE__ */ new Map());
+    const cached2 = positions.get(argIdx);
+    if (cached2) return cached2;
+    if (positions.size >= VALIDATE_LIMIT) {
       throw new Error(`Validation iteration limit exceeded at argument ${argIdx}`);
     }
+    const unique = /* @__PURE__ */ new Map();
+    for (const result2 of match2(fmt, argIdx)) {
+      const key = isFail(result2.status) ? "failure" : result2.argIndex;
+      const previous2 = unique.get(key);
+      if (!previous2 || key === "failure" && result2.rank > previous2.rank) unique.set(key, result2);
+    }
+    const results2 = [...unique.values()];
+    positions.set(argIdx, results2);
+    return results2;
+  }
+  function match2(fmt, argIdx) {
     switch (fmt.kind) {
       case 4 /* MaybeNext */: {
-        let rank = 0;
-        let warnings = [];
-        let idx = argIdx;
-        if (fmt.left) {
-          const left = crawl(fmt.left, idx);
-          if (isFail(left.status)) return left;
-          rank += left.rank;
-          idx = left.argIndex;
-          warnings = left.warnings;
-        }
-        const right = crawl(fmt.right, idx);
-        if (right.status === 0 /* NotFound */) {
-          return makeSuccess(idx, rank, warnings);
-        }
-        if (isFail(right.status)) {
-          right.status = 1 /* Failure */;
-          return right;
-        }
-        return makeSuccess(right.argIndex, rank + right.rank, warnings.concat(right.warnings));
+        const left = fmt.left ? crawl(fmt.left, argIdx) : [makeSuccess(argIdx, 0)];
+        return [...follow(left, fmt.right), ...left];
       }
       case 3 /* AndNext */: {
-        const left = crawl(fmt.left, argIdx);
-        if (isFail(left.status)) return left;
-        const right = crawl(fmt.right, left.argIndex);
-        if (isFail(right.status)) return right;
-        return makeSuccess(
-          right.argIndex,
-          left.rank + right.rank,
-          left.warnings.concat(right.warnings)
-        );
+        return follow(crawl(fmt.left, argIdx), fmt.right);
       }
       case 5 /* Or */: {
-        const left = crawl(fmt.left, argIdx);
-        if (!isFail(left.status)) return left;
-        const right = crawl(fmt.right, argIdx);
-        if (!isFail(right.status)) return right;
-        return left;
+        return [...crawl(fmt.left, argIdx), ...crawl(fmt.right, argIdx)];
       }
       case 6 /* Repeat */: {
-        let rank = 0;
-        let warnings = [];
-        let idx = argIdx;
-        for (; ; ) {
-          const r = crawl(fmt.right, idx);
-          if (isFail(r.status)) break;
-          idx = r.argIndex;
-          rank += r.rank;
-          warnings = warnings.concat(r.warnings);
-        }
-        return makeSuccess(idx, rank, warnings);
+        const matches = [];
+        const pending = [makeSuccess(argIdx, 0)];
+        const reached = /* @__PURE__ */ new Set();
+        while (pending.length > 0) {
+          const matched = pending.pop();
+          if (reached.has(matched.argIndex)) continue;
+          reached.add(matched.argIndex);
+          matches.push(matched);
+          const items = crawl(fmt.right, matched.argIndex);
+          for (let i2 = items.length - 1; i2 >= 0; i2--) {
+            const item = items[i2];
+            if (!isFail(item.status) && !reached.has(item.argIndex)) pending.push(append(matched, item));
+          }
+        }
+        return matches.sort((left, right) => right.argIndex - left.argIndex);
       }
       case 1 /* Literal */: {
         const arg = args2[argIdx];
         if (arg === void 0) {
-          return makeError(0 /* NotFound */, `Expected literal '${fmt.value}' but no argument found`, argIdx);
+          return [makeError(0 /* NotFound */, `Expected literal '${fmt.value}' but no argument found`, argIdx)];
         }
         if (isAlwaysArg(arg)) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
-        const argText = arg.type === 0 /* String */ ? arg.text.slice(1, -1) : arg.text;
+        const argText = arg.type === 0 /* String */ ? readQuoted(arg.text, 0)?.value : arg.text;
         if (argText === fmt.value) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
         if (fmt.value === "null" && arg.type === 3 /* Null */ || fmt.value === "undefined" && arg.type === 10 /* Undefined */ || fmt.value === "true" && arg.type === 2 /* Boolean */ && arg.text === "true" || fmt.value === "false" && arg.type === 2 /* Boolean */ && arg.text === "false" || fmt.value === "NaN" && arg.type === 9 /* NaN */) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
-        return makeError(1 /* Failure */, `Expected literal '${fmt.value}'`, argIdx, CORRECT_TYPE_RANK);
+        return [makeError(1 /* Failure */, `Expected literal '${fmt.value}'`, argIdx, CORRECT_TYPE_RANK)];
       }
       case 0 /* Type */: {
         const arg = args2[argIdx];
         const typeDef = fmt.type;
         if (arg === void 0) {
-          return makeError(
+          return [makeError(
             0 /* NotFound */,
             `Expected type '${typeDef.name[0]}' but no argument found`,
             argIdx
-          );
+          )];
         }
         if (isAlwaysArg(arg)) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
         const result2 = typeDef.validate(arg, args2, argIdx, state);
         if (result2 instanceof TypeError2) {
-          return {
+          return [{
             status: 1 /* Failure */,
             rank: 0,
             argIndex: argIdx,
             errors: [{ message: result2.message, argIndex: argIdx }],
             warnings: []
-          };
+          }];
         }
         if (result2 instanceof TypeWarning) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK, [
+          return [makeSuccess(argIdx + 1, CORRECT_RANK, [
             { message: result2.message, argIndex: argIdx }
-          ]);
+          ])];
         }
-        return makeSuccess(argIdx + 1, CORRECT_RANK);
+        return [makeSuccess(argIdx + 1, CORRECT_RANK)];
       }
     }
   }
-  return crawl(format, startIndex);
+  const results = crawl(format, startIndex);
+  return results.find((result2) => !isFail(result2.status) && result2.argIndex === args2.length) ?? results.reduce((best, result2) => result2.rank > best.rank ? result2 : best);
 }
 var TypeError2, TypeWarning, parameterTypes, LEX_LIMIT, wsRe, identStartRe, identStopRe, quoteRe, digitRe, PARSE_LIMIT, DESCRIBE_ALTERNATIVE_LIMIT, VALIDATE_LIMIT, CORRECT_TYPE_RANK, CORRECT_RANK, Parameters;
 var init_parameter_validator = __esm({
@@ -33820,7 +33843,7 @@ function computeDiagnostics(uri, workspace, options) {
 }
 function storyReport(workspace) {
   const documents = [];
-  for (const uri of workspace.documents.getUris()) {
+  for (const uri of workspace.passages.getDocumentUris()) {
     if (isMacroSource(uri)) continue;
     const doc = workspace.markup.get(uri);
     if (doc) documents.push(doc);
@@ -34426,8 +34449,6 @@ var init_diagnostics = __esm({
           }
         };
         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: [] });
         });
@@ -80071,6 +80092,7 @@ function computeRename(uri, position, newName, workspace) {
         addEdit(declaration.uri, declaration.nameRange, escapePassageName(newName));
       }
       for (const { uri: refUri, ref: ref2, text: text3 } of refEdits) addEdit(refUri, ref2.range, text3);
+      preserveEntryPassage(symbol2.name, newName, workspace, addEdit);
       break;
     }
     case "variable": {
@@ -80143,6 +80165,54 @@ function computeRename(uri, position, newName, workspace) {
   }
   return edits;
 }
+function preserveEntryPassage(oldName, newName, workspace, addEdit) {
+  const storyData = workspace.passages.getPassages("StoryData");
+  for (const declaration of storyData) {
+    const passage = workspace.markup.get(declaration.uri).passages.find((p) => p.passage === declaration);
+    let data2;
+    try {
+      data2 = JSON.parse(passage.content);
+      if (!data2 || typeof data2 !== "object" || Array.isArray(data2)) throw new Error();
+    } catch {
+      throw new RenameError("Cannot preserve the entry passage: StoryData must contain a valid JSON object.").at(declaration.uri, declaration.nameRange);
+    }
+    const start = typeof data2.start === "string" && data2.start ? data2.start : "Start";
+    if (start !== oldName) continue;
+    if (Object.hasOwn(data2, "start") && typeof data2.start !== "string") {
+      throw new RenameError("Cannot preserve the entry passage: StoryData.start must be a string.").at(declaration.uri, declaration.nameRange);
+    }
+    let depth = 0;
+    let startValue = false;
+    let replaced = false;
+    lexJs(passage.content, {
+      code(ch) {
+        if (ch === "{" || ch === "[") depth++;
+        if (ch === "}" || ch === "]") depth--;
+        if (ch === ",") startValue = false;
+      },
+      literal(text3, index) {
+        if (depth !== 1 || !text3.startsWith('"')) return;
+        const isKey = /^\s*:/.test(passage.content.slice(index + text3.length));
+        if (isKey) startValue = JSON.parse(text3) === "start";
+        else if (startValue) {
+          addEdit(declaration.uri, passage.range(index, index + text3.length), JSON.stringify(newName));
+          replaced = true;
+        }
+      }
+    });
+    if (!replaced) {
+      const index = passage.content.indexOf("{") + 1;
+      addEdit(declaration.uri, passage.range(index, index), `"start":${JSON.stringify(newName)}${Object.keys(data2).length ? "," : ""}`);
+    }
+  }
+  if (storyData.length === 0 && oldName === "Start") {
+    const declaration = workspace.passages.getPassage(oldName);
+    const doc = workspace.markup.get(declaration.uri);
+    const end = doc.passages.at(-1).position(doc.passages.at(-1).content.length);
+    const eol = doc.text.includes("\r\n") ? "\r\n" : "\n";
+    addEdit(declaration.uri, { start: end, end }, `${eol}${eol}:: StoryData${eol}${JSON.stringify({ start: newName })}${eol}`);
+  }
+}
 function passageHeaderProblem(name) {
   if (name.trim() === "") return "a passage name cannot be empty";
   if (/[\r\n]/.test(name)) return "a passage header is a single line, so the name cannot contain a line break";
@@ -81366,7 +81436,7 @@ function startServer(args2) {
   connection.onInitialize((params) => {
     console.error("[spindle-lsp] onInitialize called");
     const initOptions = params.initializationOptions ?? {};
-    workspaceRoot = initOptions.workspaceRoot ?? (params.workspaceFolders?.[0]?.uri ? uriToFsPath(params.workspaceFolders[0].uri) : void 0) ?? (params.rootUri ? uriToFsPath(params.rootUri) : void 0);
+    workspaceRoot = (initOptions.workspaceRoot !== void 0 ? uriToFsPath(initOptions.workspaceRoot) : void 0) ?? (params.workspaceFolders?.[0]?.uri ? uriToFsPath(params.workspaceFolders[0].uri) : void 0) ?? (params.rootUri ? uriToFsPath(params.rootUri) : void 0);
     let projectConfig = { macros: {} };
     try {
       if (workspaceRoot) projectConfig = loadConfigFromDisk(workspaceRoot);