knodin 0.8.4 → 0.8.6

package/dist/src/engine/prune.js

@@ -43,6 +43,14 @@ export const PRUNE_DIR_NAMES = new Set([
     "vendor",
     "__pycache__",
 ]);
+/** Frozen input to shared-index compatibility; update with any pruning behavior change. */
+export function prunePolicyDescriptor() {
+    return {
+        version: 1,
+        directories: [...PRUNE_DIR_NAMES].sort((left, right) => left.localeCompare(right)),
+        patterns: [".claude/worktrees"],
+    };
+}
 /** True when a single path segment (one directory name) is a pruned directory. */
 export function isPrunedSegment(segment) {
     return PRUNE_DIR_NAMES.has(segment);

package/dist/src/file-metrics.js

@@ -0,0 +1,153 @@
+import { execFileSync } from "node:child_process";
+const SOURCE_EXTENSION = /\.(?:[cm]?[jt]sx?|py|java|cls|trigger|go|rs|rb|php|cs)$/i;
+const TEST_PATH = /(?:(?:^|\/)(?:__tests__|test|tests|spec|specs)(?:\/|$)|[._](?:test|spec)\.[^/]+$)/i;
+function git(repo, args, input) {
+    try {
+        return execFileSync("git", ["-C", repo, ...args], {
+            encoding: "buffer",
+            input,
+            maxBuffer: 512 * 1024 * 1024,
+            stdio: [input ? "pipe" : "ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const stderr = error.stderr;
+        const message = Buffer.isBuffer(stderr) ? stderr.toString("utf8").trim() : String(stderr ?? "");
+        throw new Error(`knodin query file_metrics: git ${args[0]} failed${message ? `: ${message}` : ""}`);
+    }
+}
+function resolveCommit(repo, ref) {
+    try {
+        return git(repo, ["rev-parse", "--verify", `${ref}^{commit}`])
+            .toString("utf8")
+            .trim();
+    }
+    catch {
+        throw new Error(`knodin query file_metrics: invalid or unreachable Git ref ${ref}`);
+    }
+}
+function tree(repo, commit) {
+    const listing = git(repo, ["ls-tree", "-r", "-z", commit]);
+    const entries = listing
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean)
+        .flatMap((entry) => {
+        const match = /^(\d+) blob ([a-f0-9]+)\t([\s\S]+)$/.exec(entry);
+        if (!match || !SOURCE_EXTENSION.test(match[3]))
+            return [];
+        return [{ path: match[3], hash: match[2] }];
+    });
+    const hashes = [...new Set(entries.map((entry) => entry.hash))];
+    const batch = hashes.length
+        ? git(repo, ["cat-file", "--batch"], Buffer.from(`${hashes.join("\n")}\n`))
+        : Buffer.alloc(0);
+    const contents = new Map();
+    let offset = 0;
+    for (const expected of hashes) {
+        const newline = batch.indexOf(0x0a, offset);
+        if (newline < 0)
+            throw new Error("knodin query file_metrics: truncated git object batch");
+        const header = batch.subarray(offset, newline).toString("utf8");
+        const match = /^([a-f0-9]+) blob (\d+)$/.exec(header);
+        if (!match || match[1] !== expected)
+            throw new Error("knodin query file_metrics: unexpected git object batch response");
+        const size = Number(match[2]);
+        const start = newline + 1;
+        const end = start + size;
+        if (end >= batch.length || batch[end] !== 0x0a)
+            throw new Error("knodin query file_metrics: malformed git object batch response");
+        contents.set(expected, batch.subarray(start, end));
+        offset = end + 1;
+    }
+    return new Map(entries.map((entry) => {
+        const content = contents.get(entry.hash);
+        if (!content)
+            throw new Error("knodin query file_metrics: missing Git object content");
+        return [entry.path, { hash: entry.hash, content }];
+    }));
+}
+function text(buffer) {
+    if (buffer.includes(0))
+        return null;
+    const decoded = buffer.toString("utf8");
+    return Buffer.from(decoded, "utf8").equals(buffer) ? decoded : null;
+}
+export function measureFile(content) {
+    const lines = content.length === 0
+        ? 0
+        : content.split(/\r\n|\n|\r/).length - (/[\r\n]$/.test(content) ? 1 : 0);
+    const imports = (content.match(/^\s*(?:import\b|export\s+[^\n;]*\sfrom\b|(?:const|let|var)\s+[^=\n]+?=\s*require\s*\(|from\s+\S+\s+import\b|import\s+\S+)/gm) ?? []).length;
+    const routes = (content.match(/\b(?:app|router)\s*\.\s*(?:get|post|put|patch|delete|options|head|use)\s*\(|@(?:Get|Post|Put|Patch|Delete|RequestMapping|GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping)\b|@app\.(?:get|post|put|patch|delete|route)\s*\(/g) ?? []).length;
+    const effects = (content.match(/\b(?:fetch|axios\.(?:get|post|put|patch|delete)|console\.(?:log|warn|error)|(?:read|write|append|unlink|mkdir|rm)FileSync|(?:read|write|append|unlink|mkdir|rm)File|process\.env|\.query|\.execute|\.save|\.send|\.publish)\s*[[(]/g) ?? []).length;
+    return { lines, imports, routes, effects };
+}
+function subtract(head, base) {
+    return {
+        lines: head.lines - base.lines,
+        imports: head.imports - base.imports,
+        routes: head.routes - base.routes,
+        effects: head.effects - base.effects,
+    };
+}
+export function collectFileMetrics(repo, options = {}) {
+    const head = resolveCommit(repo, "HEAD");
+    let base;
+    if (options.base) {
+        resolveCommit(repo, options.base);
+        const mergeBase = git(repo, ["merge-base", "HEAD", options.base]).toString("utf8").trim();
+        if (!mergeBase)
+            throw new Error(`knodin query file_metrics: cannot resolve merge-base for ${options.base}`);
+        base = { requested: options.base, mergeBase };
+    }
+    const testScope = options.testScope ?? "all";
+    const headTree = tree(repo, head);
+    const baseTree = base ? tree(repo, base.mergeBase) : undefined;
+    const paths = [...new Set([...headTree.keys(), ...(baseTree?.keys() ?? [])])]
+        .filter((file) => testScope === "all" || (testScope === "test") === TEST_PATH.test(file))
+        .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    const files = [];
+    for (const file of paths) {
+        const headEntry = headTree.get(file);
+        const baseEntry = baseTree?.get(file);
+        const headText = headEntry ? text(headEntry.content) : null;
+        const baseText = baseEntry ? text(baseEntry.content) : null;
+        // Binary or invalid UTF-8 inputs are explicitly skipped rather than reported as zero.
+        if ((headEntry && headText === null) || (baseEntry && baseText === null))
+            continue;
+        const headMetrics = headText === null ? null : measureFile(headText);
+        const baseMetrics = baseText === null ? null : measureFile(baseText);
+        const status = !headEntry
+            ? "removed"
+            : !baseTree
+                ? "unchanged"
+                : !baseEntry
+                    ? "added"
+                    : headEntry.hash === baseEntry.hash
+                        ? "unchanged"
+                        : "changed";
+        files.push({
+            file,
+            status,
+            head: headMetrics,
+            ...(baseTree
+                ? {
+                    base: baseMetrics,
+                    delta: status === "changed" && headMetrics && baseMetrics
+                        ? subtract(headMetrics, baseMetrics)
+                        : null,
+                }
+                : {}),
+        });
+    }
+    return {
+        schemaVersion: 1,
+        status: "ok",
+        head,
+        ...(base ? { base } : {}),
+        testScope,
+        files,
+        confidentiality: "paths-and-integer-counts-only",
+        policy: "measurements-only",
+    };
+}

package/dist/src/repair-lease.js

@@ -41,10 +41,13 @@ function writeLease(target, record) {
         mode: 0o600,
     });
 }
-function removeStaleLeaseOrThrow(target) {
+function removeStaleLeaseOrThrow(target, operation) {
     const current = readLease(target);
     if (current && processIsAlive(current.pid)) {
-        throw new Error(`knodin repair: another repair is already in progress (pid ${current.pid}, started ${current.startedAt}); wait for it to finish, then run \`knodin status\``);
+        const contention = operation === "repair"
+            ? "another repair is already in progress"
+            : "another lifecycle mutation is already in progress";
+        throw new Error(`knodin ${operation}: ${contention} (pid ${current.pid}, started ${current.startedAt}); wait for it to finish, then run \`knodin status\``);
     }
     try {
         fs.unlinkSync(target);
@@ -55,7 +58,7 @@ function removeStaleLeaseOrThrow(target) {
     }
 }
 /** Atomically serialize repair post-processing across independent CLI/MCP processes. */
-export function acquireRepairLease(repo) {
+export function acquireRepairLease(repo, operation = "repair") {
     const target = leasePath(repo);
     fs.mkdirSync(path.dirname(target), { recursive: true });
     const record = {
@@ -78,8 +81,8 @@ export function acquireRepairLease(repo) {
         catch (error) {
             if (error.code !== "EEXIST")
                 throw error;
-            removeStaleLeaseOrThrow(target);
+            removeStaleLeaseOrThrow(target, operation);
         }
     }
-    throw new Error("knodin repair: could not acquire the repository repair lease; retry shortly");
+    throw new Error(`knodin ${operation}: could not acquire the repository lifecycle lease; retry shortly`);
 }

package/dist/src/response-budget.js

@@ -46,7 +46,8 @@ const PROTECTED_CONTRACT_KEYS = new Set([
     "to",
 ]);
 function isTruncatableDetail(entry) {
-    return typeof entry.key !== "string" || !PROTECTED_CONTRACT_KEYS.has(entry.key);
+    return (!entry.path.startsWith("$/sharedIndex/") &&
+        (typeof entry.key !== "string" || !PROTECTED_CONTRACT_KEYS.has(entry.key)));
 }
 function synchronizeNestedCapabilityBudget(root, metadata, operation) {
     const cross = root.crossSubstratePath;

package/dist/src/shared-index/artifact.js

@@ -0,0 +1,65 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { createZstdDecompress } from "node:zlib";
+import { assertCandidate } from "../engine/candidate-database.js";
+import { SharedIndexError } from "./s3-client.js";
+const SQLITE_HEADER = Buffer.from("SQLite format 3\0", "binary");
+function writeAll(descriptor, bytes) {
+    let offset = 0;
+    while (offset < bytes.byteLength)
+        offset += fs.writeSync(descriptor, bytes, offset, bytes.byteLength - offset);
+}
+export async function decompressArtifactToCandidate(options) {
+    assertCandidate(options.repo, options.candidate);
+    if (fs.existsSync(options.candidate.databasePath))
+        throw new SharedIndexError("integrity", "shared-index candidate database already exists");
+    const source = fs.createReadStream(options.artifact.path);
+    const decompressor = createZstdDecompress();
+    const output = fs.openSync(options.candidate.databasePath, "wx", 0o600);
+    const hash = crypto.createHash("sha256");
+    let received = 0;
+    try {
+        if (options.signal) {
+            if (options.signal.aborted)
+                throw new SharedIndexError("timeout", "shared-index decompression was cancelled");
+            options.signal.addEventListener("abort", () => decompressor.destroy(), { once: true });
+        }
+        source.pipe(decompressor);
+        for await (const chunk of decompressor) {
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            received += bytes.byteLength;
+            if (received > options.manifest.graph.uncompressedBytes)
+                throw new SharedIndexError("integrity", "shared-index decompressed object exceeded manifest size");
+            hash.update(bytes);
+            writeAll(output, bytes);
+        }
+        if (decompressor.bytesWritten !== options.manifest.graph.compressedBytes)
+            throw new SharedIndexError("integrity", "shared-index compressed object contains trailing data");
+        fs.fsyncSync(output);
+        if (received !== options.manifest.graph.uncompressedBytes ||
+            hash.digest("hex") !== options.manifest.graph.uncompressedSha256)
+            throw new SharedIndexError("integrity", "shared-index decompressed object failed size or digest verification");
+    }
+    catch (error) {
+        fs.closeSync(output);
+        fs.rmSync(options.candidate.databasePath, { force: true });
+        if (options.signal?.aborted)
+            throw new SharedIndexError("timeout", "shared-index decompression was cancelled");
+        if (error instanceof SharedIndexError)
+            throw error;
+        throw new SharedIndexError("integrity", "shared-index compressed object is not valid zstd");
+    }
+    finally {
+        source.destroy();
+        decompressor.destroy();
+    }
+    fs.closeSync(output);
+    const descriptor = fs.openSync(options.candidate.databasePath, "r");
+    const header = Buffer.alloc(SQLITE_HEADER.byteLength);
+    const headerBytes = fs.readSync(descriptor, header, 0, header.byteLength, 0);
+    fs.closeSync(descriptor);
+    if (headerBytes !== header.byteLength || !header.equals(SQLITE_HEADER)) {
+        fs.rmSync(options.candidate.databasePath, { force: true });
+        throw new SharedIndexError("integrity", "shared-index artifact is not a SQLite database");
+    }
+}

package/dist/src/shared-index/cache.js

@@ -0,0 +1,267 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { SharedIndexError } from "./s3-client.js";
+const DIGEST = /^[a-f0-9]{64}$/;
+const CACHE_FILE = "graph.sqlite.zst";
+function assertDigest(digest) {
+    if (!DIGEST.test(digest))
+        throw new SharedIndexError("integrity", "shared-index cache digest is invalid");
+}
+function hashFile(target) {
+    const hash = crypto.createHash("sha256");
+    const descriptor = fs.openSync(target, "r");
+    const buffer = Buffer.allocUnsafe(1024 * 1024);
+    try {
+        let bytes = 0;
+        do {
+            bytes = fs.readSync(descriptor, buffer, 0, buffer.byteLength, null);
+            if (bytes > 0)
+                hash.update(buffer.subarray(0, bytes));
+        } while (bytes > 0);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+    return hash.digest("hex");
+}
+function writeAll(descriptor, bytes) {
+    let offset = 0;
+    while (offset < bytes.byteLength)
+        offset += fs.writeSync(descriptor, bytes, offset, bytes.byteLength - offset);
+}
+function fsyncDirectory(target) {
+    try {
+        const descriptor = fs.openSync(target, "r");
+        try {
+            fs.fsyncSync(descriptor);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+    }
+    catch (error) {
+        if (process.platform !== "win32")
+            throw error;
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function removeStaleLeases(directory) {
+    if (!fs.existsSync(directory))
+        return;
+    for (const name of fs.readdirSync(directory)) {
+        const match = /^\.lease-(\d+)-/.exec(name);
+        if (match && !processExists(Number(match[1])))
+            fs.rmSync(path.join(directory, name), { force: true });
+    }
+}
+function isLeased(directory) {
+    removeStaleLeases(directory);
+    return (fs.existsSync(directory) && fs.readdirSync(directory).some((name) => name.startsWith(".lease-")));
+}
+function wait(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        const finish = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const timer = setTimeout(finish, milliseconds);
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(new SharedIndexError("timeout", "shared-index cache wait was cancelled"));
+        };
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export class SharedIndexCache {
+    root;
+    maxEntries;
+    maxBytes;
+    lockTimeoutMs;
+    constructor(policy = {}) {
+        this.root = path.resolve(policy.root ?? path.join(os.homedir(), ".knodin", "shared-index-cache", "v1", "sha256"));
+        this.maxEntries = policy.maxEntries ?? 32;
+        this.maxBytes = policy.maxBytes ?? 32 * 1024 ** 3;
+        this.lockTimeoutMs = policy.lockTimeoutMs ?? 30_000;
+        if (!Number.isSafeInteger(this.maxEntries) ||
+            this.maxEntries < 1 ||
+            !Number.isSafeInteger(this.maxBytes) ||
+            this.maxBytes < 1 ||
+            !Number.isSafeInteger(this.lockTimeoutMs) ||
+            this.lockTimeoutMs < 1)
+            throw new SharedIndexError("configuration", "shared-index cache policy is invalid");
+        fs.mkdirSync(this.root, { recursive: true, mode: 0o700 });
+        if (fs.lstatSync(this.root).isSymbolicLink() || !fs.lstatSync(this.root).isDirectory())
+            throw new SharedIndexError("configuration", "shared-index cache root is not a private directory");
+        fs.chmodSync(this.root, 0o700);
+    }
+    entry(digest) {
+        assertDigest(digest);
+        const directory = path.join(this.root, digest);
+        const file = path.join(directory, CACHE_FILE);
+        const stat = fs.existsSync(file) ? fs.statSync(file) : undefined;
+        return {
+            digest,
+            directory,
+            file,
+            bytes: stat?.size ?? 0,
+            accessedAt: Math.max(stat?.atimeMs ?? 0, stat?.mtimeMs ?? 0),
+        };
+    }
+    async lock(digest, signal) {
+        const target = path.join(this.root, `.${digest}.lock`);
+        const deadline = Date.now() + this.lockTimeoutMs;
+        while (true) {
+            try {
+                const descriptor = fs.openSync(target, "wx", 0o600);
+                fs.writeFileSync(descriptor, `${process.pid}\n${Date.now()}\n`);
+                fs.closeSync(descriptor);
+                return () => fs.rmSync(target, { force: true });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                try {
+                    const [pidText, createdText] = fs.readFileSync(target, "utf8").split("\n");
+                    if (Date.now() - Number(createdText) > this.lockTimeoutMs &&
+                        !processExists(Number(pidText))) {
+                        fs.rmSync(target, { force: true });
+                        continue;
+                    }
+                }
+                catch {
+                    // The lock owner may be replacing or releasing it; retry within the bound.
+                }
+                if (Date.now() >= deadline)
+                    throw new SharedIndexError("timeout", "shared-index cache lock timed out");
+                await wait(50, signal);
+            }
+        }
+    }
+    valid(entry, expectedBytes, expectedDigest) {
+        if (!fs.existsSync(entry.directory))
+            return false;
+        const directory = fs.lstatSync(entry.directory);
+        if (!directory.isDirectory() || directory.isSymbolicLink())
+            return false;
+        if (!fs.existsSync(entry.file))
+            return false;
+        const stat = fs.lstatSync(entry.file);
+        if (!stat.isFile() ||
+            stat.isSymbolicLink() ||
+            stat.size !== expectedBytes ||
+            (stat.mode & 0o777) !== 0o400)
+            return false;
+        return hashFile(entry.file) === expectedDigest;
+    }
+    lease(entry, state) {
+        const marker = path.join(entry.directory, `.lease-${process.pid}-${crypto.randomUUID()}`);
+        fs.writeFileSync(marker, "", { flag: "wx", mode: 0o600 });
+        const now = new Date();
+        fs.utimesSync(entry.file, now, now);
+        let released = false;
+        return {
+            path: entry.file,
+            state,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                fs.rmSync(marker, { force: true });
+                this.evict();
+            },
+        };
+    }
+    entries() {
+        return fs
+            .readdirSync(this.root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && DIGEST.test(entry.name))
+            .map((entry) => this.entry(entry.name))
+            .filter((entry) => fs.existsSync(entry.file));
+    }
+    evict() {
+        const entries = this.entries().sort((left, right) => left.accessedAt - right.accessedAt);
+        let bytes = entries.reduce((total, entry) => total + entry.bytes, 0);
+        let count = entries.length;
+        for (const entry of entries) {
+            if (count <= this.maxEntries && bytes <= this.maxBytes)
+                break;
+            if (isLeased(entry.directory) || fs.existsSync(path.join(this.root, `.${entry.digest}.lock`)))
+                continue;
+            fs.rmSync(entry.directory, { recursive: true, force: true });
+            count -= 1;
+            bytes -= entry.bytes;
+        }
+    }
+    async acquire(store, manifest, signal) {
+        const digest = manifest.graph.compressedSha256;
+        const expectedBytes = manifest.graph.compressedBytes;
+        if (expectedBytes > this.maxBytes)
+            throw new SharedIndexError("configuration", "shared-index artifact exceeds the configured cache-size bound");
+        const entry = this.entry(digest);
+        const unlock = await this.lock(digest, signal);
+        try {
+            const corrupt = fs.existsSync(entry.file);
+            if (this.valid(entry, expectedBytes, digest))
+                return this.lease(entry, "hit");
+            if (corrupt && isLeased(entry.directory))
+                throw new SharedIndexError("unavailable", "shared-index corrupt cache entry is currently leased");
+            if (fs.existsSync(entry.directory))
+                fs.rmSync(entry.directory, { recursive: true, force: true });
+            fs.mkdirSync(entry.directory, { recursive: true, mode: 0o700 });
+            const metadata = await store.head(manifest.graph.key, { signal });
+            if (metadata.bytes !== expectedBytes)
+                throw new SharedIndexError("integrity", "shared-index compressed object size does not match manifest");
+            const temporary = path.join(entry.directory, `.download-${crypto.randomUUID()}.tmp`);
+            try {
+                const source = await store.get(manifest.graph.key, { maxBytes: expectedBytes, signal });
+                const descriptor = fs.openSync(temporary, "wx", 0o600);
+                const hash = crypto.createHash("sha256");
+                let received = 0;
+                try {
+                    for await (const chunk of source) {
+                        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        received += bytes.byteLength;
+                        if (received > expectedBytes)
+                            throw new SharedIndexError("integrity", "shared-index compressed object exceeded manifest size");
+                        hash.update(bytes);
+                        writeAll(descriptor, bytes);
+                    }
+                    fs.fsyncSync(descriptor);
+                }
+                finally {
+                    fs.closeSync(descriptor);
+                }
+                if (received !== expectedBytes || hash.digest("hex") !== digest)
+                    throw new SharedIndexError("integrity", "shared-index compressed object failed size or digest verification");
+                fs.chmodSync(temporary, 0o400);
+                fs.renameSync(temporary, entry.file);
+                fsyncDirectory(entry.directory);
+                const state = corrupt ? "corrupt-refetched" : "downloaded";
+                const lease = this.lease(this.entry(digest), state);
+                this.evict();
+                return lease;
+            }
+            catch (error) {
+                fs.rmSync(temporary, { force: true });
+                throw error;
+            }
+        }
+        finally {
+            unlock();
+        }
+    }
+}

package/dist/src/shared-index/compatibility.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { EMBEDDING_DIMENSIONS, EMBEDDING_MODEL_ID, EMBEDDING_MODEL_REVISION, } from "../engine/embeddings.js";
+import { KNODIN_SCHEMA_VERSION } from "../engine/index.js";
+import { prunePolicyDescriptor } from "../engine/prune.js";
+import { KNODIN_VERSION } from "../version.js";
+import { canonicalManifestBytes, sha256Hex } from "./contract.js";
+const require = createRequire(import.meta.url);
+function packageVersion(name) {
+    try {
+        return require(`${name}/package.json`).version;
+    }
+    catch {
+        let current = path.dirname(fileURLToPath(import.meta.url));
+        try {
+            current = path.dirname(require.resolve(name));
+        }
+        catch {
+            throw new Error(`cannot resolve compatibility dependency ${name}`);
+        }
+        for (;;) {
+            const manifest = path.join(current, "package.json");
+            if (fs.existsSync(manifest)) {
+                const value = JSON.parse(fs.readFileSync(manifest, "utf8"));
+                if (value.name === name && value.version)
+                    return value.version;
+            }
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        throw new Error(`cannot read compatibility dependency ${name}`);
+    }
+}
+function digest(value) {
+    return sha256Hex(canonicalManifestBytes(value));
+}
+/** One implementation used by client verification and publisher metadata. */
+export function currentSharedIndexCompatibility() {
+    const model = {
+        id: EMBEDDING_MODEL_ID,
+        revision: EMBEDDING_MODEL_REVISION,
+        dimensions: EMBEDDING_DIMENSIONS,
+        runtime: `@huggingface/transformers@${packageVersion("@huggingface/transformers")}`,
+    };
+    const parsers = {
+        policyVersion: 1,
+        packages: {
+            "tree-sitter-wasms": packageVersion("tree-sitter-wasms"),
+            "web-tree-sitter": packageVersion("web-tree-sitter"),
+            "web-tree-sitter-sfapex": packageVersion("web-tree-sitter-sfapex"),
+        },
+    };
+    return {
+        knodinVersion: KNODIN_VERSION,
+        databaseSchemaVersion: KNODIN_SCHEMA_VERSION,
+        modelId: EMBEDDING_MODEL_ID,
+        modelDigest: digest(model),
+        parserBundleDigest: digest(parsers),
+        indexConfigDigest: digest({
+            policyVersion: 1,
+            databaseSchemaVersion: KNODIN_SCHEMA_VERSION,
+            embeddingDimensions: EMBEDDING_DIMENSIONS,
+        }),
+        prunePolicyDigest: digest(prunePolicyDescriptor()),
+    };
+}