@bendyline/docblocks 2.6.1 → 2.7.0

package/dist/workspace-index/index.js

@@ -0,0 +1,1287 @@
+import {
+  catalogEntryFromDocument,
+  chooseOutsideInMarkdownPath,
+  normalizeLineEndings,
+  resolveOutsideInLayout
+} from "../chunk-R2JX5N3F.js";
+import {
+  isCompanionDirectoryName,
+  isDiscoverableWorkspaceEntry,
+  isMarkdownFileName
+} from "../chunk-YHSFRPBS.js";
+import {
+  decodeUtf8Text
+} from "../chunk-M5ZNQGR5.js";
+import {
+  FsError,
+  WORKSPACE_ROOT,
+  parseWorkspacePath,
+  tryParseWorkspacePath,
+  workspacePathContains
+} from "../chunk-AYWKIZLD.js";
+
+// src/workspace-index/search-text.ts
+var LineBuilder = class {
+  constructor() {
+    this.lines = [];
+    this.sourceLines = [];
+    this.kinds = [];
+    this.current = null;
+    this.currentLine = 0;
+    this.kind = "text";
+  }
+  /** Start a new block: whatever follows begins on a fresh line. */
+  block(kind) {
+    this.flush();
+    this.kind = kind;
+  }
+  /** Append text that starts on `line`, opening a new line when it advances. */
+  append(line, text) {
+    if (this.current === null || line > this.currentLine) {
+      this.flush();
+      this.current = "";
+      this.currentLine = line;
+    }
+    this.current += text;
+  }
+  /** Text whose embedded newlines are source line breaks (soft breaks, code). */
+  appendLines(firstLine, value) {
+    const parts = value.split("\n");
+    for (let index = 0; index < parts.length; index += 1) {
+      this.append(firstLine + index, parts[index]);
+    }
+  }
+  flush() {
+    if (this.current !== null && this.current.trim() !== "") {
+      this.lines.push(this.current.normalize("NFC"));
+      this.sourceLines.push(this.currentLine);
+      this.kinds.push(this.kind);
+    }
+    this.current = null;
+  }
+  build() {
+    this.flush();
+    let characters = 0;
+    for (const line of this.lines) characters += line.length;
+    return {
+      lines: this.lines,
+      sourceLines: this.sourceLines,
+      kinds: this.kinds,
+      characters
+    };
+  }
+};
+var UNSEARCHABLE_INLINE = /* @__PURE__ */ new Set([
+  "image",
+  "imageReference",
+  "inlineIcon",
+  "htmlInline",
+  "mention",
+  "footnoteReference"
+]);
+function startLine(node) {
+  return node.position?.start.line;
+}
+function emitInline(nodes, out, fallback) {
+  for (const node of nodes) {
+    if (UNSEARCHABLE_INLINE.has(node.type)) continue;
+    const line = startLine(node) ?? fallback;
+    if ("children" in node && Array.isArray(node.children)) {
+      emitInline(node.children, out, line);
+    } else if ("value" in node && typeof node.value === "string") {
+      out.appendLines(line, node.value);
+    }
+  }
+}
+function emitTableRow(row, out, fallback) {
+  const line = startLine(row) ?? fallback;
+  row.children.forEach((cell, index) => {
+    if (index > 0) out.append(line, " | ");
+    emitInline(cell.children, out, startLine(cell) ?? line);
+  });
+}
+function contentStartLine(line, sourceLines, fences) {
+  return fences.test(sourceLines[line - 1] ?? "") ? line + 1 : line;
+}
+var CODE_FENCE = /^\s{0,3}(?:```|~~~)/u;
+var MATH_FENCE = /^\s*\$\$/u;
+function emitBlocks(blocks, out, sourceLines, fallback) {
+  for (const block of blocks) {
+    const line = startLine(block) ?? fallback;
+    switch (block.type) {
+      case "heading":
+        out.block("heading");
+        emitInline(block.children, out, line);
+        break;
+      case "paragraph":
+        out.block("text");
+        emitInline(block.children, out, line);
+        break;
+      case "leafDirective":
+        out.block("text");
+        emitInline(block.children, out, line);
+        break;
+      case "code":
+        out.block("code");
+        out.appendLines(contentStartLine(line, sourceLines, CODE_FENCE), block.value);
+        break;
+      case "math":
+        out.block("code");
+        out.appendLines(contentStartLine(line, sourceLines, MATH_FENCE), block.value);
+        break;
+      case "table":
+        for (const row of block.children) {
+          out.block("text");
+          emitTableRow(row, out, line);
+        }
+        break;
+      case "htmlBlock":
+        out.block("text");
+        out.appendLines(line, block.rawHtml.replace(/<[^>]*>/gu, " "));
+        break;
+      case "definitionList":
+        for (const item of block.children) {
+          if (item.type === "definitionTerm") {
+            out.block("text");
+            emitInline(item.children, out, startLine(item) ?? line);
+          } else {
+            emitBlocks(item.children, out, sourceLines, startLine(item) ?? line);
+          }
+        }
+        break;
+      case "blockquote":
+      case "list":
+      case "listItem":
+      case "footnoteDefinition":
+      case "containerDirective":
+        emitBlocks(block.children, out, sourceLines, line);
+        break;
+      case "thematicBreak":
+      case "definition":
+        break;
+    }
+  }
+}
+function emitFrontmatter(sourceLines, out) {
+  if (sourceLines[0]?.trim() !== "---") return;
+  for (let index = 1; index < sourceLines.length; index += 1) {
+    const text = sourceLines[index];
+    if (text.trim() === "---" || text.trim() === "...") return;
+    out.block("frontmatter");
+    out.append(index + 1, text);
+  }
+}
+function extractSearchText(document, source) {
+  const sourceLines = source.split("\n");
+  const out = new LineBuilder();
+  emitFrontmatter(sourceLines, out);
+  emitBlocks(document.children, out, sourceLines, 1);
+  return out.build();
+}
+function lineSearchText(source) {
+  const out = new LineBuilder();
+  source.split("\n").forEach((text, index) => {
+    out.block("text");
+    out.append(index + 1, text);
+  });
+  return out.build();
+}
+
+// src/workspace-index/analyze.ts
+var markdownModule = null;
+function loadMarkdown() {
+  markdownModule ?? (markdownModule = import("@bendyline/squisq/markdown"));
+  return markdownModule;
+}
+function stemOf(path) {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function nameOnlyDocument(identity, issue) {
+  return {
+    record: {
+      path: identity.path,
+      sourcePath: identity.sourcePath,
+      format: identity.format,
+      lastModified: identity.lastModified,
+      title: stemOf(identity.path),
+      outline: [],
+      wordCount: 0,
+      content: "name-only",
+      issue
+    },
+    text: null
+  };
+}
+var ATX_HEADING = /^\s{0,3}#{1,6}\s+(.+?)\s*#*\s*$/u;
+function linesDocument(identity, source, issue) {
+  const text = lineSearchText(source);
+  const heading = text.lines.map((line) => ATX_HEADING.exec(line)?.[1]).find(Boolean);
+  return {
+    record: {
+      path: identity.path,
+      sourcePath: identity.sourcePath,
+      format: identity.format,
+      lastModified: identity.lastModified,
+      title: heading ?? stemOf(identity.path),
+      outline: [],
+      wordCount: 0,
+      content: "lines",
+      issue
+    },
+    text
+  };
+}
+async function analyzeDocumentBytes(identity, data, options) {
+  let decoded;
+  try {
+    decoded = decodeUtf8Text(data, { path: identity.sourcePath ?? identity.path });
+  } catch (error) {
+    if (error instanceof FsError) return nameOnlyDocument(identity, "not-utf8");
+    throw error;
+  }
+  const source = normalizeLineEndings(decoded);
+  if (data.byteLength > options.maxParseBytes) {
+    return linesDocument(identity, source, "parse-limit");
+  }
+  const { MarkdownLimitError, parseMarkdown } = await loadMarkdown();
+  let document;
+  try {
+    document = parseMarkdown(source, {
+      limits: { maxSourceBytes: options.maxParseBytes },
+      signal: options.signal
+    });
+  } catch (error) {
+    if (error instanceof MarkdownLimitError) return linesDocument(identity, source, "parse-limit");
+    throw error;
+  }
+  const entry = await catalogEntryFromDocument(
+    {
+      path: identity.path,
+      ...identity.sourcePath && identity.sourcePath !== identity.path ? { source: identity.sourcePath } : {},
+      format: identity.format
+    },
+    document
+  );
+  return {
+    record: {
+      path: identity.path,
+      sourcePath: identity.sourcePath,
+      format: identity.format,
+      lastModified: identity.lastModified,
+      title: entry.title,
+      outline: entry.outline,
+      wordCount: entry.wordCount,
+      ...entry.excerpt ? { excerpt: entry.excerpt } : {},
+      ...entry.description ? { description: entry.description } : {},
+      ...entry.tags ? { tags: entry.tags } : {},
+      content: "full"
+    },
+    text: extractSearchText(document, source)
+  };
+}
+
+// src/workspace-index/types.ts
+var WORKSPACE_INDEX_LIMITS = Object.freeze({
+  maxEntries: 5e4,
+  maxDirectories: 1e4,
+  maxDepth: 32,
+  maxDocuments: 1e4,
+  maxDocumentBytes: 4 * 1024 * 1024,
+  maxParseBytes: 1024 * 1024,
+  maxTextCharacters: 24e6
+});
+var WORKSPACE_SEARCH_LIMITS = Object.freeze({
+  maxQueryCharacters: 256,
+  maxDocuments: 200,
+  maxLinesPerDocument: 50,
+  maxMatchesPerDocument: 1e3,
+  maxTotalMatches: 1e5
+});
+
+// src/workspace-index/search.ts
+function createCheckpoint(yieldControl, now, signal, sliceMs = 8) {
+  let sliceStart = now();
+  return async () => {
+    signal?.throwIfAborted();
+    if (now() - sliceStart < sliceMs) return;
+    await yieldControl();
+    signal?.throwIfAborted();
+    sliceStart = now();
+  };
+}
+var REGEX_SYNTAX = /[\\^$.*+?()[\]{}|/]/gu;
+var WORD_CHARACTER = /^[\p{L}\p{N}\p{M}_]$/u;
+function buildLiteralMatcher(query, maxQueryCharacters = WORKSPACE_SEARCH_LIMITS.maxQueryCharacters) {
+  const text = query.text.normalize("NFC");
+  if (!text.trim() || text.length > maxQueryCharacters) return null;
+  let source = text.replace(REGEX_SYNTAX, "\\$&");
+  if (query.wholeWord) {
+    const characters = [...text];
+    if (WORD_CHARACTER.test(characters[0])) source = `(?<![\\p{L}\\p{N}\\p{M}_])${source}`;
+    if (WORD_CHARACTER.test(characters[characters.length - 1])) {
+      source = `${source}(?![\\p{L}\\p{N}\\p{M}_])`;
+    }
+  }
+  return new RegExp(source, query.matchCase ? "gu" : "giu");
+}
+function rangesIn(matcher, text) {
+  const ranges = [];
+  for (const match of text.matchAll(matcher)) {
+    ranges.push([match.index, match.index + match[0].length]);
+  }
+  return ranges;
+}
+function countIn(matcher, text, cap) {
+  let count = 0;
+  for (const _match of text.matchAll(matcher)) {
+    count += 1;
+    if (count >= cap) break;
+  }
+  return count;
+}
+var SNIPPET_CHARACTERS = 200;
+var SNIPPET_LEAD = 60;
+function buildSnippet(line, ranges) {
+  if (line.length <= SNIPPET_CHARACTERS) {
+    const indent = line.length - line.trimStart().length;
+    return {
+      snippet: line.slice(indent),
+      ranges: ranges.map(([start2, end2]) => [start2 - indent, end2 - indent])
+    };
+  }
+  const first = ranges[0]?.[0] ?? 0;
+  const start = Math.max(0, Math.min(first - SNIPPET_LEAD, line.length - SNIPPET_CHARACTERS));
+  const end = Math.min(line.length, start + SNIPPET_CHARACTERS);
+  const prefix = start > 0 ? "\u2026" : "";
+  const suffix = end < line.length ? "\u2026" : "";
+  const shift = prefix.length - start;
+  const clipped = [];
+  for (const [rangeStart, rangeEnd] of ranges) {
+    if (rangeEnd <= start || rangeStart >= end) continue;
+    clipped.push([Math.max(rangeStart, start) + shift, Math.min(rangeEnd, end) + shift]);
+  }
+  return { snippet: `${prefix}${line.slice(start, end)}${suffix}`, ranges: clipped };
+}
+function stemOf2(path) {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+async function searchDocuments(documents, query, checkpoint, limitOverrides = {}) {
+  const limits = { ...WORKSPACE_SEARCH_LIMITS, ...limitOverrides };
+  const matcher = buildLiteralMatcher(query, limits.maxQueryCharacters);
+  let pendingDocuments = 0;
+  let skippedDocuments = 0;
+  for (const document of documents) {
+    if (document.pending) pendingDocuments += 1;
+    else if (!document.text) skippedDocuments += 1;
+  }
+  if (!matcher) {
+    return {
+      documents: [],
+      totalDocuments: 0,
+      totalMatches: 0,
+      truncated: false,
+      pendingDocuments,
+      skippedDocuments
+    };
+  }
+  const tallies = [];
+  let totalMatches = 0;
+  let truncated = false;
+  for (const document of documents) {
+    await checkpoint();
+    const titleRanges = rangesIn(matcher, document.record.title.normalize("NFC"));
+    const titleMatch = titleRanges.length > 0 || countIn(matcher, stemOf2(document.record.path).normalize("NFC"), 1) > 0;
+    let matchCount = 0;
+    if (document.text && !truncated) {
+      for (const line of document.text.lines) {
+        const room = Math.min(
+          limits.maxMatchesPerDocument - matchCount,
+          limits.maxTotalMatches - totalMatches - matchCount
+        );
+        if (room <= 0) break;
+        matchCount += countIn(matcher, line, room);
+      }
+      if (matchCount >= limits.maxMatchesPerDocument) truncated = true;
+      totalMatches += matchCount;
+      if (totalMatches >= limits.maxTotalMatches) truncated = true;
+    }
+    if (titleMatch || matchCount > 0) {
+      tallies.push({ document, titleMatch, titleRanges, matchCount });
+    }
+  }
+  tallies.sort(
+    (left, right) => Number(right.titleMatch) - Number(left.titleMatch) || right.matchCount - left.matchCount || compareCodeUnits(right.document.record.lastModified, left.document.record.lastModified) || compareCodeUnits(left.document.record.path, right.document.record.path)
+  );
+  if (tallies.length > limits.maxDocuments) truncated = true;
+  const results = [];
+  for (const tally of tallies.slice(0, limits.maxDocuments)) {
+    await checkpoint();
+    const { document } = tally;
+    const matches = [];
+    let occurrence = 0;
+    let moreMatches = false;
+    const text = document.text;
+    if (text && tally.matchCount > 0) {
+      for (let index = 0; index < text.lines.length; index += 1) {
+        const line = text.lines[index];
+        const ranges = rangesIn(matcher, line);
+        if (ranges.length === 0) continue;
+        if (matches.length >= limits.maxLinesPerDocument) {
+          moreMatches = true;
+          break;
+        }
+        const snippet = buildSnippet(line, ranges);
+        matches.push({
+          line: text.sourceLines[index],
+          kind: text.kinds[index],
+          snippet: snippet.snippet,
+          ranges: snippet.ranges,
+          occurrence
+        });
+        occurrence += ranges.length;
+      }
+    }
+    results.push({
+      path: document.record.path,
+      title: document.record.title,
+      format: document.record.format,
+      titleMatch: tally.titleMatch,
+      titleRanges: tally.titleRanges,
+      matchCount: tally.matchCount,
+      matches,
+      moreMatches,
+      lastModified: document.record.lastModified,
+      pending: document.pending
+    });
+  }
+  return {
+    documents: results,
+    totalDocuments: tallies.length,
+    totalMatches,
+    truncated,
+    pendingDocuments,
+    skippedDocuments
+  };
+}
+
+// src/workspace-index/workspace-index.ts
+function emptyTree() {
+  return { files: /* @__PURE__ */ new Map(), documents: /* @__PURE__ */ new Map(), directories: /* @__PURE__ */ new Set(), unreadable: /* @__PURE__ */ new Set() };
+}
+var IndexStopped = class extends Error {
+};
+var RootListingError = class extends Error {
+};
+function fsCode(error) {
+  return error instanceof FsError ? error.code : null;
+}
+function isVanished(error) {
+  const code = fsCode(error);
+  return code === "not-found" || code === "type-mismatch";
+}
+function classify(entry) {
+  if (isMarkdownFileName(entry.name)) return "markdown";
+  return resolveOutsideInLayout(entry.path) ? "outside-in" : "other";
+}
+function compareCodeUnits2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function defaultYield() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function defaultNow() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+var PUBLISH_INTERVAL_MS = 250;
+var SLICE_MS = 8;
+var WorkspaceIndexImpl = class {
+  constructor(options) {
+    this.abort = new AbortController();
+    this.tree = emptyTree();
+    this.truncation = null;
+    this.analysisTruncation = null;
+    this.rootError = null;
+    this.listedOnce = false;
+    this.analyzedCount = 0;
+    this.textCharacters = 0;
+    this.readIssues = 0;
+    this.started = false;
+    this.disposed = false;
+    this.paused = false;
+    this.pumping = false;
+    this.walkRequested = false;
+    this.lastWalkEnd = null;
+    this.pendingChanges = /* @__PURE__ */ new Set();
+    this.changesReady = false;
+    this.changeTimer = null;
+    this.priority = [];
+    this.queue = [];
+    this.queueIndex = 0;
+    this.queueDirty = true;
+    this.sliceStart = 0;
+    this.subscription = null;
+    this.watching = false;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.listedWaiters = /* @__PURE__ */ new Set();
+    this.generation = 0;
+    this.lastPublish = 0;
+    this.filesCache = null;
+    this.documentsCache = null;
+    this.statusCache = null;
+    this.workspaceId = options.workspaceId;
+    this.source = options.source;
+    this.limits = { ...WORKSPACE_INDEX_LIMITS, ...options.limits };
+    this.yieldControl = options.yieldControl ?? defaultYield;
+    this.now = options.now ?? defaultNow;
+    this.minRefreshIntervalMs = options.minRefreshIntervalMs ?? 15e3;
+    this.changeCoalesceMs = options.changeCoalesceMs ?? 50;
+  }
+  // ── Public API ────────────────────────────────────────────────────────
+  getStatus() {
+    if (this.statusCache) return this.statusCache;
+    let pendingCount = 0;
+    for (const state of this.tree.documents.values()) {
+      if (state.analysis === null) pendingCount += 1;
+    }
+    const phase = this.disposed ? "disposed" : !this.started ? "idle" : this.rootError !== null ? "error" : !this.listedOnce ? "listing" : pendingCount > 0 ? "analyzing" : "ready";
+    this.statusCache = Object.freeze({
+      phase,
+      fileCount: this.tree.files.size,
+      documentCount: this.tree.documents.size,
+      analyzedCount: this.analyzedCount,
+      pendingCount,
+      watching: this.watching,
+      listed: this.listedOnce,
+      truncated: this.truncation ?? this.analysisTruncation,
+      issues: this.tree.unreadable.size + this.readIssues,
+      error: this.rootError,
+      generation: this.generation
+    });
+    return this.statusCache;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  start() {
+    if (this.started || this.disposed) return;
+    this.started = true;
+    this.startWatching();
+    this.requestWalk(true);
+  }
+  getFiles() {
+    if (!this.filesCache) {
+      this.filesCache = Object.freeze(
+        [...this.tree.files.values()].map(({ version: _version, ...file }) => Object.freeze(file)).sort((left, right) => compareCodeUnits2(left.path, right.path))
+      );
+    }
+    return this.filesCache;
+  }
+  getDocuments() {
+    if (!this.documentsCache) {
+      this.documentsCache = Object.freeze(
+        [...this.tree.documents.values()].map((state) => this.recordOf(state)).sort((left, right) => compareCodeUnits2(left.path, right.path))
+      );
+    }
+    return this.documentsCache;
+  }
+  getDocument(path) {
+    const canonical = tryParseWorkspacePath(path);
+    const state = canonical === null ? void 0 : this.tree.documents.get(canonical);
+    return state ? this.recordOf(state) : null;
+  }
+  has(path) {
+    const canonical = tryParseWorkspacePath(path);
+    if (canonical === null) return "unknown";
+    if (this.tree.files.has(canonical) || this.tree.directories.has(canonical)) return "present";
+    if (!this.listedOnce || this.truncation !== null || this.rootError !== null) return "unknown";
+    const segments = canonical.split("/");
+    for (let index = 0; index < segments.length; index += 1) {
+      const kind = index < segments.length - 1 ? "directory" : "file";
+      if (!isDiscoverableWorkspaceEntry(segments[index], kind)) return "unknown";
+    }
+    for (const directory of this.tree.unreadable) {
+      if (workspacePathContains(directory, canonical)) return "unknown";
+    }
+    return "absent";
+  }
+  whenListed(options = {}) {
+    if (this.listedOnce) return Promise.resolve(true);
+    if (this.disposed) return Promise.resolve(false);
+    const { signal, timeoutMs } = options;
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+      let timer = null;
+      const cleanup = () => {
+        this.listedWaiters.delete(waiter);
+        if (timer !== null) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const waiter = (listed) => {
+        cleanup();
+        resolve(listed);
+      };
+      const onAbort = () => {
+        cleanup();
+        reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+      };
+      this.listedWaiters.add(waiter);
+      if (timeoutMs !== void 0) timer = setTimeout(() => waiter(false), timeoutMs);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  search(query, options = {}) {
+    const documents = [...this.tree.documents.values()].map((state) => ({
+      record: this.recordOf(state),
+      text: state.analysis?.text ?? null,
+      pending: state.analysis === null
+    }));
+    documents.sort((left, right) => compareCodeUnits2(left.record.path, right.record.path));
+    return searchDocuments(
+      documents,
+      query,
+      createCheckpoint(this.yieldControl, this.now, options.signal, SLICE_MS),
+      options.limits
+    );
+  }
+  refresh(options = {}) {
+    if (!options.force && this.watching) return;
+    this.requestWalk(options.force ?? false);
+  }
+  invalidate(path) {
+    const canonical = tryParseWorkspacePath(path);
+    if (canonical === null || !this.started || this.disposed) return;
+    this.enqueueChange(canonical);
+  }
+  prioritize(paths) {
+    const canonical = paths.map((path) => tryParseWorkspacePath(path)).filter((path) => path !== null);
+    if (canonical.length === 0) return;
+    this.priority = [...canonical, ...this.priority.filter((path) => !canonical.includes(path))];
+    void this.pump();
+  }
+  setPaused(paused) {
+    if (this.paused === paused) return;
+    this.paused = paused;
+    if (!paused) void this.pump();
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.abort.abort();
+    if (this.changeTimer !== null) clearTimeout(this.changeTimer);
+    this.changeTimer = null;
+    const subscription = this.subscription;
+    this.subscription = null;
+    this.watching = false;
+    if (subscription) void subscription.dispose().catch(() => void 0);
+    for (const waiter of [...this.listedWaiters]) waiter(false);
+    this.publish();
+    this.listeners.clear();
+  }
+  // ── Scheduling ────────────────────────────────────────────────────────
+  requestWalk(force) {
+    if (!this.started || this.disposed) return;
+    if (!force && this.lastWalkEnd !== null && this.now() - this.lastWalkEnd < this.minRefreshIntervalMs) {
+      return;
+    }
+    this.walkRequested = true;
+    void this.pump();
+  }
+  enqueueChange(path) {
+    this.pendingChanges.add(path);
+    if (this.changeTimer !== null) return;
+    this.changeTimer = setTimeout(() => {
+      this.changeTimer = null;
+      this.changesReady = true;
+      void this.pump();
+    }, this.changeCoalesceMs);
+  }
+  async pump() {
+    if (this.pumping || this.disposed || !this.started) return;
+    this.pumping = true;
+    this.sliceStart = this.now();
+    try {
+      while (!this.disposed && !this.paused) {
+        if (this.walkRequested) {
+          this.walkRequested = false;
+          await this.fullWalk();
+          continue;
+        }
+        if (this.changesReady && this.pendingChanges.size > 0) {
+          this.changesReady = false;
+          const paths = [...this.pendingChanges];
+          this.pendingChanges.clear();
+          await this.applyChanges(paths);
+          continue;
+        }
+        const next = this.nextPendingDocument();
+        if (!next) break;
+        await this.analyze(next);
+        this.maybePublish();
+      }
+    } catch (error) {
+      if (!(error instanceof IndexStopped)) {
+        this.rootError = error instanceof Error ? error.message : "Indexing failed.";
+      }
+    } finally {
+      this.pumping = false;
+      if (!this.disposed) this.publish();
+    }
+  }
+  /** Yield to the host between slices; stop once disposed. */
+  async checkpoint() {
+    if (this.disposed) throw new IndexStopped();
+    if (this.now() - this.sliceStart < SLICE_MS) return;
+    await this.yieldControl();
+    if (this.disposed) throw new IndexStopped();
+    this.sliceStart = this.now();
+  }
+  // ── Watching ──────────────────────────────────────────────────────────
+  startWatching() {
+    if (!this.source.watch || !this.source.capabilities?.watch) return;
+    let subscription;
+    try {
+      subscription = this.source.watch((event) => this.onWatchEvent(event), {
+        onError: () => this.onWatchFailure()
+      });
+    } catch {
+      return;
+    }
+    this.subscription = subscription;
+    this.watching = true;
+    subscription.ready.then(
+      () => {
+        if (this.subscription === subscription) this.requestWalk(true);
+      },
+      () => this.onWatchFailure()
+    );
+  }
+  onWatchEvent(event) {
+    if (this.disposed) return;
+    if (event.type === "overflow") {
+      this.requestWalk(true);
+      return;
+    }
+    this.enqueueChange(event.path);
+    if (event.type === "moved" && event.destinationPath !== null) {
+      this.enqueueChange(event.destinationPath);
+    }
+  }
+  /** Fall back to explicit refreshes; never resubscribe automatically. */
+  onWatchFailure() {
+    if (this.disposed || !this.watching) return;
+    const subscription = this.subscription;
+    this.subscription = null;
+    this.watching = false;
+    if (subscription) void subscription.dispose().catch(() => void 0);
+    this.requestWalk(true);
+    this.publish();
+  }
+  // ── Listing ───────────────────────────────────────────────────────────
+  async fullWalk() {
+    const progressive = !this.listedOnce;
+    const previous = this.tree.documents;
+    const target = emptyTree();
+    if (progressive) this.tree = target;
+    let truncation;
+    try {
+      truncation = await this.listTree(target, previous, WORKSPACE_ROOT, 0, progressive);
+    } catch (error) {
+      if (!(error instanceof RootListingError)) throw error;
+      this.rootError = error.message;
+      this.lastWalkEnd = this.now();
+      for (const waiter of [...this.listedWaiters]) waiter(false);
+      return;
+    }
+    this.tree = target;
+    this.truncation = truncation;
+    this.rootError = null;
+    this.lastWalkEnd = this.now();
+    this.afterStructuralChange();
+    if (!this.listedOnce) {
+      this.listedOnce = true;
+      for (const waiter of [...this.listedWaiters]) waiter(true);
+    }
+    this.publish();
+  }
+  /**
+   * Breadth-first listing of `root` into `target`, carrying analysis over
+   * from `previous` for documents whose source version is unchanged.
+   */
+  async listTree(target, previous, root, rootDepth, progressive) {
+    let truncation = null;
+    const queue = [
+      { path: root, depth: rootDepth }
+    ];
+    const companions = [];
+    let directories = 0;
+    let entries = 0;
+    walk: while (queue.length > 0) {
+      await this.checkpoint();
+      const { path, depth } = queue.shift();
+      directories += 1;
+      if (directories > this.limits.maxDirectories) {
+        truncation ?? (truncation = { reason: "directories", limit: this.limits.maxDirectories });
+        break;
+      }
+      let children;
+      try {
+        children = await this.source.readDirectory(path);
+      } catch (error) {
+        if (this.disposed) throw new IndexStopped();
+        if (path === WORKSPACE_ROOT) {
+          throw new RootListingError(
+            error instanceof Error ? error.message : "The workspace could not be listed."
+          );
+        }
+        if (!isVanished(error)) target.unreadable.add(path);
+        continue;
+      }
+      if (this.disposed) throw new IndexStopped();
+      target.directories.add(path);
+      const directoryNames = new Set(
+        children.filter((child) => child.kind === "directory").map((child) => child.name)
+      );
+      for (const child of children) {
+        if (!isDiscoverableWorkspaceEntry(child.name, child.kind)) continue;
+        entries += 1;
+        if (entries > this.limits.maxEntries) {
+          truncation ?? (truncation = { reason: "entries", limit: this.limits.maxEntries });
+          break walk;
+        }
+        if (child.kind === "directory") {
+          if (depth + 1 > this.limits.maxDepth) {
+            truncation ?? (truncation = { reason: "depth", limit: this.limits.maxDepth });
+          } else {
+            queue.push({ path: child.path, depth: depth + 1 });
+          }
+          continue;
+        }
+        const kind = classify(child);
+        target.files.set(child.path, this.fileOf(child, kind));
+        if (kind === "markdown") {
+          target.documents.set(child.path, this.markdownState(child, previous.get(child.path)));
+        } else if (kind === "outside-in") {
+          const layout = resolveOutsideInLayout(child.path);
+          if (directoryNames.has(layout.companionName)) {
+            companions.push({ file: child, layout });
+          } else {
+            target.documents.set(
+              child.path,
+              this.outsideInState(child, layout, null, previous.get(child.path))
+            );
+          }
+        }
+      }
+      if (progressive) this.maybePublish();
+    }
+    for (const { file, layout } of companions) {
+      await this.checkpoint();
+      const source = await this.companionSource(layout);
+      target.documents.set(
+        file.path,
+        this.outsideInState(file, layout, source, previous.get(file.path))
+      );
+    }
+    return truncation;
+  }
+  /** The Markdown companion an outside-in document is edited through. */
+  async companionSource(layout) {
+    let companion;
+    try {
+      companion = await this.source.readDirectory(parseWorkspacePath(layout.companionDirectory));
+    } catch (error) {
+      if (this.disposed) throw new IndexStopped();
+      if (!isVanished(error)) this.readIssues += 1;
+      return null;
+    }
+    const files = companion.filter((entry) => entry.kind === "file");
+    const chosen = chooseOutsideInMarkdownPath(
+      layout,
+      files.map((entry) => entry.path)
+    );
+    return chosen ? files.find((entry) => entry.path === chosen) ?? null : null;
+  }
+  fileOf(entry, kind) {
+    return {
+      path: entry.path,
+      name: entry.name,
+      size: entry.kind === "file" ? entry.size : 0,
+      lastModified: entry.lastModified,
+      kind,
+      version: entry.version
+    };
+  }
+  markdownState(entry, previous) {
+    return this.documentState(
+      {
+        path: entry.path,
+        sourcePath: entry.path,
+        format: "markdown",
+        lastModified: entry.lastModified
+      },
+      entry.version,
+      entry.kind === "file" ? entry.size : 0,
+      null,
+      previous
+    );
+  }
+  outsideInState(entry, layout, source, previous) {
+    return this.documentState(
+      {
+        path: entry.path,
+        sourcePath: source?.path ?? null,
+        format: layout.format,
+        lastModified: entry.lastModified
+      },
+      source?.version ?? null,
+      source?.kind === "file" ? source.size : 0,
+      layout,
+      previous
+    );
+  }
+  documentState(identity, sourceVersion, sourceSize, layout, previous) {
+    const state = {
+      identity,
+      sourceVersion,
+      sourceSize,
+      layout,
+      analysis: null,
+      analysisVersion: null
+    };
+    if (identity.sourcePath === null) {
+      state.analysis = nameOnlyDocument(identity, "no-companion");
+    } else if (sourceSize > this.limits.maxDocumentBytes) {
+      state.analysis = nameOnlyDocument(identity, "too-large");
+    } else if (previous?.analysis && previous.identity.sourcePath === identity.sourcePath && previous.analysisVersion !== null && previous.analysisVersion === sourceVersion) {
+      state.analysis = {
+        record: { ...previous.analysis.record, lastModified: identity.lastModified },
+        text: previous.analysis.text
+      };
+      state.analysisVersion = previous.analysisVersion;
+    }
+    return state;
+  }
+  // ── Incremental changes ───────────────────────────────────────────────
+  async applyChanges(paths) {
+    for (const path of paths) {
+      await this.checkpoint();
+      await this.applyChange(path);
+    }
+    this.afterStructuralChange();
+    this.publish();
+  }
+  async applyChange(path) {
+    if (path === WORKSPACE_ROOT) {
+      this.walkRequested = true;
+      return;
+    }
+    const segments = path.split("/");
+    for (let index = 0; index < segments.length - 1; index += 1) {
+      const segment = segments[index];
+      if (isCompanionDirectoryName(segment)) {
+        await this.refreshCompanion(segments.slice(0, index + 1).join("/"));
+        return;
+      }
+      if (!isDiscoverableWorkspaceEntry(segment, "directory")) return;
+    }
+    let entry;
+    try {
+      entry = await this.source.stat(path);
+    } catch (error) {
+      if (this.disposed) throw new IndexStopped();
+      if (!isVanished(error)) {
+        this.walkRequested = true;
+        return;
+      }
+      entry = null;
+    }
+    if (this.disposed) throw new IndexStopped();
+    const name = segments[segments.length - 1];
+    if (entry === null) {
+      this.removeSubtree(path);
+      if (isCompanionDirectoryName(name)) await this.refreshCompanion(path);
+      return;
+    }
+    if (entry.kind === "directory") {
+      if (isCompanionDirectoryName(name)) {
+        await this.refreshCompanion(path);
+        return;
+      }
+      if (!isDiscoverableWorkspaceEntry(name, "directory")) return;
+      const previous2 = new Map(this.tree.documents);
+      this.removeSubtree(path);
+      const truncation = await this.listTree(this.tree, previous2, path, segments.length, false);
+      this.truncation ?? (this.truncation = truncation);
+      return;
+    }
+    if (!isDiscoverableWorkspaceEntry(name, "file")) return;
+    const kind = classify(entry);
+    this.tree.files.set(path, this.fileOf(entry, kind));
+    const previous = this.tree.documents.get(path);
+    if (kind === "markdown") {
+      this.tree.documents.set(path, this.markdownState(entry, previous));
+    } else if (kind === "outside-in") {
+      const layout = resolveOutsideInLayout(path);
+      const source = await this.companionSource(layout);
+      this.tree.documents.set(path, this.outsideInState(entry, layout, source, previous));
+    }
+  }
+  /** Re-resolve the outside-in documents whose companion folder is `companion`. */
+  async refreshCompanion(companion) {
+    for (const state of [...this.tree.documents.values()]) {
+      const layout = state.layout;
+      if (!layout || layout.companionDirectory !== companion) continue;
+      const file = this.tree.files.get(state.identity.path);
+      if (!file) continue;
+      const source = await this.companionSource(layout);
+      const entry = {
+        kind: "file",
+        path: file.path,
+        name: file.name,
+        size: file.size,
+        version: file.version,
+        lastModified: file.lastModified
+      };
+      this.tree.documents.set(file.path, this.outsideInState(entry, layout, source, state));
+    }
+  }
+  removeSubtree(path) {
+    const within = (candidate) => workspacePathContains(path, candidate);
+    for (const key of [...this.tree.files.keys()]) if (within(key)) this.tree.files.delete(key);
+    for (const key of [...this.tree.documents.keys()]) {
+      if (within(key)) this.tree.documents.delete(key);
+    }
+    for (const key of [...this.tree.directories])
+      if (within(key)) this.tree.directories.delete(key);
+    for (const key of [...this.tree.unreadable]) if (within(key)) this.tree.unreadable.delete(key);
+  }
+  /** Recount totals and requeue analysis after the tree changed shape. */
+  afterStructuralChange() {
+    let analyzed = 0;
+    let characters = 0;
+    for (const state of this.tree.documents.values()) {
+      if (state.analysis && state.analysis.record.content !== "name-only") analyzed += 1;
+      characters += state.analysis?.text?.characters ?? 0;
+    }
+    this.analyzedCount = analyzed;
+    this.textCharacters = characters;
+    this.queueDirty = true;
+  }
+  // ── Analysis ──────────────────────────────────────────────────────────
+  nextPendingDocument() {
+    while (this.priority.length > 0) {
+      const path = this.priority.shift();
+      const state = this.tree.documents.get(path);
+      if (state && state.analysis === null) return state;
+    }
+    if (this.queueDirty) {
+      this.queue = [...this.tree.documents.values()].filter((state) => state.analysis === null).sort(
+        (left, right) => compareCodeUnits2(right.identity.lastModified, left.identity.lastModified) || compareCodeUnits2(left.identity.path, right.identity.path)
+      );
+      this.queueIndex = 0;
+      this.queueDirty = false;
+    }
+    while (this.queueIndex < this.queue.length) {
+      const state = this.queue[this.queueIndex];
+      this.queueIndex += 1;
+      if (this.tree.documents.get(state.identity.path) === state && state.analysis === null) {
+        return state;
+      }
+    }
+    return null;
+  }
+  async analyze(state) {
+    const { identity } = state;
+    if (this.analyzedCount >= this.limits.maxDocuments) {
+      state.analysis = nameOnlyDocument(identity, "over-budget");
+      this.analysisTruncation ?? (this.analysisTruncation = { reason: "documents", limit: this.limits.maxDocuments });
+      return;
+    }
+    const sourcePath = identity.sourcePath;
+    let read;
+    try {
+      read = await this.source.readFile(sourcePath);
+    } catch (error) {
+      if (this.disposed) throw new IndexStopped();
+      if (isVanished(error)) {
+        this.enqueueChange(identity.path);
+        state.analysis = nameOnlyDocument(identity, "read-error");
+        return;
+      }
+      this.readIssues += 1;
+      state.analysis = nameOnlyDocument(identity, "read-error");
+      return;
+    }
+    if (this.disposed) throw new IndexStopped();
+    if (this.tree.documents.get(identity.path) !== state) return;
+    if (read === null) {
+      this.enqueueChange(identity.path);
+      state.analysis = nameOnlyDocument(identity, "read-error");
+      return;
+    }
+    await this.checkpoint();
+    let analyzed;
+    if (read.data.byteLength > this.limits.maxDocumentBytes) {
+      analyzed = nameOnlyDocument(identity, "too-large");
+    } else {
+      try {
+        analyzed = await analyzeDocumentBytes(identity, read.data, {
+          maxParseBytes: this.limits.maxParseBytes,
+          signal: this.abort.signal
+        });
+      } catch {
+        if (this.disposed) throw new IndexStopped();
+        analyzed = nameOnlyDocument(identity, "read-error");
+      }
+    }
+    if (this.tree.documents.get(identity.path) !== state) return;
+    const characters = analyzed.text?.characters ?? 0;
+    if (characters > 0 && this.textCharacters + characters > this.limits.maxTextCharacters) {
+      analyzed = {
+        record: { ...analyzed.record, content: "name-only", issue: "over-budget" },
+        text: null
+      };
+      this.analysisTruncation ?? (this.analysisTruncation = { reason: "text", limit: this.limits.maxTextCharacters });
+    }
+    state.analysis = analyzed;
+    state.analysisVersion = read.entry.version;
+    this.textCharacters += analyzed.text?.characters ?? 0;
+    if (analyzed.record.content !== "name-only") this.analyzedCount += 1;
+  }
+  // ── Publishing ────────────────────────────────────────────────────────
+  recordOf(state) {
+    return state.analysis?.record ?? nameOnlyDocument(state.identity, "pending").record;
+  }
+  maybePublish() {
+    if (this.now() - this.lastPublish >= PUBLISH_INTERVAL_MS) this.publish();
+  }
+  publish() {
+    this.generation += 1;
+    this.lastPublish = this.now();
+    this.filesCache = null;
+    this.documentsCache = null;
+    this.statusCache = null;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+};
+function createWorkspaceIndex(options) {
+  return new WorkspaceIndexImpl(options);
+}
+
+// src/workspace-index/fuzzy.ts
+var SEPARATORS = /* @__PURE__ */ new Set(["/", "\\", "-", "_", ".", " "]);
+var SCORE_MATCH = 16;
+var BONUS_FIRST_CHARACTER = 24;
+var BONUS_WORD_START = 20;
+var BONUS_CONSECUTIVE = 12;
+var BONUS_SAME_CASE = 1;
+var PENALTY_GAP = 2;
+var PENALTY_GAP_CAP = 24;
+var PENALTY_LEADING = 1;
+function isWordStart(target, index) {
+  if (index === 0) return true;
+  const previous = target[index - 1];
+  if (SEPARATORS.has(previous)) return true;
+  const current = target[index];
+  return previous === previous.toLowerCase() && current !== current.toLowerCase();
+}
+function toRanges(indices) {
+  const ranges = [];
+  for (const index of indices) {
+    const last = ranges[ranges.length - 1];
+    if (last && last[1] === index) ranges[ranges.length - 1] = [last[0], index + 1];
+    else ranges.push([index, index + 1]);
+  }
+  return ranges;
+}
+function fuzzyMatch(query, target) {
+  if (!query) return { score: 0, ranges: [] };
+  const lowerQuery = query.toLowerCase();
+  const lowerTarget = target.toLowerCase();
+  if (lowerQuery.length > lowerTarget.length) return null;
+  let queryIndex = 0;
+  let end = -1;
+  for (let index = 0; index < lowerTarget.length; index += 1) {
+    if (lowerTarget[index] === lowerQuery[queryIndex]) {
+      queryIndex += 1;
+      if (queryIndex === lowerQuery.length) {
+        end = index;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  queryIndex = lowerQuery.length - 1;
+  let start = end;
+  for (let index = end; index >= 0; index -= 1) {
+    if (lowerTarget[index] === lowerQuery[queryIndex]) {
+      queryIndex -= 1;
+      if (queryIndex < 0) {
+        start = index;
+        break;
+      }
+    }
+  }
+  const indices = [];
+  queryIndex = 0;
+  for (let index = start; index <= end && queryIndex < lowerQuery.length; index += 1) {
+    if (lowerTarget[index] !== lowerQuery[queryIndex]) continue;
+    indices.push(index);
+    queryIndex += 1;
+  }
+  if (indices.length !== lowerQuery.length) return null;
+  let score = 0;
+  let previous = -2;
+  for (let position = 0; position < indices.length; position += 1) {
+    const index = indices[position];
+    score += SCORE_MATCH;
+    if (index === 0) score += BONUS_FIRST_CHARACTER;
+    else if (isWordStart(target, index)) score += BONUS_WORD_START;
+    if (index === previous + 1) score += BONUS_CONSECUTIVE;
+    else if (previous >= 0)
+      score -= Math.min(PENALTY_GAP * (index - previous - 1), PENALTY_GAP_CAP);
+    if (target[index] === query[position]) score += BONUS_SAME_CASE;
+    previous = index;
+  }
+  score -= Math.min(PENALTY_LEADING * indices[0], PENALTY_GAP_CAP);
+  return { score, ranges: toRanges(indices) };
+}
+function fuzzyMatchTokens(tokens, target) {
+  let score = 0;
+  const marked = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const match = fuzzyMatch(token, target);
+    if (!match) return null;
+    score += match.score;
+    for (const [rangeStart, rangeEnd] of match.ranges) {
+      for (let index = rangeStart; index < rangeEnd; index += 1) marked.add(index);
+    }
+  }
+  return { score, ranges: toRanges([...marked].sort((left, right) => left - right)) };
+}
+function fuzzyTokens(query) {
+  return query.trim().split(/\s+/u).filter(Boolean);
+}
+export {
+  WORKSPACE_INDEX_LIMITS,
+  WORKSPACE_SEARCH_LIMITS,
+  buildLiteralMatcher,
+  buildSnippet,
+  createWorkspaceIndex,
+  fuzzyMatch,
+  fuzzyMatchTokens,
+  fuzzyTokens
+};