@mutmutco/cli 4.1.19 → 4.1.20

package/dist/repo-index-v4.cjs

@@ -1,1070 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/repo-index-v4/index.ts
-var index_exports = {};
-__export(index_exports, {
-  REPO_INDEX_V4_SCHEMA: () => REPO_INDEX_V4_SCHEMA,
-  V4_DELTA_DEEPEN_STEPS: () => V4_DELTA_DEEPEN_STEPS,
-  V4_GRAPH_MAX_EDGES: () => V4_GRAPH_MAX_EDGES,
-  V4_GRAPH_MAX_EDGES_PER_FILE: () => V4_GRAPH_MAX_EDGES_PER_FILE,
-  V4_MAX_ARTIFACT_BYTES: () => V4_MAX_ARTIFACT_BYTES,
-  V4_MAX_CHUNKS: () => V4_MAX_CHUNKS,
-  V4_STAGE_MAX_BODY_BYTES: () => V4_STAGE_MAX_BODY_BYTES,
-  V4_STAGE_MAX_RECORDS: () => V4_STAGE_MAX_RECORDS,
-  buildGraphEdges: () => buildGraphEdges,
-  buildRepoIndexV4: () => buildRepoIndexV4,
-  buildRepoIndexV4Detailed: () => buildRepoIndexV4Detailed,
-  buildStructuralChunks: () => buildStructuralChunks,
-  buildStructuralChunksForPaths: () => buildStructuralChunksForPaths,
-  canonicalRepoIndexPaths: () => canonicalRepoIndexPaths,
-  changedPaths: () => changedPaths,
-  compareV4Chunks: () => compareV4Chunks,
-  encodedStageBytes: () => encodedStageBytes,
-  formatV4BuildMetrics: () => formatV4BuildMetrics,
-  gitRunner: () => gitRunner,
-  graphEdgesForSource: () => graphEdgesForSource,
-  isRepoIndexDeltaCompatible: () => isRepoIndexDeltaCompatible,
-  languageForPath: () => languageForPath,
-  parseNameStatusZ: () => parseNameStatusZ,
-  planRepoIndexV4Delta: () => planRepoIndexV4Delta,
-  readRepoIndexProvenance: () => readRepoIndexProvenance,
-  removedPaths: () => removedPaths,
-  repoIndexV4DeltaBase: () => repoIndexV4DeltaBase,
-  repoIndexV4StorePath: () => repoIndexV4StorePath,
-  shardRepoIndexV4: () => shardRepoIndexV4,
-  structuralChunksForSource: () => structuralChunksForSource
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/repo-index-v4/chunks.ts
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs2 = require("node:fs");
-var import_node_path3 = require("node:path");
-
-// ../infra/repo-index-path-policy.mjs
-var HARD_DENY = Object.freeze([
-  /(^|\/)\.env(\.|$)/i,
-  /(^|\/)\.env\./i,
-  /credentials/i,
-  /secrets?\.json$/i,
-  /\.pem$/i,
-  /\.p12$/i,
-  /\.key$/i,
-  /(^|\/)id_rsa/i,
-  /(^|\/)id_ed25519/i,
-  /\.keystore$/i
-]);
-function isHardDeniedRepoIndexPath(value) {
-  return typeof value !== "string" || HARD_DENY.some((pattern) => pattern.test(value));
-}
-function isSafeRepoIndexPath(value) {
-  if (typeof value !== "string" || !value || value.length > 1024) return false;
-  if (value.startsWith("/") || value.includes("\\") || /[\u0000-\u001f\u007f]/u.test(value)) return false;
-  const segments = value.split("/");
-  if (segments.some((segment) => !segment || segment === "." || segment === "..")) return false;
-  return !isHardDeniedRepoIndexPath(value);
-}
-var REPO_INDEX_ALGORITHM_VERSION = 1;
-var REPO_INDEX_FILTER_VERSION = 2;
-var REPO_INDEX_MATERIAL_LAYOUT_VERSION = 2;
-var LEGACY_REPO_INDEX_PROVENANCE = Object.freeze({
-  algorithmVersion: 1,
-  filterVersion: 1,
-  materialLayoutVersion: 1
-});
-var CURRENT_REPO_INDEX_PROVENANCE = Object.freeze({
-  algorithmVersion: REPO_INDEX_ALGORITHM_VERSION,
-  filterVersion: REPO_INDEX_FILTER_VERSION,
-  materialLayoutVersion: REPO_INDEX_MATERIAL_LAYOUT_VERSION
-});
-function repoIndexProvenanceToken(provenance = CURRENT_REPO_INDEX_PROVENANCE) {
-  const resolved = provenance && typeof provenance === "object" ? provenance : {};
-  return `a${resolved.algorithmVersion}-f${resolved.filterVersion}-l${resolved.materialLayoutVersion}`;
-}
-var CURRENT_REPO_INDEX_PROVENANCE_TOKEN = repoIndexProvenanceToken(CURRENT_REPO_INDEX_PROVENANCE);
-var GENERATED_PROJECTION = Object.freeze([
-  // Host plugin packages: the assembled skills/hooks/scripts/bin payload and the copied host
-  // manifest directory. `packages/<host>-plugin/<file>` at the root stays admitted.
-  /^packages\/(?:claude|codex|kimi|cursor|hermes)-plugin\/(?:skills|hooks|scripts|bin)\//,
-  /^packages\/(?:claude|codex|kimi|cursor|hermes)-plugin\/\.[A-Za-z0-9-]+-plugin\//,
-  // In-repo plugin roots assembled by the same declaration.
-  /^\.kilo-plugin\/(?:skills|scripts)\//,
-  /^\.pi-plugin\/(?:skills|scripts|extensions)\//,
-  // Release metadata regenerated from the tracked tree at every prepare.
-  /^distribution-bom\.json$/,
-  // Cross-repo generator outputs the estate audit named.
-  /^product\/connector\/generated\//,
-  /^packages\/jerv-pi\/generated\/roster\//,
-  /^docs\/\.release-inbox\//
-]);
-function isGeneratedRepoIndexProjection(value) {
-  return typeof value === "string" && GENERATED_PROJECTION.some((pattern) => pattern.test(value));
-}
-function isCanonicalRepoIndexPath(value) {
-  return isSafeRepoIndexPath(value) && !isGeneratedRepoIndexProjection(value);
-}
-function readRepoIndexProvenance(manifest) {
-  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) return null;
-  const provenance = manifest.indexProvenance;
-  if (provenance === void 0) return { ...LEGACY_REPO_INDEX_PROVENANCE };
-  if (!provenance || typeof provenance !== "object" || Array.isArray(provenance)) return null;
-  const keys = ["algorithmVersion", "filterVersion", "materialLayoutVersion"];
-  if (Object.keys(provenance).length !== keys.length) return null;
-  for (const key of keys) {
-    const value = provenance[key];
-    if (!Number.isInteger(value) || value < 1) return null;
-  }
-  return {
-    algorithmVersion: provenance.algorithmVersion,
-    filterVersion: provenance.filterVersion,
-    materialLayoutVersion: provenance.materialLayoutVersion
-  };
-}
-function isRepoIndexDeltaCompatible(manifest) {
-  const provenance = readRepoIndexProvenance(manifest);
-  return provenance !== null && provenance.algorithmVersion === REPO_INDEX_ALGORITHM_VERSION && provenance.filterVersion === REPO_INDEX_FILTER_VERSION && provenance.materialLayoutVersion === REPO_INDEX_MATERIAL_LAYOUT_VERSION;
-}
-
-// ../infra/repo-index-material-buckets.mjs
-var import_node_crypto = require("node:crypto");
-var REPO_INDEX_MATERIAL_BUCKET_COUNT = 2;
-var REPO_INDEX_MATERIAL_KINDS = Object.freeze(["chunks", "embeddings"]);
-var REPO_INDEX_MATERIAL_PREFIX = "material-v2";
-function canonicalMaterialJson(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(canonicalMaterialJson).join(",")}]`;
-  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalMaterialJson(value[key])}`).join(",")}}`;
-}
-function repoIndexMaterialDigest(value) {
-  return (0, import_node_crypto.createHash)("sha256").update(canonicalMaterialJson(value)).digest("hex");
-}
-function normalizeRepoIndexMaterialPath(path) {
-  return String(path).replace(/^\.\//, "").normalize("NFC");
-}
-function repoIndexMaterialBucket(path) {
-  const hash = (0, import_node_crypto.createHash)("sha256").update(normalizeRepoIndexMaterialPath(path), "utf8").digest();
-  return hash.readUInt32BE(0) % REPO_INDEX_MATERIAL_BUCKET_COUNT;
-}
-function compareRepoIndexChunks(a, b) {
-  const aPath = String(a?.path ?? "");
-  const bPath = String(b?.path ?? "");
-  if (aPath !== bPath) return aPath < bPath ? -1 : 1;
-  const aLine = Number(a?.citations?.[0]?.startLine ?? 0);
-  const bLine = Number(b?.citations?.[0]?.startLine ?? 0);
-  if (aLine !== bLine) return aLine - bLine;
-  const aId = String(a?.id ?? "");
-  const bId = String(b?.id ?? "");
-  return aId === bId ? 0 : aId < bId ? -1 : 1;
-}
-function compareRepoIndexEmbeddings(a, b) {
-  const aId = String(a?.chunkId ?? "");
-  const bId = String(b?.chunkId ?? "");
-  return aId === bId ? 0 : aId < bId ? -1 : 1;
-}
-function stripRepoIndexChunkCommit(chunk) {
-  const citations = Array.isArray(chunk?.citations) ? chunk.citations : [];
-  return {
-    ...chunk,
-    citations: citations.map((citation2) => {
-      const rest = { ...citation2 };
-      delete rest.commit;
-      return rest;
-    })
-  };
-}
-function repoIndexMaterialIndexKey(repoBase, digest) {
-  return `${repoBase}/${REPO_INDEX_MATERIAL_PREFIX}/index/${digest}.json`;
-}
-function repoIndexMaterialIndexUri(repo, digest) {
-  return `s3://${repoIndexMaterialIndexKey(`repo-index/v4/${repo}`, digest)}`;
-}
-function repoIndexMaterialBucketBody(kind, bucket, records) {
-  return { schemaVersion: 4, materialLayoutVersion: 2, kind, bucket, bucketCount: REPO_INDEX_MATERIAL_BUCKET_COUNT, count: records.length, records };
-}
-var bucketBody = repoIndexMaterialBucketBody;
-function buildRepoIndexMaterialLayout(repo, chunks, embeddings) {
-  const chunkList = Array.isArray(chunks) ? chunks : [];
-  const embeddingList = Array.isArray(embeddings) ? embeddings : [];
-  const pathByChunkId = new Map(chunkList.map((chunk) => [String(chunk?.id), String(chunk?.path)]));
-  const grouped = /* @__PURE__ */ new Map();
-  for (const kind of REPO_INDEX_MATERIAL_KINDS) {
-    for (let bucket = 0; bucket < REPO_INDEX_MATERIAL_BUCKET_COUNT; bucket++) grouped.set(`${kind}:${bucket}`, []);
-  }
-  for (const chunk of chunkList) {
-    grouped.get(`chunks:${repoIndexMaterialBucket(chunk?.path)}`).push(stripRepoIndexChunkCommit(chunk));
-  }
-  for (const embedding of embeddingList) {
-    const path = pathByChunkId.get(String(embedding?.chunkId));
-    if (path === void 0) throw new Error("repo-index material embeds a chunk that is not in the corpus");
-    grouped.get(`embeddings:${repoIndexMaterialBucket(path)}`).push(embedding);
-  }
-  const buckets = [];
-  for (const kind of REPO_INDEX_MATERIAL_KINDS) {
-    for (let bucket = 0; bucket < REPO_INDEX_MATERIAL_BUCKET_COUNT; bucket++) {
-      const records = grouped.get(`${kind}:${bucket}`);
-      records.sort(kind === "chunks" ? compareRepoIndexChunks : compareRepoIndexEmbeddings);
-      const body = bucketBody(kind, bucket, records);
-      buckets.push({ kind, bucket, count: records.length, digest: repoIndexMaterialDigest(body), body });
-    }
-  }
-  const index = {
-    schemaVersion: 4,
-    materialLayoutVersion: 2,
-    repo,
-    bucketCount: REPO_INDEX_MATERIAL_BUCKET_COUNT,
-    chunkCount: chunkList.length,
-    embeddingCount: embeddingList.length,
-    // Ordered descriptors: chunks buckets ascending, then embeddings buckets ascending.
-    buckets: buckets.map(({ kind, bucket, count, digest }) => ({ kind, bucket, count, digest }))
-  };
-  return { bucketCount: REPO_INDEX_MATERIAL_BUCKET_COUNT, buckets, index, indexDigest: repoIndexMaterialDigest(index) };
-}
-
-// src/doc-refs-core.ts
-var import_node_child_process = require("node:child_process");
-var CHECK_IGNORE_MAX_BUFFER = 32 * 1024 * 1024;
-function defaultIsIgnored(root, relPaths, exec = import_node_child_process.execFileSync) {
-  const inRepo = relPaths.filter((p) => !p.startsWith(".."));
-  if (inRepo.length === 0) return /* @__PURE__ */ new Set();
-  try {
-    const out = exec("git", ["check-ignore", "--stdin"], {
-      cwd: root,
-      input: inRepo.join("\n"),
-      encoding: "utf8",
-      maxBuffer: CHECK_IGNORE_MAX_BUFFER
-    });
-    return new Set(out.split(/\r?\n/).filter(Boolean));
-  } catch (error) {
-    if (error?.status === 1) return /* @__PURE__ */ new Set();
-    if (error?.status === 128) return /* @__PURE__ */ new Set();
-    if (error?.code === "ENOENT") return /* @__PURE__ */ new Set();
-    if (error?.code === "ENOBUFS") {
-      throw new Error(
-        `git check-ignore produced more than ${CHECK_IGNORE_MAX_BUFFER} bytes for ${inRepo.length} path(s) \u2014 the ignore set cannot be read, and treating it as empty would index gitignored paths (#4062)`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/repo-index.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_path2 = require("node:path");
-
-// src/repo-runtime-state.ts
-var import_node_crypto2 = require("node:crypto");
-var import_node_fs = require("node:fs");
-var import_node_os = require("node:os");
-var import_node_path = require("node:path");
-var RUNTIME_DIR = "mmi-runtime";
-function hashPath(path) {
-  return (0, import_node_crypto2.createHash)("sha256").update((0, import_node_path.resolve)(path)).digest("hex").slice(0, 16);
-}
-function resolveGitDir(cwd) {
-  const dotGit = (0, import_node_path.join)(cwd, ".git");
-  try {
-    const st = (0, import_node_fs.statSync)(dotGit);
-    if (st.isDirectory()) return dotGit;
-    if (!st.isFile()) return void 0;
-  } catch {
-    return void 0;
-  }
-  try {
-    const raw = (0, import_node_fs.readFileSync)(dotGit, "utf8").trim();
-    const match = /^gitdir:\s*(.+)$/i.exec(raw);
-    if (!match) return void 0;
-    const gitdir = match[1].trim();
-    return (0, import_node_path.isAbsolute)(gitdir) ? gitdir : (0, import_node_path.resolve)(cwd, gitdir);
-  } catch {
-    return void 0;
-  }
-}
-function repoRuntimeStatePath(cwd, ...parts) {
-  const gitDir = resolveGitDir(cwd);
-  if (gitDir && (0, import_node_fs.existsSync)(gitDir)) return (0, import_node_path.join)(gitDir, RUNTIME_DIR, ...parts);
-  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), "mmi-cli", hashPath(cwd), ...parts);
-}
-
-// src/repo-index.ts
-var INDEXABLE_EXT = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".go",
-  ".rs",
-  ".java",
-  ".kt",
-  ".md",
-  ".yml",
-  ".yaml",
-  ".json",
-  ".toml",
-  ".sh",
-  ".ps1",
-  ".css",
-  ".html"
-]);
-function isHardDeniedPath(relPosix) {
-  return isHardDeniedRepoIndexPath(relPosix);
-}
-function isIndexablePath(relPosix) {
-  if (!isSafeRepoIndexPath(relPosix)) return false;
-  if (relPosix.startsWith(".git/")) return false;
-  if (relPosix.includes("node_modules/")) return false;
-  if (relPosix.includes("dist/")) return false;
-  const dot = relPosix.lastIndexOf(".");
-  if (dot < 0) return false;
-  return INDEXABLE_EXT.has(relPosix.slice(dot).toLowerCase());
-}
-function toPosix(p) {
-  return p.split(import_node_path2.sep).join("/");
-}
-function listCandidatePaths(cwd, exec = import_node_child_process2.execFileSync) {
-  try {
-    const out = exec("git", ["ls-files", "-z", "-c", "-o", "--exclude-standard"], {
-      cwd,
-      encoding: "utf8",
-      maxBuffer: 64 * 1024 * 1024
-    });
-    return out.split("\0").filter(Boolean).map(toPosix);
-  } catch {
-    return [];
-  }
-}
-
-// src/repo-index-v4/language.ts
-var LANGUAGE_BY_EXTENSION = {
-  ".ts": { name: "typescript", parserName: "typescript" },
-  ".mts": { name: "typescript", parserName: "typescript" },
-  ".cts": { name: "typescript", parserName: "typescript" },
-  ".tsx": { name: "tsx", parserName: "tsx" },
-  ".js": { name: "javascript", parserName: "javascript" },
-  ".mjs": { name: "javascript", parserName: "javascript" },
-  ".cjs": { name: "javascript", parserName: "javascript" },
-  ".jsx": { name: "jsx", parserName: "javascript" },
-  ".py": { name: "python", parserName: "python" },
-  ".go": { name: "go", parserName: "go" },
-  ".rs": { name: "rust", parserName: "rust" },
-  ".java": { name: "java", parserName: "java" },
-  ".kt": { name: "kotlin", parserName: "kotlin" }
-};
-function languageForPath(path) {
-  const dot = path.lastIndexOf(".");
-  return dot < 0 ? void 0 : LANGUAGE_BY_EXTENSION[path.slice(dot).toLowerCase()];
-}
-
-// src/repo-index-v4/chunks.ts
-var BLURB_CAP = 200;
-var SIGNATURE_CAP = 300;
-var STRUCTURAL_KINDS = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function_definition",
-  "function_item",
-  "function",
-  "method_declaration",
-  "method_definition",
-  "method",
-  "class_declaration",
-  "class_definition",
-  "class",
-  "interface_declaration",
-  "interface_definition",
-  "enum_declaration",
-  "enum_definition",
-  "enum_item",
-  "struct_item",
-  "struct_specifier",
-  "trait_item",
-  "impl_item",
-  "type_declaration",
-  "type_alias_declaration",
-  "object_declaration"
-]);
-var parserRuntime;
-var grammarCache = /* @__PURE__ */ new Map();
-async function parserFor(language) {
-  const api = await (parserRuntime ??= import("web-tree-sitter"));
-  await api.Parser.init();
-  let grammar = grammarCache.get(language);
-  if (!grammar) {
-    grammar = import("tree-sitter-wasm").then(({ getWasmPath }) => api.Language.load(getWasmPath(language)));
-    grammarCache.set(language, grammar);
-  }
-  const parser = new api.Parser();
-  parser.setLanguage(await grammar);
-  return parser;
-}
-function sha256(value) {
-  return (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
-}
-function pointerId(path, kind, contentHash, start, end, symbol) {
-  return sha256(["repo-index-v4", path, kind, contentHash, String(start), String(end), symbol ?? ""].join("\0"));
-}
-function lineAt(bytes, offset) {
-  let line = 1;
-  for (let i = 0; i < Math.min(offset, bytes.length); i++) if (bytes[i] === 10) line++;
-  return line;
-}
-function lineRange(bytes, start, end) {
-  const startLine = lineAt(bytes, start);
-  const endLine = lineAt(bytes, Math.max(start, end - 1));
-  return { startLine, endLine: Math.max(startLine, endLine) };
-}
-function boundedLine(value, cap) {
-  const line = value?.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim();
-  return line ? line.slice(0, cap) : void 0;
-}
-function citation(repo, commit, path, bytes, start, end, symbol) {
-  return { repo, commit, path, ...lineRange(bytes, start, end), ...symbol ? { symbol } : {} };
-}
-function doclineBefore(bytes, start) {
-  const prior2 = Buffer.from(bytes.subarray(0, start)).toString("utf8").split(/\r?\n/);
-  for (let i = prior2.length - 1; i >= 0; i--) {
-    const line = prior2[i].trim();
-    if (!line) continue;
-    const text = line.replace(/^(?:\/\/\/|\/\/|#|\/\*\*?|\*)\s?/, "").replace(/\*\/$/, "").trim();
-    return text === line ? void 0 : boundedLine(text, BLURB_CAP);
-  }
-  return void 0;
-}
-function fileChunk(repo, commit, path, source, language) {
-  const bytes = Buffer.from(source, "utf8");
-  const contentHash = sha256(bytes);
-  return {
-    id: pointerId(path, "file", contentHash, 0, bytes.length),
-    path,
-    kind: "file",
-    contentHash,
-    ...language ? { language } : {},
-    citations: [citation(repo, commit, path, bytes, 0, bytes.length)]
-  };
-}
-function structuralNode(node) {
-  if (STRUCTURAL_KINDS.has(node.type)) return node;
-  return node.namedChildren.find((child) => STRUCTURAL_KINDS.has(child.type));
-}
-function structureChunk(repo, commit, path, sourceBytes, language, owner) {
-  const item = structuralNode(owner);
-  if (!item) return void 0;
-  const start = owner.startIndex;
-  const end = owner.endIndex;
-  if (start < 0 || end < start || end > sourceBytes.length) return void 0;
-  const contentHash = sha256(sourceBytes.subarray(start, end));
-  const name = boundedLine(item.childForFieldName("name")?.text, SIGNATURE_CAP);
-  const bodyStart = item.childForFieldName("body")?.startIndex ?? end;
-  const symbol = boundedLine(Buffer.from(sourceBytes.subarray(start, bodyStart)).toString("utf8"), SIGNATURE_CAP) ?? name;
-  return {
-    id: pointerId(path, "symbol", contentHash, start, end, symbol),
-    path,
-    kind: "symbol",
-    contentHash,
-    language,
-    ...symbol ? { symbol } : {},
-    ...doclineBefore(sourceBytes, start) ? { blurb: doclineBefore(sourceBytes, start) } : {},
-    citations: [citation(repo, commit, path, sourceBytes, start, end, name)]
-  };
-}
-async function structuralChunksForSource(repo, commit, path, source) {
-  const language = languageForPath(path);
-  if (!language) return [fileChunk(repo, commit, path, source)];
-  let parser;
-  let tree;
-  try {
-    parser = await parserFor(language.parserName);
-    tree = parser.parse(source) ?? void 0;
-    if (!tree || tree.rootNode.hasError) return [fileChunk(repo, commit, path, source, language.name)];
-    const bytes = Buffer.from(source, "utf8");
-    const chunks = tree.rootNode.namedChildren.map((node) => structureChunk(repo, commit, path, bytes, language.name, node)).filter((chunk) => chunk !== void 0).sort((a, b) => a.citations[0].startLine - b.citations[0].startLine || a.id.localeCompare(b.id));
-    return chunks.length ? chunks : [fileChunk(repo, commit, path, source, language.name)];
-  } catch {
-    return [fileChunk(repo, commit, path, source, language.name)];
-  } finally {
-    tree?.delete();
-    parser?.delete();
-  }
-}
-function canonicalRepoIndexPaths(cwd) {
-  const candidates = listCandidatePaths(cwd).filter(isIndexablePath).sort((a, b) => a.localeCompare(b));
-  const ignored = defaultIsIgnored(cwd, candidates);
-  return candidates.filter((path) => !ignored.has(path) && !isHardDeniedPath(path) && isCanonicalRepoIndexPath(path));
-}
-function compareV4Chunks(a, b) {
-  return compareRepoIndexChunks(a, b);
-}
-async function buildStructuralChunksForPaths(cwd, repo, commit, paths) {
-  const chunks = [];
-  for (const path of paths) {
-    const absolute = (0, import_node_path3.join)(cwd, ...path.split("/"));
-    if (!(0, import_node_fs2.existsSync)(absolute)) continue;
-    let source;
-    try {
-      source = (0, import_node_fs2.readFileSync)(absolute, "utf8");
-    } catch {
-      continue;
-    }
-    chunks.push(...await structuralChunksForSource(repo, commit, path, source));
-  }
-  return chunks.sort(compareV4Chunks);
-}
-async function buildStructuralChunks(cwd, repo, commit) {
-  return buildStructuralChunksForPaths(cwd, repo, commit, canonicalRepoIndexPaths(cwd));
-}
-
-// src/repo-index-v4/types.ts
-var REPO_INDEX_V4_SCHEMA = 4;
-
-// src/repo-index-v4/builder.ts
-var import_node_crypto4 = require("node:crypto");
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs3 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path4 = require("node:path");
-
-// src/repo-index-v4/delta.ts
-var import_node_child_process3 = require("node:child_process");
-var COMMIT = /^[a-f0-9]{40}$/;
-var V4_DELTA_DEEPEN_STEPS = [50, 250, 1e3];
-function gitRunner(cwd) {
-  return (args) => {
-    const result = (0, import_node_child_process3.spawnSync)("git", [...args], { cwd, encoding: "utf8", windowsHide: true, maxBuffer: 64 * 1024 * 1024 });
-    if (result.error) return { status: -1, stdout: "" };
-    return { status: typeof result.status === "number" ? result.status : -1, stdout: String(result.stdout ?? "") };
-  };
-}
-function parseNameStatusZ(output) {
-  const fields = output.split("\0");
-  if (fields.length && fields[fields.length - 1] === "") fields.pop();
-  const changes = [];
-  for (let i = 0; i < fields.length; ) {
-    const raw = fields[i++] ?? "";
-    const letter = raw[0];
-    if (!letter || !/^[AMDTRC]\d*$/.test(raw)) return null;
-    if (letter === "R" || letter === "C") {
-      const oldPath = fields[i++];
-      const path2 = fields[i++];
-      if (!oldPath || !path2) return null;
-      changes.push(letter === "C" ? { status: "A", path: path2 } : { status: "R", path: path2, oldPath });
-      continue;
-    }
-    const path = fields[i++];
-    if (!path) return null;
-    changes.push({ status: letter, path });
-  }
-  return changes;
-}
-function changedPaths(changes) {
-  return [...new Set(changes.filter((change) => change.status !== "D").map((change) => change.path))].sort();
-}
-function removedPaths(changes) {
-  const removed = changes.flatMap((change) => change.status === "D" ? [change.path] : change.status === "R" && change.oldPath ? [change.oldPath] : []);
-  return [...new Set(removed)].sort();
-}
-function commitPresent(git2, commit) {
-  return git2(["cat-file", "-e", `${commit}^{commit}`]).status === 0;
-}
-function isAncestor(git2, base, head) {
-  return git2(["merge-base", "--is-ancestor", base, head]).status === 0;
-}
-function planRepoIndexV4Delta(opts) {
-  const headCommit = opts.headCommit.toLowerCase();
-  const baseCommit = opts.baseCommit ? opts.baseCommit.toLowerCase() : null;
-  const full = (fallbackReason) => ({ mode: "full", headCommit, fallbackReason, ...baseCommit ? { baseCommit } : {} });
-  if (opts.forceFull) return full("explicit-full-rebuild");
-  if (!baseCommit || !COMMIT.test(baseCommit)) return full("no-active-authority");
-  if (baseCommit === headCommit) return { mode: "unchanged", baseCommit, headCommit };
-  if (opts.basePipelineCompatible === false) return full("incompatible-base-provenance");
-  if (opts.hasPriorMaterial === false) return full("no-prior-material");
-  const { git: git2 } = opts;
-  let usable = commitPresent(git2, baseCommit) && isAncestor(git2, baseCommit, headCommit);
-  for (const depth of V4_DELTA_DEEPEN_STEPS) {
-    if (usable || !opts.deepen) break;
-    try {
-      opts.deepen(depth);
-    } catch {
-      break;
-    }
-    usable = commitPresent(git2, baseCommit) && isAncestor(git2, baseCommit, headCommit);
-  }
-  if (!usable) {
-    return full(commitPresent(git2, baseCommit) ? "base-not-ancestor" : "base-commit-unavailable");
-  }
-  const diff = git2(["diff", "--name-status", "-z", "--find-renames", baseCommit, headCommit]);
-  if (diff.status !== 0) return full("diff-unreadable");
-  const changes = parseNameStatusZ(diff.stdout);
-  if (!changes) return full("unsupported-change-status");
-  return { mode: "delta", baseCommit, headCommit, changes };
-}
-
-// src/repo-index-v4/builder.ts
-var V4_MAX_CHUNKS = 1e4;
-var V4_MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
-var V4_EMBED_BATCH = 32;
-var V4_VECTOR_DECIMAL_PLACES = 6;
-var COMMIT2 = /^[a-f0-9]{40}$/;
-function canonicalJson(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  const record = value;
-  return `{${Object.keys(record).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(record[k])}`).join(",")}}`;
-}
-function sha2562(value) {
-  return (0, import_node_crypto4.createHash)("sha256").update(canonicalJson(value)).digest("hex");
-}
-function quantizeV4Vector(vector) {
-  return vector.map((value) => Number(value.toFixed(V4_VECTOR_DECIMAL_PLACES)));
-}
-function statePath(cwd) {
-  return repoRuntimeStatePath(cwd, "repo-index", "v4.json");
-}
-function git(cwd, args) {
-  return String((0, import_node_child_process4.execFileSync)("git", args, { cwd, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"] })).trim();
-}
-function gitInfo(cwd) {
-  const commit = git(cwd, ["rev-parse", "HEAD"]).toLowerCase();
-  if (!COMMIT2.test(commit)) throw new Error("repo-index v4 requires an exact git HEAD commit");
-  let defaultBranch = "main";
-  try {
-    defaultBranch = git(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]).replace(/^origin\//, "") || defaultBranch;
-  } catch {
-  }
-  let createdAt;
-  try {
-    createdAt = new Date(git(cwd, ["show", "-s", "--format=%cI", "HEAD"])).toISOString();
-  } catch {
-    createdAt = "1970-01-01T00:00:00.000Z";
-  }
-  return { commit, defaultBranch, createdAt };
-}
-function prior(cwd) {
-  try {
-    const p = JSON.parse((0, import_node_fs3.readFileSync)(statePath(cwd), "utf8"));
-    return p?.schemaVersion === 4 && p?.manifest?.immutable === true ? p : null;
-  } catch {
-    return null;
-  }
-}
-function repoIndexV4DeltaBase(envelope) {
-  return envelope && isRepoIndexDeltaCompatible(envelope.manifest) ? envelope : null;
-}
-function tombstone(repo, commit, path, createdAt) {
-  const base = { repo, commit, path, reason: "deleted", createdAt };
-  return { ...base, id: sha2562(base) };
-}
-function embeddingInput(cwd, chunk) {
-  const c = chunk.citations[0];
-  if (!c) return `${chunk.path}
-${chunk.symbol ?? ""}
-${chunk.blurb ?? ""}`;
-  try {
-    const lines = (0, import_node_fs3.readFileSync)((0, import_node_path4.join)(cwd, ...chunk.path.split("/")), "utf8").split(/\r?\n/);
-    const body = lines.slice(Math.max(0, (c.startLine ?? 1) - 1), Math.min(lines.length, c.endLine ?? lines.length)).join("\n");
-    return body.slice(0, 1e5);
-  } catch {
-    return `${chunk.path}
-${chunk.symbol ?? ""}
-${chunk.blurb ?? ""}`;
-  }
-}
-var V4_EMBED_TIMEOUT_MS = 15 * 6e4;
-var V4_EMBED_RETRY = 1;
-function runEmbedderOnce(cwd, chunks, modelDirectory, createdAt) {
-  if (!chunks.length) return { ok: true, embeddings: [] };
-  const orchestratorRunner = (0, import_node_path4.join)(process.cwd(), "repo-indexer", "src", "batch.mjs");
-  const targetRunner = (0, import_node_path4.join)(cwd, "repo-indexer", "src", "batch.mjs");
-  const file = (0, import_node_fs3.existsSync)(orchestratorRunner) ? orchestratorRunner : targetRunner;
-  if (!(0, import_node_fs3.existsSync)(file)) return { ok: false, reason: "embeddings-unavailable" };
-  const request = { texts: chunks.map((chunk) => ({ id: chunk.id, text: embeddingInput(cwd, chunk) })), maxBatch: V4_EMBED_BATCH };
-  const env = { ...process.env, ...modelDirectory ? { MMI_REPO_INDEXER_MODEL_DIR: modelDirectory } : {} };
-  const requestDir = (0, import_node_fs3.mkdtempSync)((0, import_node_path4.join)((0, import_node_os2.tmpdir)(), "mmi-repo-index-req-"));
-  const requestFile = (0, import_node_path4.join)(requestDir, "request.json");
-  (0, import_node_fs3.writeFileSync)(requestFile, JSON.stringify(request));
-  let result;
-  try {
-    result = (0, import_node_child_process4.spawnSync)(process.execPath, [file, requestFile], { encoding: "utf8", windowsHide: true, timeout: V4_EMBED_TIMEOUT_MS, maxBuffer: V4_MAX_ARTIFACT_BYTES, env });
-  } finally {
-    (0, import_node_fs3.rmSync)(requestDir, { recursive: true, force: true });
-  }
-  if (result.error || result.status !== 0) {
-    const cleanExit = result.error === void 0 && result.signal === void 0 && typeof result.status === "number" && result.status !== 0;
-    const stdout = String(result.stdout).trim();
-    const stderrTail = String(result.stderr).trim().slice(-400) || void 0;
-    let code;
-    if (cleanExit) {
-      try {
-        code = JSON.parse(stdout)?.code;
-      } catch {
-      }
-    }
-    return {
-      ok: false,
-      code,
-      stdoutTail: code ? void 0 : stdout.slice(-400) || void 0,
-      stderrTail,
-      cleanExit,
-      detail: result.error?.message ?? result.signal ?? `exit status ${result.status ?? "unknown"}`
-    };
-  }
-  try {
-    const response = JSON.parse(String(result.stdout));
-    if (!response.ok || !response.provenance || !Array.isArray(response.embeddings)) return { ok: false, reason: "embeddings-unavailable" };
-    const provenance = {
-      provider: response.provenance.provider,
-      model: response.provenance.model,
-      modelDigest: response.provenance.modelDigest,
-      dimensions: response.provenance.dimensions,
-      input: response.provenance.input,
-      createdAt
-    };
-    const byId = new Map(response.embeddings.map((e) => [e.id, e.vector]));
-    const embeddings = chunks.map((chunk) => ({ chunkId: chunk.id, vector: byId.get(chunk.id), provenance })).filter((e) => Array.isArray(e.vector) && e.vector.length === provenance.dimensions && e.vector.every(Number.isFinite));
-    return embeddings.length === chunks.length ? { ok: true, embeddings } : { ok: false, reason: "partial-coverage" };
-  } catch {
-    return { ok: false, reason: "embeddings-unavailable" };
-  }
-}
-function runEmbedder(cwd, chunks, modelDirectory, createdAt) {
-  if (!chunks.length) return { embeddings: [] };
-  let last;
-  for (let attempt = 1; attempt <= V4_EMBED_RETRY + 1; attempt++) {
-    last = runEmbedderOnce(cwd, chunks, modelDirectory, createdAt);
-    if (last.ok) return { embeddings: last.embeddings, reason: last.reason };
-    if (attempt > V4_EMBED_RETRY || last.cleanExit !== true) break;
-  }
-  const runner = last;
-  const code = runner.code ? ` code=${runner.code}` : "";
-  const stdout = runner.stdoutTail ? ` stdout=${runner.stdoutTail}` : "";
-  const stderr = runner.stderrTail ? ` stderr=${runner.stderrTail}` : "";
-  throw new Error(`repo-index v4 embedding runner failed: ${runner.detail ?? "unknown"}${code}${stdout}${stderr}`);
-}
-function restampCitations(chunk, repo, commit) {
-  return { ...chunk, citations: chunk.citations.map((citation2) => ({ ...citation2, repo, commit })) };
-}
-async function buildRepoIndexV4(cwd, repo, opts = {}) {
-  return (await buildRepoIndexV4Detailed(cwd, repo, opts)).envelope;
-}
-async function buildRepoIndexV4Detailed(cwd, repo, opts = {}) {
-  const { commit, defaultBranch, createdAt } = gitInfo(cwd);
-  const delta = opts.delta;
-  const old = prior(cwd);
-  const deltaBase = repoIndexV4DeltaBase(old);
-  let chunks;
-  let carried = 0;
-  let built = 0;
-  let changedCount = 0;
-  let removedCount = 0;
-  if (delta) {
-    const admitted = new Set(canonicalRepoIndexPaths(cwd));
-    const changed = new Set(changedPaths(delta.changes));
-    const removed = new Set(removedPaths(delta.changes));
-    changedCount = changed.size;
-    removedCount = removed.size;
-    const rebuilt = await buildStructuralChunksForPaths(cwd, repo, commit, [...changed].filter((path2) => admitted.has(path2)).sort());
-    const kept = delta.prior.chunks.filter((chunk) => !changed.has(chunk.path) && !removed.has(chunk.path) && admitted.has(chunk.path)).map((chunk) => restampCitations(chunk, repo, commit));
-    carried = kept.length;
-    built = rebuilt.length;
-    chunks = [...kept, ...rebuilt].sort(compareV4Chunks);
-  } else {
-    chunks = await buildStructuralChunks(cwd, repo, commit);
-    built = chunks.length;
-  }
-  if (chunks.length > V4_MAX_CHUNKS) throw new Error(`repo-index v4 exceeds ${V4_MAX_CHUNKS} chunk ceiling`);
-  const currentPaths = new Set(chunks.map((c) => c.path));
-  const priorChunks = delta ? delta.prior.chunks : old?.manifest.chunks ?? [];
-  const priorTombstones = delta ? delta.prior.tombstones ?? [] : old?.manifest.tombstones ?? [];
-  const tombstonePaths = [
-    ...priorTombstones.map((t) => t.path),
-    ...priorChunks.map((c) => c.path).filter((path2) => !currentPaths.has(path2))
-  ];
-  const tombstones = [...new Set(tombstonePaths)].sort().map((path2) => tombstone(repo, commit, path2, createdAt));
-  const embeddingSource = delta ? delta.prior : { chunks: deltaBase?.manifest.chunks ?? [], embeddings: deltaBase?.manifest.embeddings ?? [] };
-  const oldChunkHashById = new Map(embeddingSource.chunks.map((c) => [c.id, c.contentHash]));
-  const reusableEmbedding = (embedding) => {
-    const norm = Math.hypot(...embedding.vector);
-    return embedding.vector.length === 384 && embedding.vector.every(Number.isFinite) && norm >= 0.98 && norm <= 1.02 && embedding.provenance.provider === "local" && embedding.provenance.modelDigest === "828e1496d7fabb79cfa4dcd84fa38625c0d3d21da474a00f08db0f559940cf35" && embedding.provenance.dimensions === 384 && embedding.provenance.input === "pointer-safe-structural-chunk";
-  };
-  const oldEmbeddingByHash = new Map(embeddingSource.embeddings.filter(reusableEmbedding).map((e) => [oldChunkHashById.get(e.chunkId), e]));
-  const reusable = chunks.flatMap((chunk) => {
-    const priorEmbedding = oldEmbeddingByHash.get(chunk.contentHash);
-    return priorEmbedding ? [{ ...priorEmbedding, chunkId: chunk.id }] : [];
-  });
-  const reusableIds = new Set(reusable.map((e) => e.chunkId));
-  const missing = chunks.filter((chunk) => !reusableIds.has(chunk.id));
-  const generated = missing.length === 0 ? { embeddings: [] } : opts.embed === false ? { embeddings: [], reason: "embeddings-unavailable" } : runEmbedder(cwd, missing, opts.modelDirectory, createdAt);
-  const embeddings = [...reusable, ...generated.embeddings].map((embedding) => ({ ...embedding, vector: quantizeV4Vector(embedding.vector) })).sort(compareRepoIndexEmbeddings);
-  const materialIndexDigest = buildRepoIndexMaterialLayout(repo, chunks, embeddings).indexDigest;
-  const artifact = (kind, digest, uri) => {
-    const identity2 = { repo, commit, immutable: true, kind, uri, sha256: digest, createdAt };
-    return { ...identity2, id: sha2562(identity2) };
-  };
-  const artifacts = [artifact("material-index", materialIndexDigest, repoIndexMaterialIndexUri(repo, materialIndexDigest))];
-  const grammarProvenance = {
-    runtime: { name: "web-tree-sitter", version: "0.26.12", license: "MIT" },
-    grammarPack: { name: "tree-sitter-wasm", version: "1.1.4", license: "MIT", digest: "f3089ddf2c9615a423783b645c4dfb23ccda30807bbd059746f583952357c489" },
-    languages: ["go", "java", "javascript", "jsx", "kotlin", "python", "rust", "tsx", "typescript"]
-  };
-  const rrf = { algorithm: "reciprocal-rank-fusion", k: 60, lexicalWeight: 1, semanticWeight: 1 };
-  const indexProvenance = { ...CURRENT_REPO_INDEX_PROVENANCE };
-  const identity = { repo, commit, defaultBranch, immutable: true, ...delta ? { parentCommit: delta.baseCommit } : {}, createdAt, grammarProvenance, indexProvenance, chunks, embeddings, artifacts, tombstones, rrf };
-  const manifest = { ...identity, id: sha2562(identity) };
-  const complete = embeddings.length === chunks.length;
-  const envelope = {
-    schemaVersion: 4,
-    manifest,
-    status: { repo, commit, state: complete ? "ready" : "degraded", updatedAt: createdAt, ...!complete ? { degradedReasons: [generated.reason === "partial-coverage" ? "partial-coverage" : "embeddings-unavailable"] } : {} }
-  };
-  const encoded = canonicalJson(envelope);
-  if (Buffer.byteLength(encoded) > V4_MAX_ARTIFACT_BYTES) throw new Error(`repo-index v4 artifact exceeds ${V4_MAX_ARTIFACT_BYTES} byte ceiling`);
-  const path = statePath(cwd);
-  (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)(path), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(path, `${JSON.stringify(envelope, null, 2)}
-`, "utf8");
-  const metrics = {
-    mode: delta ? "delta" : "full",
-    ...delta ? { baseCommit: delta.baseCommit } : {},
-    changedPaths: changedCount,
-    removedPaths: removedCount,
-    chunksTotal: chunks.length,
-    chunksCarried: carried,
-    chunksBuilt: built,
-    embeddingsReused: reusable.length,
-    embeddingsEmbedded: generated.embeddings.length,
-    tombstones: tombstones.length
-  };
-  return { envelope, metrics };
-}
-function formatV4BuildMetrics(repo, metrics) {
-  const base = metrics.baseCommit ? ` base=${metrics.baseCommit.slice(0, 12)}` : "";
-  return `${repo}: ${metrics.mode}${base} changed=${metrics.changedPaths} removed=${metrics.removedPaths} chunks=${metrics.chunksTotal} (carried=${metrics.chunksCarried} built=${metrics.chunksBuilt}) embeddings(reused=${metrics.embeddingsReused} new=${metrics.embeddingsEmbedded}) tombstones=${metrics.tombstones}`;
-}
-function repoIndexV4StorePath(cwd) {
-  return statePath(cwd);
-}
-
-// src/repo-index-v4/shards.ts
-var V4_STAGE_MAX_BODY_BYTES = 750 * 1024;
-var V4_STAGE_MAX_RECORDS = 256;
-var V4_STAGE_MAX_SHARDS = 128;
-function encodedBytes(value) {
-  return Buffer.byteLength(JSON.stringify(value));
-}
-function split(kind, records, manifest, bucket) {
-  const groups = [];
-  let group = [];
-  for (const record of records) {
-    const next = [...group, record];
-    const probe = { repo: manifest.repo, commit: manifest.commit, manifestId: manifest.id, kind, ...bucket === void 0 ? {} : { bucket }, index: 127, total: 128, digest: "0".repeat(64), records: next };
-    if (group.length && (group.length >= V4_STAGE_MAX_RECORDS || encodedBytes(probe) > V4_STAGE_MAX_BODY_BYTES)) {
-      groups.push(group);
-      group = [record];
-    } else {
-      group = next;
-    }
-  }
-  if (group.length || records.length === 0) groups.push(group);
-  if (groups.length > V4_STAGE_MAX_SHARDS) throw new Error(`repo-index v4 ${kind} requires ${groups.length} shards (max ${V4_STAGE_MAX_SHARDS})`);
-  return groups.map((items, index) => {
-    const request = {
-      repo: manifest.repo,
-      commit: manifest.commit,
-      manifestId: manifest.id,
-      kind,
-      ...bucket === void 0 ? {} : { bucket },
-      index,
-      total: groups.length,
-      digest: sha2562(items),
-      records: items
-    };
-    if (encodedBytes(request) > V4_STAGE_MAX_BODY_BYTES) throw new Error(`repo-index v4 ${kind} shard ${index} exceeds ${V4_STAGE_MAX_BODY_BYTES} bytes`);
-    return request;
-  });
-}
-function shardRepoIndexV4(envelope, opts = {}) {
-  const { chunks, embeddings, ...header } = envelope.manifest;
-  const identity = { repo: header.repo, commit: header.commit, manifestId: header.id, header, status: envelope.status };
-  if ((header.indexProvenance?.materialLayoutVersion ?? 1) < 2) {
-    const stages2 = [...split("chunks", chunks, envelope.manifest), ...split("embeddings", embeddings ?? [], envelope.manifest)];
-    const shards2 = stages2.map(({ kind, index, total, digest, records }) => ({ kind, index, total, digest, count: records.length }));
-    return { stages: stages2, finalize: { ...identity, shards: shards2 } };
-  }
-  const reusable = new Set(opts.priorBucketDigests ?? []);
-  const layout = buildRepoIndexMaterialLayout(header.repo, chunks, embeddings ?? []);
-  const stages = [];
-  const shards = [];
-  const buckets = layout.buckets.map((bucket) => {
-    if (reusable.has(bucket.digest)) return { kind: bucket.kind, bucket: bucket.bucket, count: bucket.count, digest: bucket.digest, shards: 0 };
-    const fragments = split(bucket.kind, bucket.body.records, envelope.manifest, bucket.bucket);
-    stages.push(...fragments);
-    shards.push(...fragments.map(({ kind, index, total, digest, records }) => ({ kind, bucket: bucket.bucket, index, total, digest, count: records.length })));
-    return { kind: bucket.kind, bucket: bucket.bucket, count: bucket.count, digest: bucket.digest, shards: fragments.length };
-  });
-  if (buckets.length !== 2 * REPO_INDEX_MATERIAL_BUCKET_COUNT) throw new Error("repo-index v4 material layout is incomplete");
-  return { stages, finalize: { ...identity, shards, materialLayout: 2, buckets } };
-}
-function encodedStageBytes(stage) {
-  return encodedBytes(stage);
-}
-
-// src/repo-index-v4/edges.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path5 = require("node:path");
-var V4_GRAPH_MAX_EDGES = 5e3;
-var V4_GRAPH_MAX_EDGES_PER_FILE = 64;
-var SUPPORTED = /* @__PURE__ */ new Map([
-  [".js", "javascript"],
-  [".jsx", "javascript"],
-  [".mjs", "javascript"],
-  [".cjs", "javascript"],
-  [".ts", "typescript"],
-  [".tsx", "typescript"],
-  [".py", "python"],
-  [".go", "go"],
-  [".rs", "rust"],
-  [".cs", "csharp"],
-  [".md", "resource"],
-  [".json", "resource"],
-  [".yaml", "resource"],
-  [".yml", "resource"]
-]);
-function extension(path) {
-  const index = path.lastIndexOf(".");
-  return index < 0 ? "" : path.slice(index).toLowerCase();
-}
-function lineAt2(source, offset) {
-  return source.slice(0, offset).split(/\r?\n/).length;
-}
-function normalizedRepo(value) {
-  return value.toLowerCase().replace(/^https?:\/\/github\.com\//, "").replace(/\.git(?:[#/?].*)?$/, "").replace(/[?#].*$/, "");
-}
-function targetRepo(specifier, roster) {
-  const direct = normalizedRepo(specifier).match(/(?:^|\/)mutmutco\/([a-z0-9._-]+)/)?.[1];
-  if (direct && roster.has(`mutmutco/${direct}`)) return `mutmutco/${direct}`;
-  const scoped = specifier.toLowerCase().match(/^@mutmutco\/([a-z0-9._-]+)/)?.[1];
-  if (scoped && roster.has(`mutmutco/${scoped}`)) return `mutmutco/${scoped}`;
-  const crate = specifier.toLowerCase().replace(/_/g, "-");
-  return roster.has(`mutmutco/${crate}`) ? `mutmutco/${crate}` : void 0;
-}
-function candidate(base) {
-  return { ...base, id: sha2562(base) };
-}
-function graphEdgesForSource(repo, commit, path, source, rosterRepos) {
-  const language = SUPPORTED.get(extension(path));
-  if (!language) return [];
-  const roster = new Set(rosterRepos.map((value) => value.toLowerCase()));
-  roster.delete(repo.toLowerCase());
-  const edges = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (kind, offset, target, confidence, rule, symbol) => {
-    const targetName = targetRepo(target, roster);
-    if (!targetName) return;
-    const base = { kind, confidence, source: { repo, commit, path, line: lineAt2(source, offset), ...symbol ? { symbol } : {} }, target: { repo: targetName, ...symbol ? { symbol } : {} }, resolver: { name: "repo-index-v4-static", version: 1, language, rule } };
-    const edge = candidate(base);
-    if (!seen.has(edge.id) && edges.length < V4_GRAPH_MAX_EDGES_PER_FILE) {
-      seen.add(edge.id);
-      edges.push(edge);
-    }
-  };
-  const imports = [];
-  const patterns = [
-    /\bimport\s+(?:\{?\s*([A-Za-z_$][\w$]*)[^'";]*?\s+from\s+)?['"]([^'"]+)['"]/g,
-    /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g,
-    /\bfrom\s+([A-Za-z0-9_.\/-]+)\s+import\s+([A-Za-z_]\w*)/g,
-    /\b(?:use|extern\s+crate)\s+([A-Za-z0-9_:\/-]+)/g,
-    /\bimport\s+"([^"]+)"/g,
-    /<ProjectReference\b[^>]*Include=["']([^"']+)["']/gi
-  ];
-  for (const pattern of patterns) for (const match of source.matchAll(pattern)) {
-    const values = match.slice(1).filter((value) => !!value);
-    const target = values.find((value) => targetRepo(value, roster));
-    if (!target || match.index === void 0) continue;
-    const binding = values.find((value) => value !== target && /^[A-Za-z_$][\w$]*$/.test(value));
-    imports.push({ binding, target });
-    push("import", match.index, target, 0.95, `import-${pattern.source.slice(0, 16)}`, binding);
-  }
-  for (const imported of imports) if (imported.binding) {
-    const call = new RegExp(`\\b${imported.binding.replace(/[$]/g, "\\$&")}\\s*\\(`, "g");
-    for (const match of source.matchAll(call)) if (match.index !== void 0) push("call", match.index, imported.target, 0.85, "import-bound-call", imported.binding);
-  }
-  const resource = /https?:\/\/github\.com\/mutmutco\/[A-Za-z0-9._-]+(?:\.git)?/g;
-  for (const match of source.matchAll(resource)) if (match.index !== void 0) push("resource", match.index, match[0], 1, "github-url");
-  return edges.sort((a, b) => a.source.path.localeCompare(b.source.path) || a.source.line - b.source.line || a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
-}
-function buildGraphEdges(cwd, repo, commit, rosterRepos) {
-  const paths = listCandidatePaths(cwd).filter(isIndexablePath).sort((a, b) => a.localeCompare(b));
-  const ignored = defaultIsIgnored(cwd, paths);
-  const edges = [];
-  for (const path of paths) {
-    if (ignored.has(path) || isHardDeniedPath(path) || !SUPPORTED.has(extension(path))) continue;
-    const absolute = (0, import_node_path5.join)(cwd, ...path.split("/"));
-    if (!(0, import_node_fs4.existsSync)(absolute)) continue;
-    try {
-      edges.push(...graphEdgesForSource(repo, commit, path, (0, import_node_fs4.readFileSync)(absolute, "utf8"), rosterRepos));
-    } catch {
-    }
-    if (edges.length >= V4_GRAPH_MAX_EDGES) break;
-  }
-  return edges.slice(0, V4_GRAPH_MAX_EDGES).sort((a, b) => a.source.path.localeCompare(b.source.path) || a.source.line - b.source.line || a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  REPO_INDEX_V4_SCHEMA,
-  V4_DELTA_DEEPEN_STEPS,
-  V4_GRAPH_MAX_EDGES,
-  V4_GRAPH_MAX_EDGES_PER_FILE,
-  V4_MAX_ARTIFACT_BYTES,
-  V4_MAX_CHUNKS,
-  V4_STAGE_MAX_BODY_BYTES,
-  V4_STAGE_MAX_RECORDS,
-  buildGraphEdges,
-  buildRepoIndexV4,
-  buildRepoIndexV4Detailed,
-  buildStructuralChunks,
-  buildStructuralChunksForPaths,
-  canonicalRepoIndexPaths,
-  changedPaths,
-  compareV4Chunks,
-  encodedStageBytes,
-  formatV4BuildMetrics,
-  gitRunner,
-  graphEdgesForSource,
-  isRepoIndexDeltaCompatible,
-  languageForPath,
-  parseNameStatusZ,
-  planRepoIndexV4Delta,
-  readRepoIndexProvenance,
-  removedPaths,
-  repoIndexV4DeltaBase,
-  repoIndexV4StorePath,
-  shardRepoIndexV4,
-  structuralChunksForSource
-});