trellis 1.0.8 → 2.0.6

package/dist/index-vkpkfwhq.js

@@ -0,0 +1,817 @@
+// @bun
+import {
+  __esm,
+  __export,
+  __require
+} from "./index-a76rekgs.js";
+
+// src/links/parser.ts
+function parseFileRefs(content, filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  if (ext === "md") {
+    return parseMarkdownRefs(content, filePath);
+  }
+  return parseDocCommentRefs(content, filePath, ext);
+}
+function parseMarkdownRefs(content, filePath) {
+  return extractRefs(content, filePath, "markdown");
+}
+function parseDocCommentRefs(content, filePath, ext) {
+  const fileExt = ext ?? (filePath.split(".").pop()?.toLowerCase() ?? "");
+  const commentBlocks = extractDocComments(content, fileExt);
+  const refs = [];
+  for (const block of commentBlocks) {
+    const blockRefs = extractRefs(block.text, filePath, block.context, block.startLine);
+    refs.push(...blockRefs);
+  }
+  return refs;
+}
+function extractRefs(text, filePath, context, lineOffset = 0) {
+  const refs = [];
+  const lines = text.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    let match;
+    const re = new RegExp(WIKI_LINK_RE.source, WIKI_LINK_RE.flags);
+    while ((match = re.exec(line)) !== null) {
+      const raw = match[1];
+      const col = match.index;
+      const lineNum = i + 1 + lineOffset;
+      const parsed = parseRefContent(raw);
+      if (!parsed)
+        continue;
+      refs.push({
+        ...parsed,
+        raw,
+        source: {
+          filePath,
+          line: lineNum,
+          col,
+          context
+        }
+      });
+    }
+  }
+  return refs;
+}
+function parseRefContent(raw) {
+  if (!raw || !raw.trim())
+    return null;
+  let content;
+  let alias;
+  const pipeIdx = raw.indexOf("|");
+  if (pipeIdx !== -1) {
+    content = raw.substring(0, pipeIdx).trim();
+    alias = raw.substring(pipeIdx + 1).trim();
+    if (!alias)
+      alias = undefined;
+  } else {
+    content = raw.trim();
+  }
+  if (!content)
+    return null;
+  const colonIdx = content.indexOf(":");
+  if (colonIdx !== -1) {
+    const possibleNs = content.substring(0, colonIdx);
+    if (isValidNamespace(possibleNs)) {
+      const rest = content.substring(colonIdx + 1);
+      const { target: target2, anchor: anchor2 } = splitAnchor(rest);
+      const ns = possibleNs;
+      return { namespace: ns, target: target2, anchor: anchor2, alias };
+    }
+  }
+  const { target, anchor } = splitAnchor(content);
+  const inferred = inferNamespace(target, anchor);
+  if (!inferred)
+    return null;
+  return { namespace: inferred, target, anchor, alias };
+}
+function splitAnchor(content) {
+  const hashIdx = content.indexOf("#");
+  if (hashIdx === -1)
+    return { target: content };
+  return {
+    target: content.substring(0, hashIdx),
+    anchor: content.substring(hashIdx + 1) || undefined
+  };
+}
+function isValidNamespace(s) {
+  return VALID_NAMESPACES.has(s);
+}
+function inferNamespace(target, anchor) {
+  if (/^TRL-\d+$/i.test(target))
+    return "issue";
+  if (/^DEC-\d+$/i.test(target))
+    return "decision";
+  if (anchor)
+    return "symbol";
+  if (target.includes("/"))
+    return "file";
+  const ext = target.split(".").pop()?.toLowerCase();
+  if (ext && CODE_EXTENSIONS.has(ext))
+    return "file";
+  return null;
+}
+function extractDocComments(content, ext) {
+  switch (ext) {
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx":
+    case "mjs":
+    case "cjs":
+    case "java":
+    case "cs":
+      return extractJSDocComments(content);
+    case "py":
+    case "pyi":
+      return extractPythonDocstrings(content);
+    case "rs":
+      return extractRustDocComments(content);
+    case "go":
+      return extractGoDocComments(content);
+    case "rb":
+      return extractRubyDocComments(content);
+    default:
+      return [];
+  }
+}
+function extractJSDocComments(content) {
+  const blocks = [];
+  const lines = content.split(`
+`);
+  let inBlock = false;
+  let blockLines = [];
+  let blockStart = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!inBlock && (trimmed.startsWith("/**") || trimmed.startsWith("/*"))) {
+      inBlock = true;
+      blockStart = i;
+      blockLines = [trimmed];
+      if (trimmed.endsWith("*/") && trimmed.length > 4) {
+        blocks.push({
+          text: stripBlockCommentMarkers(blockLines.join(`
+`)),
+          startLine: blockStart,
+          context: "jsdoc"
+        });
+        inBlock = false;
+        blockLines = [];
+      }
+      continue;
+    }
+    if (inBlock) {
+      blockLines.push(trimmed);
+      if (trimmed.includes("*/")) {
+        blocks.push({
+          text: stripBlockCommentMarkers(blockLines.join(`
+`)),
+          startLine: blockStart,
+          context: "jsdoc"
+        });
+        inBlock = false;
+        blockLines = [];
+      }
+      continue;
+    }
+    if (trimmed.startsWith("//")) {
+      blocks.push({
+        text: trimmed.replace(/^\/\/\s?/, ""),
+        startLine: i,
+        context: "comment"
+      });
+    }
+  }
+  return blocks;
+}
+function stripBlockCommentMarkers(text) {
+  return text.replace(/^\/\*\*?\s?/, "").replace(/\*\/\s*$/, "").split(`
+`).map((line) => line.replace(/^\s*\*\s?/, "")).join(`
+`).trim();
+}
+function extractPythonDocstrings(content) {
+  const blocks = [];
+  const lines = content.split(`
+`);
+  let inDocstring = false;
+  let delimiter = "";
+  let blockLines = [];
+  let blockStart = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!inDocstring) {
+      for (const delim of ['"""', "'''"]) {
+        if (trimmed.startsWith(delim)) {
+          if (trimmed.endsWith(delim) && trimmed.length > delim.length * 2) {
+            blocks.push({
+              text: trimmed.slice(delim.length, -delim.length).trim(),
+              startLine: i,
+              context: "pydoc"
+            });
+            break;
+          }
+          inDocstring = true;
+          delimiter = delim;
+          blockStart = i;
+          blockLines = [trimmed.slice(delim.length)];
+          break;
+        }
+      }
+      if (!inDocstring && trimmed.startsWith("#")) {
+        blocks.push({
+          text: trimmed.replace(/^#\s?/, ""),
+          startLine: i,
+          context: "comment"
+        });
+      }
+    } else {
+      if (trimmed.endsWith(delimiter)) {
+        blockLines.push(trimmed.slice(0, -delimiter.length));
+        blocks.push({
+          text: blockLines.join(`
+`).trim(),
+          startLine: blockStart,
+          context: "pydoc"
+        });
+        inDocstring = false;
+        blockLines = [];
+      } else {
+        blockLines.push(trimmed);
+      }
+    }
+  }
+  return blocks;
+}
+function extractRustDocComments(content) {
+  const blocks = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith("///") || trimmed.startsWith("//!")) {
+      blocks.push({
+        text: trimmed.replace(/^\/\/[\/!]\s?/, ""),
+        startLine: i,
+        context: "rustdoc"
+      });
+    }
+  }
+  return blocks;
+}
+function extractGoDocComments(content) {
+  const blocks = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith("//")) {
+      blocks.push({
+        text: trimmed.replace(/^\/\/\s?/, ""),
+        startLine: i,
+        context: "godoc"
+      });
+    }
+  }
+  return blocks;
+}
+function extractRubyDocComments(content) {
+  const blocks = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith("#")) {
+      blocks.push({
+        text: trimmed.replace(/^#\s?/, ""),
+        startLine: i,
+        context: "comment"
+      });
+    }
+  }
+  return blocks;
+}
+var WIKI_LINK_RE, CODE_EXTENSIONS, VALID_NAMESPACES;
+var init_parser = __esm(() => {
+  WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
+  CODE_EXTENSIONS = new Set([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "py",
+    "pyi",
+    "go",
+    "rs",
+    "rb",
+    "java",
+    "cs",
+    "md",
+    "json",
+    "yaml",
+    "yml",
+    "toml",
+    "css",
+    "scss",
+    "less",
+    "html",
+    "vue",
+    "svelte"
+  ]);
+  VALID_NAMESPACES = new Set([
+    "issue",
+    "file",
+    "symbol",
+    "identity",
+    "milestone",
+    "decision"
+  ]);
+});
+
+// src/links/resolver.ts
+function resolveRef(ref, ctx) {
+  switch (ref.namespace) {
+    case "issue":
+      return resolveIssue(ref, ctx);
+    case "file":
+      return resolveFile(ref, ctx);
+    case "symbol":
+      return resolveSymbol(ref, ctx);
+    case "identity":
+      return resolveIdentity(ref, ctx);
+    case "milestone":
+      return resolveMilestone(ref, ctx);
+    case "decision":
+      return resolveDecision(ref, ctx);
+    default:
+      return { ...ref, state: "broken" };
+  }
+}
+function resolveRefs(refs, ctx) {
+  return refs.map((ref) => resolveRef(ref, ctx));
+}
+function resolveIssue(ref, ctx) {
+  const title = ctx.getIssueTitle(ref.target);
+  if (title !== undefined) {
+    return {
+      ...ref,
+      state: "resolved",
+      entityId: `issue:${ref.target}`,
+      title
+    };
+  }
+  return { ...ref, state: "broken" };
+}
+function resolveFile(ref, ctx) {
+  if (ctx.hasTrackedFile(ref.target)) {
+    return {
+      ...ref,
+      state: "resolved",
+      entityId: `file:${ref.target}`,
+      title: ref.target
+    };
+  }
+  return { ...ref, state: "broken" };
+}
+function resolveSymbol(ref, ctx) {
+  if (!ctx.hasTrackedFile(ref.target)) {
+    return { ...ref, state: "broken" };
+  }
+  if (ref.anchor && ctx.hasSymbol(ref.target, ref.anchor)) {
+    return {
+      ...ref,
+      state: "resolved",
+      entityId: `symbol:${ref.target}#${ref.anchor}`,
+      title: `${ref.anchor} in ${ref.target}`
+    };
+  }
+  if (ref.anchor) {
+    return { ...ref, state: "broken" };
+  }
+  return {
+    ...ref,
+    state: "resolved",
+    entityId: `file:${ref.target}`,
+    title: ref.target
+  };
+}
+function resolveIdentity(ref, ctx) {
+  if (ctx.hasIdentity(ref.target)) {
+    return {
+      ...ref,
+      state: "resolved",
+      entityId: `identity:${ref.target}`,
+      title: ref.target
+    };
+  }
+  return { ...ref, state: "broken" };
+}
+function resolveMilestone(ref, ctx) {
+  const title = ctx.getMilestoneTitle(ref.target);
+  if (title !== undefined) {
+    return {
+      ...ref,
+      state: "resolved",
+      entityId: `milestone:${ref.target}`,
+      title
+    };
+  }
+  return { ...ref, state: "broken" };
+}
+function resolveDecision(ref, ctx) {
+  if (ctx.hasDecision(ref.target)) {
+    return {
+      ...ref,
+      state: "resolved",
+      entityId: `decision:${ref.target}`,
+      title: ctx.getDecisionTitle(ref.target) ?? ref.target
+    };
+  }
+  return { ...ref, state: "broken" };
+}
+function createResolverContext(engine) {
+  const trackedSet = new Set(engine.trackedFiles().map((f) => f.path));
+  const agentIds = new Set(engine.getOps().map((op) => op.agentId));
+  const issues = engine.listIssues();
+  const milestones = engine.listMilestones();
+  return {
+    hasTrackedFile(path) {
+      return trackedSet.has(path);
+    },
+    getIssueTitle(id) {
+      const issue = engine.getIssue(id);
+      return issue?.title;
+    },
+    getMilestoneTitle(idOrMessage) {
+      const byId = milestones.find((m) => m.id === idOrMessage);
+      if (byId)
+        return byId.message;
+      const byMsg = milestones.find((m) => m.message && m.message.toLowerCase().includes(idOrMessage.toLowerCase()));
+      return byMsg?.message;
+    },
+    hasSymbol(filePath, symbolName) {
+      try {
+        const { readFileSync } = __require("fs");
+        const { join } = __require("path");
+        const absPath = join(engine.getRootPath(), filePath);
+        const content = readFileSync(absPath, "utf-8");
+        const result = engine.parseFile(content, filePath);
+        if (!result)
+          return false;
+        return result.declarations.some((d) => d.name === symbolName);
+      } catch {
+        return false;
+      }
+    },
+    hasIdentity(id) {
+      return agentIds.has(id) || agentIds.has(`agent:${id}`);
+    },
+    getKnownAgentIds() {
+      return [...agentIds];
+    },
+    getTrackedFilePaths() {
+      return [...trackedSet];
+    },
+    getIssueIds() {
+      return issues.map((i) => i.id);
+    },
+    getMilestoneIds() {
+      return milestones.map((m) => m.id);
+    },
+    hasDecision(id) {
+      if (!engine.getDecision)
+        return false;
+      return engine.getDecision(id) !== null;
+    },
+    getDecisionTitle(id) {
+      if (!engine.getDecision)
+        return;
+      const d = engine.getDecision(id);
+      return d?.toolName;
+    },
+    getSymbolNames(filePath) {
+      try {
+        const { readFileSync } = __require("fs");
+        const { join } = __require("path");
+        const absPath = join(engine.getRootPath(), filePath);
+        const content = readFileSync(absPath, "utf-8");
+        const result = engine.parseFile(content, filePath);
+        if (!result)
+          return [];
+        return result.declarations.map((d) => d.name);
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+var init_resolver = () => {};
+
+// src/links/ref-index.ts
+function buildRefIndex(files, ctx) {
+  const index = {
+    outgoing: new Map,
+    incoming: new Map
+  };
+  for (const file of files) {
+    const refs = parseFileRefs(file.content, file.path);
+    addFileToIndex(index, file.path, refs, ctx);
+  }
+  return index;
+}
+function updateFileInIndex(index, filePath, content, ctx) {
+  removeFileFromIndex(index, filePath);
+  const refs = parseFileRefs(content, filePath);
+  addFileToIndex(index, filePath, refs, ctx);
+}
+function removeFileFromIndex(index, filePath) {
+  const oldRefs = index.outgoing.get(filePath);
+  if (!oldRefs)
+    return;
+  for (const ref of oldRefs) {
+    const resolved = resolveRefToEntityId(ref);
+    if (resolved) {
+      const sources = index.incoming.get(resolved);
+      if (sources) {
+        const filtered = sources.filter((s) => s.filePath !== filePath);
+        if (filtered.length > 0) {
+          index.incoming.set(resolved, filtered);
+        } else {
+          index.incoming.delete(resolved);
+        }
+      }
+    }
+  }
+  index.outgoing.delete(filePath);
+}
+function getOutgoingRefs(index, filePath) {
+  return index.outgoing.get(filePath) ?? [];
+}
+function getBacklinks(index, entityId) {
+  return index.incoming.get(entityId) ?? [];
+}
+function getReferencedEntities(index) {
+  return [...index.incoming.keys()];
+}
+function getFilesWithRefs(index) {
+  return [...index.outgoing.keys()];
+}
+function getIndexStats(index) {
+  let totalRefs = 0;
+  for (const refs of index.outgoing.values()) {
+    totalRefs += refs.length;
+  }
+  return {
+    totalFiles: index.outgoing.size,
+    totalRefs,
+    totalEntities: index.incoming.size
+  };
+}
+function addFileToIndex(index, filePath, refs, ctx) {
+  if (refs.length === 0)
+    return;
+  index.outgoing.set(filePath, refs);
+  for (const ref of refs) {
+    const resolved = resolveRef(ref, ctx);
+    const entityId = resolved.entityId ?? buildFallbackEntityId(ref);
+    const sources = index.incoming.get(entityId) ?? [];
+    sources.push(ref.source);
+    index.incoming.set(entityId, sources);
+  }
+}
+function buildFallbackEntityId(ref) {
+  if (ref.anchor) {
+    return `${ref.namespace}:${ref.target}#${ref.anchor}`;
+  }
+  return `${ref.namespace}:${ref.target}`;
+}
+function resolveRefToEntityId(ref) {
+  if (ref.anchor) {
+    return `${ref.namespace}:${ref.target}#${ref.anchor}`;
+  }
+  return `${ref.namespace}:${ref.target}`;
+}
+var init_ref_index = __esm(() => {
+  init_parser();
+  init_resolver();
+});
+
+// src/links/lifecycle.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+
+class StaleRefRegistry {
+  staleRefs = new Map;
+  markStale(entityId, reason, sources, opts) {
+    const entry = {
+      entityId,
+      reason,
+      causeOpHash: opts?.causeOpHash,
+      newTarget: opts?.newTarget,
+      timestamp: new Date().toISOString(),
+      sources
+    };
+    this.staleRefs.set(entityId, entry);
+    return entry;
+  }
+  clearStale(entityId) {
+    this.staleRefs.delete(entityId);
+  }
+  isStale(entityId) {
+    return this.staleRefs.has(entityId);
+  }
+  getStale(entityId) {
+    return this.staleRefs.get(entityId);
+  }
+  getAllStale() {
+    return [...this.staleRefs.values()];
+  }
+  getByReason(reason) {
+    return this.getAllStale().filter((s) => s.reason === reason);
+  }
+}
+function buildRenameProposal(index, filePath, oldName, newName) {
+  const oldEntityId = `symbol:${filePath}#${oldName}`;
+  const newEntityId = `symbol:${filePath}#${newName}`;
+  const sources = getBacklinks(index, oldEntityId);
+  const altEntityId = `symbol:${filePath}#${oldName}`;
+  const altSources = getBacklinks(index, altEntityId);
+  const allSources = deduplicateSources([...sources, ...altSources]);
+  const rewrites = [];
+  const affectedFiles = new Set;
+  for (const source of allSources) {
+    affectedFiles.add(source.filePath);
+    const oldText = buildRefText(filePath, oldName);
+    const newText = buildRefText(filePath, newName);
+    rewrites.push({
+      filePath: source.filePath,
+      line: source.line,
+      col: source.col,
+      oldText,
+      newText
+    });
+  }
+  return {
+    oldTarget: oldEntityId,
+    newTarget: newEntityId,
+    affectedFiles: [...affectedFiles],
+    rewrites
+  };
+}
+function applyRenameProposal(proposal, rootPath) {
+  const modifiedFiles = [];
+  const byFile = new Map;
+  for (const rw of proposal.rewrites) {
+    const existing = byFile.get(rw.filePath) ?? [];
+    existing.push(rw);
+    byFile.set(rw.filePath, existing);
+  }
+  for (const [filePath, rewrites] of byFile) {
+    try {
+      const absPath = join(rootPath, filePath);
+      let content = readFileSync(absPath, "utf-8");
+      let modified = false;
+      for (const rw of rewrites) {
+        if (content.includes(rw.oldText)) {
+          content = content.replaceAll(rw.oldText, rw.newText);
+          modified = true;
+        }
+      }
+      if (modified) {
+        const { writeFileSync } = __require("fs");
+        writeFileSync(absPath, content);
+        modifiedFiles.push(filePath);
+      }
+    } catch {}
+  }
+  return modifiedFiles;
+}
+function handleSymbolDeletion(index, registry, filePath, symbolName, causeOpHash) {
+  const entityId = `symbol:${filePath}#${symbolName}`;
+  const sources = getBacklinks(index, entityId);
+  if (sources.length === 0)
+    return null;
+  return registry.markStale(entityId, "deleted", sources, { causeOpHash });
+}
+function handleFileDeletion(index, registry, filePath, causeOpHash) {
+  const entityId = `file:${filePath}`;
+  const sources = getBacklinks(index, entityId);
+  if (sources.length === 0)
+    return null;
+  return registry.markStale(entityId, "deleted", sources, { causeOpHash });
+}
+function getDiagnostics(index, registry, resolvedEntityIds) {
+  const diagnostics = [];
+  for (const [filePath, refs] of index.outgoing) {
+    for (const ref of refs) {
+      const entityId = buildEntityIdFromRef(ref);
+      const staleInfo = registry.getStale(entityId);
+      if (staleInfo) {
+        const reason = staleInfo.reason === "renamed" ? `renamed to ${staleInfo.newTarget}` : "removed";
+        diagnostics.push({
+          entityId,
+          state: "stale",
+          source: ref.source,
+          message: `Reference to '${ref.target}${ref.anchor ? "#" + ref.anchor : ""}' is stale: target was ${reason}`
+        });
+        continue;
+      }
+      if (!resolvedEntityIds.has(entityId)) {
+        diagnostics.push({
+          entityId,
+          state: "broken",
+          source: ref.source,
+          message: `Cannot resolve reference: '${ref.target}${ref.anchor ? "#" + ref.anchor : ""}' does not exist`
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+function processSemanticPatches(patches, filePath, index, registry, causeOpHash) {
+  const events = [];
+  for (const patch of patches) {
+    if (patch.kind === "symbolRename") {
+      const proposal = buildRenameProposal(index, filePath, patch.oldName, patch.newName);
+      if (proposal.rewrites.length > 0) {
+        events.push({
+          type: "rename-proposal",
+          filePath,
+          proposal
+        });
+      }
+    }
+    if (patch.kind === "symbolRemove") {
+      const staleRef = handleSymbolDeletion(index, registry, filePath, patch.entityName, causeOpHash);
+      if (staleRef) {
+        events.push({
+          type: "stale-detected",
+          filePath,
+          staleRef
+        });
+      }
+    }
+  }
+  return events;
+}
+function buildRefText(filePath, symbolName) {
+  return `[[${filePath}#${symbolName}]]`;
+}
+function buildEntityIdFromRef(ref) {
+  if (ref.anchor) {
+    return `${ref.namespace}:${ref.target}#${ref.anchor}`;
+  }
+  return `${ref.namespace}:${ref.target}`;
+}
+function deduplicateSources(sources) {
+  const seen = new Set;
+  return sources.filter((s) => {
+    const key = `${s.filePath}:${s.line}:${s.col}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+var init_lifecycle = __esm(() => {
+  init_ref_index();
+});
+
+// src/links/index.ts
+var exports_links = {};
+__export(exports_links, {
+  updateFileInIndex: () => updateFileInIndex,
+  resolveRefs: () => resolveRefs,
+  resolveRef: () => resolveRef,
+  removeFileFromIndex: () => removeFileFromIndex,
+  processSemanticPatches: () => processSemanticPatches,
+  parseRefContent: () => parseRefContent,
+  parseMarkdownRefs: () => parseMarkdownRefs,
+  parseFileRefs: () => parseFileRefs,
+  parseDocCommentRefs: () => parseDocCommentRefs,
+  inferNamespace: () => inferNamespace,
+  handleSymbolDeletion: () => handleSymbolDeletion,
+  handleFileDeletion: () => handleFileDeletion,
+  getReferencedEntities: () => getReferencedEntities,
+  getOutgoingRefs: () => getOutgoingRefs,
+  getIndexStats: () => getIndexStats,
+  getFilesWithRefs: () => getFilesWithRefs,
+  getDiagnostics: () => getDiagnostics,
+  getBacklinks: () => getBacklinks,
+  createResolverContext: () => createResolverContext,
+  buildRenameProposal: () => buildRenameProposal,
+  buildRefIndex: () => buildRefIndex,
+  applyRenameProposal: () => applyRenameProposal,
+  StaleRefRegistry: () => StaleRefRegistry
+});
+var init_links = __esm(() => {
+  init_parser();
+  init_resolver();
+  init_ref_index();
+  init_lifecycle();
+});
+
+export { parseFileRefs, parseMarkdownRefs, parseDocCommentRefs, parseRefContent, inferNamespace, resolveRef, resolveRefs, createResolverContext, buildRefIndex, updateFileInIndex, removeFileFromIndex, getOutgoingRefs, getBacklinks, getReferencedEntities, getFilesWithRefs, getIndexStats, StaleRefRegistry, buildRenameProposal, applyRenameProposal, handleSymbolDeletion, handleFileDeletion, getDiagnostics, processSemanticPatches, exports_links, init_links };