@tangle-network/agent-knowledge 19.1.1 → 19.1.2

package/dist/{inspect-CwIvMcno.js → inspect-C6c4zuKp.js}

@@ -1,12 +1,12 @@
 import { i as textSourceId, n as slugify, r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { r as searchKnowledge } from "./search-Cbyj2shJ.js";
+import { r as searchKnowledge } from "./search-BBr5eUyT.js";
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { canonicalCandidateBytes, canonicalCandidateDigest, sha256Bytes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { contentHash } from "@tangle-network/agent-eval";
 import { z } from "zod";
-import { constants } from "node:fs";
+import { constants, lstatSync } from "node:fs";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/adapters.ts
 const textSourceAdapter = {
@@ -95,8 +95,7 @@ async function renameDurable(source, target) {
 	await withDirectoryHandle(sourceDir, async (sourceHandle, anchoredSourceDir) => {
 		await withDirectoryHandle(targetDir, async (targetHandle, anchoredTargetDir) => {
 			await rename(resolve(anchoredSourceDir, basename(source)), resolve(anchoredTargetDir, basename(target)));
-			await syncDirectoryHandle(sourceHandle);
-			if (targetDir !== sourceDir) await syncDirectoryHandle(targetHandle);
+			await Promise.all([syncDirectoryHandle(sourceHandle), targetDir === sourceDir ? void 0 : syncDirectoryHandle(targetHandle)]);
 		});
 	});
 }
@@ -172,15 +171,20 @@ async function listRegularFileMetadataWithinRoot(root, relativeDirectory) {
 	const walk = async (directory, relative) => {
 		const out = [];
 		const entries = await readdir(directory, { withFileTypes: true });
-		for (const entry of entries.filter((entry) => entry.isDirectory())) out.push(...await withSafeDirectory(directory, entry.name, false, (child) => walk(child, `${relative}/${entry.name}`)));
+		const directories = entries.filter((entry) => entry.isDirectory());
+		for (let start = 0; start < directories.length; start += 8) {
+			const children = await Promise.all(directories.slice(start, start + 8).map((entry) => withSafeDirectory(directory, entry.name, false, (child) => walk(child, `${relative}/${entry.name}`))));
+			for (const child of children) out.push(...child);
+		}
 		const files = entries.filter((entry) => !entry.isDirectory());
-		for (let start = 0; start < files.length; start += 64) {
-			const batch = await Promise.all(files.slice(start, start + 64).map(async (entry) => {
+		for (let start = 0; start < files.length; start += 256) {
+			if (start > 0) await new Promise((resume) => setImmediate(resume));
+			for (const entry of files.slice(start, start + 256)) {
 				const path = `${relative}/${entry.name}`;
 				if (!entry.isFile()) throw new Error(`knowledge tree contains an unsupported filesystem entry: ${path}`);
-				const stat = await lstat(resolve(directory, entry.name), { bigint: true });
+				const stat = lstatSync(resolve(directory, entry.name), { bigint: true });
 				if (!stat.isFile()) throw new Error(`knowledge path is not a regular file: ${path}`);
-				return [{
+				out.push({
 					path,
 					bytes: Number(stat.size),
 					generation: [
@@ -190,9 +194,8 @@ async function listRegularFileMetadataWithinRoot(root, relativeDirectory) {
 						stat.mtimeNs,
 						stat.ctimeNs
 					].join(":")
-				}];
-			}));
-			out.push(...batch.flat());
+				});
+			}
 		}
 		return out.sort((left, right) => left.path.localeCompare(right.path));
 	};
@@ -488,10 +491,6 @@ async function prepareKnowledgeFileTransaction(input) {
 		const preparationDir = await mkdtemp(join(transactionRoot, "prepare-"));
 		let activated = false;
 		try {
-			for (const item of changed) {
-				if (item.before) await writeFileDurable(snapshotPath(preparationDir, "before", item.entry.index), item.before);
-				if (item.after) await writeFileDurable(snapshotPath(preparationDir, "after", item.entry.index), item.after);
-			}
 			const transaction = transactionSchema.parse({
 				kind: "knowledge-file-transaction",
 				transactionId: randomUUID(),
@@ -505,7 +504,11 @@ async function prepareKnowledgeFileTransaction(input) {
 				createdAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
 				entries: changed.map((item) => item.entry)
 			});
-			await writeJsonDurable(join(preparationDir, "transaction.json"), transaction);
+			for (const side of ["before", "after"]) if (changed.some((item) => item[side])) await mkdir(join(preparationDir, side));
+			await Promise.all([...changed.flatMap((item) => ["before", "after"].flatMap((side) => {
+				const bytes = item[side];
+				return bytes ? [writeFileDurable(snapshotPath(preparationDir, side, item.entry.index), bytes)] : [];
+			})), writeJsonDurable(join(preparationDir, "transaction.json"), transaction)]);
 			const activeDir = join(transactionRoot, activeTransactionDirectoryName(transaction.transactionId));
 			await renameDurable(preparationDir, activeDir);
 			activated = true;
@@ -647,11 +650,13 @@ async function finishKnowledgeFileTransaction(input) {
 		if (transaction.retainHistory === true) await withSafeDirectory(input.root, ".agent-knowledge/history", true, async (historyRoot) => {
 			await renameDurable(join(transactionRoot, activeName), join(historyRoot, transaction.transactionId));
 		});
-		else await rm(join(transactionRoot, activeName), {
-			recursive: true,
-			force: false
-		});
-		await syncDirectory(transactionRoot);
+		else {
+			await rm(join(transactionRoot, activeName), {
+				recursive: true,
+				force: false
+			});
+			await syncDirectory(transactionRoot);
+		}
 	});
 }
 async function hasRetainedTransaction(root, transaction) {
@@ -867,6 +872,86 @@ function loadLockfile() {
 }
 const activeRoots = new AsyncLocalStorage();
 const activeReadRoots = new AsyncLocalStorage();
+const gates = /* @__PURE__ */ new Map();
+/** How long a same-process writer waits for admission before failing like a contended lock. */
+const WRITER_ADMISSION_MS = 6e4;
+function gateOf(root) {
+	let gate = gates.get(root);
+	if (!gate) {
+		gate = {
+			readers: 0,
+			writing: false,
+			readersWaiting: [],
+			writersWaiting: []
+		};
+		gates.set(root, gate);
+	}
+	return gate;
+}
+/** Admit whoever may go next: waiting readers after a write, otherwise a waiting writer first. */
+function admitNext(root, gate, afterWrite) {
+	if (gate.writing) return;
+	if (gate.readersWaiting.length > 0 && (afterWrite || gate.writersWaiting.length === 0)) {
+		const admitted = gate.readersWaiting.splice(0);
+		gate.readers += admitted.length;
+		for (const admit of admitted) admit();
+	} else if (gate.readers === 0 && gate.writersWaiting.length > 0) {
+		gate.writing = true;
+		gate.writersWaiting.shift()();
+	} else if (gate.readers === 0) gates.delete(root);
+}
+async function enterGate(root, mode, timeoutMs) {
+	const gate = gateOf(root);
+	const release = mode === "read" ? () => {
+		gate.readers -= 1;
+		if (gate.readers === 0) admitNext(root, gate, false);
+	} : () => {
+		gate.writing = false;
+		admitNext(root, gate, true);
+	};
+	if (mode === "read" ? !gate.writing && gate.writersWaiting.length === 0 : !gate.writing && gate.readers === 0 && gate.writersWaiting.length === 0) {
+		if (mode === "read") gate.readers += 1;
+		else gate.writing = true;
+		return once(release);
+	}
+	const waiting = mode === "read" ? gate.readersWaiting : gate.writersWaiting;
+	return new Promise((resolve, reject) => {
+		let timer;
+		const admit = () => {
+			if (timer) clearTimeout(timer);
+			resolve(once(release));
+		};
+		waiting.push(admit);
+		timer = setTimeout(() => {
+			const position = waiting.indexOf(admit);
+			if (position < 0) return;
+			waiting.splice(position, 1);
+			admitNext(root, gate, mode === "write");
+			reject(mode === "read" ? /* @__PURE__ */ new Error("knowledge read could not observe a stable mutation epoch") : Object.assign(/* @__PURE__ */ new Error(`knowledge store is locked by this process: ${root}`), { code: "ELOCKED" }));
+		}, timeoutMs);
+		timer.unref?.();
+	});
+}
+function once(release) {
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		release();
+	};
+}
+const mutationTimings = new AsyncLocalStorage();
+/** Run `body` and report the lock timings of the store mutations it performed. */
+async function measureKnowledgeMutation(body) {
+	const timings = [];
+	return {
+		value: await mutationTimings.run(timings, body),
+		timing: timings.length === 0 ? void 0 : timings.reduce((sum, next) => ({
+			lockWaitMs: sum.lockWaitMs + next.lockWaitMs,
+			lockHoldMs: sum.lockHoldMs + next.lockHoldMs
+		}))
+	};
+}
 var KnowledgeLockLostError = class extends Error {
 	constructor(message, options) {
 		super(message, options);
@@ -886,24 +971,42 @@ async function withKnowledgeMutation(root, mutate, options = {}) {
 	const resolvedRoot = resolve(root);
 	const existing = activeRoots.getStore()?.get(resolvedRoot);
 	if (existing?.active) return await runInlineMutation(existing.lock, mutate);
-	return withSafeDirectory(resolvedRoot, ".agent-knowledge", true, async (cacheDir) => {
-		const acquired = await acquireDurableFileLock(resolvedRoot, {
-			lockfilePath: join(cacheDir, "mutation.lock.durable"),
-			staleMs: options.staleMs,
-			retries: options.retries ?? {
-				retries: 100,
-				factor: 1.1,
-				minTimeout: 10,
-				maxTimeout: 200,
-				randomize: true
+	if (activeReadRoots.getStore()?.has(resolvedRoot)) throw new Error("a knowledge mutation cannot start inside a read of the same store");
+	const started = performance.now();
+	const leave = await enterGate(resolvedRoot, "write", noRetries(options.retries) ? 0 : WRITER_ADMISSION_MS);
+	try {
+		return await withSafeDirectory(resolvedRoot, ".agent-knowledge", true, async (cacheDir) => {
+			const acquired = await acquireDurableFileLock(resolvedRoot, {
+				lockfilePath: join(cacheDir, "mutation.lock.durable"),
+				staleMs: options.staleMs,
+				retries: options.retries ?? {
+					retries: 100,
+					factor: 1.1,
+					minTimeout: 10,
+					maxTimeout: 200,
+					randomize: true
+				}
+			});
+			const held = performance.now();
+			try {
+				return await runOwnedMutation(resolvedRoot, cacheDir, acquired, options, mutate);
+			} finally {
+				try {
+					await acquired.release();
+				} finally {
+					mutationTimings.getStore()?.push({
+						lockWaitMs: Math.round(held - started),
+						lockHoldMs: Math.round(performance.now() - held)
+					});
+				}
 			}
 		});
-		try {
-			return await runOwnedMutation(resolvedRoot, cacheDir, acquired, options, mutate);
-		} finally {
-			await acquired.release();
-		}
-	});
+	} finally {
+		leave();
+	}
+}
+function noRetries(retries) {
+	return retries === 0 || typeof retries === "object" && !Array.isArray(retries) && retries.retries === 0;
 }
 /**
 * Run `body` inside this package's mutation scope for `root`, on a lock the caller already holds.
@@ -1048,21 +1151,26 @@ async function withKnowledgeRead(root, read, options = {}) {
 	if (activeReadRoots.getStore()?.has(resolvedRoot)) return await read();
 	const readRoots = new Set(activeReadRoots.getStore());
 	readRoots.add(resolvedRoot);
-	return activeReadRoots.run(readRoots, async () => {
-		const retries = options.retries ?? DEFAULT_READ_RETRIES;
-		for (let attempt = 0; attempt <= retries; attempt += 1) {
-			const before = await readMutationEpoch(resolvedRoot);
-			if (isOdd(before)) {
-				await waitForActiveMutationEpoch(resolvedRoot, before, options);
-				continue;
+	const retries = options.retries ?? DEFAULT_READ_RETRIES;
+	const leave = await enterGate(resolvedRoot, "read", (retries + 1) * (options.waitMs ?? DEFAULT_READ_WAIT_MS));
+	try {
+		return await activeReadRoots.run(readRoots, async () => {
+			for (let attempt = 0; attempt <= retries; attempt += 1) {
+				const before = await readMutationEpoch(resolvedRoot);
+				if (isOdd(before)) {
+					await waitForActiveMutationEpoch(resolvedRoot, before, options);
+					continue;
+				}
+				const result = await read();
+				const after = await readMutationEpoch(resolvedRoot);
+				if (before === after && !isOdd(after)) return result;
+				if (isOdd(after)) await waitForActiveMutationEpoch(resolvedRoot, after, options);
 			}
-			const result = await read();
-			const after = await readMutationEpoch(resolvedRoot);
-			if (before === after && !isOdd(after)) return result;
-			if (isOdd(after)) await waitForActiveMutationEpoch(resolvedRoot, after, options);
-		}
-		throw new Error("knowledge read could not observe a stable mutation epoch");
-	});
+			throw new Error("knowledge read could not observe a stable mutation epoch");
+		});
+	} finally {
+		leave();
+	}
 }
 async function acquireDurableFileLock(target, options) {
 	const stale = Math.max(5e3, options.staleMs ?? DEFAULT_STALE_MS);
@@ -3686,6 +3794,26 @@ function knowledgePageDigest(page) {
 }
 /** Snapshot the exact ordered current/ancestor/shared page view. */
 function createKnowledgeVisibilitySnapshot(visiblePages) {
+	return snapshotVisibility(visiblePages, knowledgePageDigest);
+}
+/**
+* Snapshot a view whose pages are immutable, hashing each page object once across views.
+* The caller guarantees no page in `visiblePages` can change after this call.
+*/
+function snapshotImmutableVisibility(visiblePages) {
+	return snapshotVisibility(visiblePages, immutablePageDigest);
+}
+const immutablePageDigests = /* @__PURE__ */ new WeakMap();
+/** `knowledgePageDigest` memoized by object identity, for pages that are deeply frozen. */
+function immutablePageDigest(page) {
+	let pageDigest = immutablePageDigests.get(page);
+	if (pageDigest === void 0) {
+		pageDigest = knowledgePageDigest(page);
+		if (Object.isFrozen(page)) immutablePageDigests.set(page, pageDigest);
+	}
+	return pageDigest;
+}
+function snapshotVisibility(visiblePages, digestOf) {
 	if (!Array.isArray(visiblePages)) throw new TypeError("knowledge visibility must be an array");
 	const identities = /* @__PURE__ */ new Set();
 	const entries = visiblePages.map((entry, position) => {
@@ -3700,20 +3828,35 @@ function createKnowledgeVisibilitySnapshot(visiblePages) {
 			pageId: entry.page.id,
 			origin,
 			path: entry.page.path,
-			pageDigest: knowledgePageDigest(entry.page),
+			pageDigest: digestOf(entry.page),
 			sourceIds: Object.freeze([...entry.page.sourceIds]),
 			invalidated: entry.page.invalidation !== void 0
 		});
 	});
 	const material = visibilityMaterial(entries);
+	const materialBytes = canonicalCandidateBytes(material);
+	const snapshotDigest = sha256Bytes(materialBytes);
 	const snapshot = Object.freeze({
 		...material,
-		snapshotDigest: canonicalCandidateDigest(material),
+		snapshotDigest,
 		entries: Object.freeze(entries)
 	});
 	visibilityIndexes.set(snapshot, indexVisibility(snapshot));
+	encodedSnapshots.set(snapshot, encodedFromMaterial(materialBytes, snapshotDigest));
 	return snapshot;
 }
+const encodedSnapshots = /* @__PURE__ */ new WeakMap();
+/**
+* RFC 8785 orders `snapshotDigest` after every material key, so the stored encoding is the
+* material's canonical bytes with that one member appended before the closing brace.
+*/
+function encodedFromMaterial(materialBytes, snapshotDigest) {
+	const member = new TextEncoder().encode(`,"snapshotDigest":${JSON.stringify(snapshotDigest)}}`);
+	const encoded = new Uint8Array(materialBytes.byteLength - 1 + member.byteLength);
+	encoded.set(materialBytes.subarray(0, materialBytes.byteLength - 1));
+	encoded.set(member, materialBytes.byteLength - 1);
+	return encoded;
+}
 /**
 * Verify a snapshot's schema and canonical digest. The check runs once per
 * snapshot object; later calls with the same object are free.
@@ -3724,6 +3867,8 @@ function verifyKnowledgeVisibilitySnapshot(snapshot) {
 /** Canonical bytes of a verified snapshot, for durable storage. */
 function encodeKnowledgeVisibilitySnapshot(snapshot) {
 	const verified = verifyKnowledgeVisibilitySnapshot(snapshot);
+	const encoded = encodedSnapshots.get(verified);
+	if (encoded !== void 0) return encoded.slice();
 	return canonicalCandidateBytes({
 		schemaVersion: verified.schemaVersion,
 		digestAlgorithm: verified.digestAlgorithm,
@@ -3978,43 +4123,92 @@ function createRunScopedStores(options) {
 		}
 	};
 	const roots = /* @__PURE__ */ new Map();
-	let cachedBytes = 0;
 	let current;
-	const readRoot = async (root) => {
-		const loaded = await withKnowledgeRead(root, async () => {
-			let files;
+	const loadRoot = (root, previous) => withKnowledgeRead(root, async () => {
+		let listed;
+		try {
+			listed = await listRegularFileMetadataWithinRoot(root, pagesDirectory);
+		} catch (error) {
+			if (!isMissingFile(error)) throw error;
+			listed = [];
+		}
+		const generation = JSON.stringify(listed.map((file) => [file.path, file.generation]));
+		if (previous?.generation === generation) return previous;
+		const files = /* @__PURE__ */ new Map();
+		const changed = [];
+		for (const file of listed) {
+			const known = previous?.files.get(file.path);
+			if (known?.generation === file.generation) files.set(file.path, known);
+			else if (!isKnowledgePagePath(file.path)) files.set(file.path, {
+				generation: file.generation,
+				page: void 0
+			});
+			else changed.push(file);
+		}
+		const parse = (path, generation, bytes) => files.set(path, {
+			generation,
+			page: freezeView(knowledgePageFromMarkdown(path, bytes.toString("utf8"), pagesDirectory))
+		});
+		if (changed.length > 64) {
+			const wanted = new Map(changed.map((file) => [file.path, file.generation]));
+			for (const file of await listRegularFilesWithinRoot(root, pagesDirectory)) {
+				const generation = wanted.get(file.path);
+				if (generation !== void 0) parse(file.path, generation, file.bytes);
+			}
+		} else await Promise.all(changed.map(async (file) => {
 			try {
-				files = await listRegularFileMetadataWithinRoot(root, pagesDirectory);
+				parse(file.path, file.generation, (await readRegularFileWithinRoot(root, file.path)).bytes);
 			} catch (error) {
 				if (!isMissingFile(error)) throw error;
-				files = [];
 			}
-			const generation = JSON.stringify(files.map((file) => [file.path, file.generation]));
-			const previous = roots.get(root);
-			if (previous?.generation === generation) return previous;
-			const pages = await loadKnowledgePages(root, { pagesDirectory });
-			return {
-				generation,
-				bytes: files.reduce((sum, file) => sum + file.bytes, 0),
-				pages: freezeView(pages)
-			};
+		}));
+		const pages = Object.freeze([...files.values()].flatMap((file) => file.page ? [file.page] : []).sort((a, b) => a.path.localeCompare(b.path)));
+		return {
+			generation,
+			bytes: listed.reduce((sum, file) => sum + file.bytes, 0),
+			files,
+			pages
+		};
+	});
+	const refreshes = /* @__PURE__ */ new Map();
+	const readRoot = (root) => {
+		let state = refreshes.get(root);
+		if (!state) {
+			state = {};
+			refreshes.set(root, state);
+		}
+		const slot = state;
+		const start = () => {
+			const running = loadRoot(root, roots.get(root)).then((loaded) => retain(root, loaded)).finally(() => {
+				if (slot.running === running) slot.running = void 0;
+				if (!slot.running && !slot.next && refreshes.get(root) === slot) refreshes.delete(root);
+			});
+			slot.running = running;
+			return running;
+		};
+		if (slot.next) return slot.next;
+		if (!slot.running) return start();
+		const next = slot.running.catch(() => void 0).then(() => {
+			slot.next = void 0;
+			return start();
 		});
+		slot.next = next;
+		return next;
+	};
+	const retain = (root, loaded) => {
 		const existing = roots.get(root);
 		if (existing?.generation === loaded.generation) return existing;
-		if (existing) {
-			roots.delete(root);
-			cachedBytes -= existing.bytes;
-		}
-		if (loaded.bytes <= MAX_CACHED_SOURCE_BYTES) {
-			while (roots.size >= MAX_CACHED_ROOTS || cachedBytes + loaded.bytes > MAX_CACHED_SOURCE_BYTES) {
-				const oldest = roots.keys().next().value;
-				if (oldest === void 0) break;
-				cachedBytes -= roots.get(oldest).bytes;
-				roots.delete(oldest);
-				current = void 0;
-			}
-			roots.set(root, loaded);
-			cachedBytes += loaded.bytes;
+		roots.delete(root);
+		roots.set(root, loaded);
+		const live = new Set(current?.identities.map((identity) => JSON.parse(identity)[0]));
+		live.add(root);
+		let bytes = 0;
+		for (const part of roots.values()) bytes += part.bytes;
+		for (const [candidate, part] of roots) {
+			if (roots.size <= MAX_CACHED_ROOTS && bytes <= MAX_CACHED_SOURCE_BYTES) break;
+			if (live.has(candidate)) continue;
+			roots.delete(candidate);
+			bytes -= part.bytes;
 		}
 		return loaded;
 	};
@@ -4033,19 +4227,19 @@ function createRunScopedStores(options) {
 			origin: "shared"
 		});
 		const identities = scopes.map(({ root, origin }) => JSON.stringify([root, origin]));
-		const parts = [];
-		for (const scope of scopes) parts.push(await readRoot(scope.root));
-		if (current && identities.length === current.identities.length && identities.every((id, i) => id === current.identities[i] && parts[i] === current.parts[i])) return current.chain;
+		const parts = await Promise.all(scopes.map((scope) => readRoot(scope.root)));
+		const latest = current;
+		if (latest && identities.length === latest.identities.length && identities.every((id, i) => id === latest.identities[i] && parts[i] === latest.parts[i])) return latest.chain;
 		const chain = Object.freeze(parts.flatMap((part, i) => part.pages.map((page) => Object.freeze({
 			page,
 			origin: scopes[i].origin
 		}))));
 		toolViews.add(chain);
-		current = parts.length <= MAX_CACHED_ROOTS && parts.reduce((sum, part) => sum + part.bytes, 0) <= MAX_CACHED_SOURCE_BYTES ? {
+		current = {
 			identities,
 			parts,
 			chain
-		} : void 0;
+		};
 		return chain;
 	});
 	return stores;
@@ -4439,6 +4633,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-export { writeSourceRegistry as $, ClaimLedgerGoalConflictError as $t, verifyKnowledgeVisibilitySnapshot as A, rollbackKnowledgeFileTransaction as An, loadKnowledgePages as At, assertGradeableEvidence as B, relativeWithinRoot as Bn, KnowledgeIndexSchema as Bt, knowledgePageDigest as C, withKnowledgeRead as Cn, resolveRunScopedCitations as Ct, normalizeVisibilityRef as D, finishKnowledgeFileTransaction as Dn, isScaffoldPath as Dt, normalizeVisibilityArtifact as E, commitKnowledgeFileMutations as En, isKnowledgePagePath as Et, validateKnowledgeIndex as F, isKernelAnchoredPath as Fn, DeepQuestionSchema as Ft, verifyGradeableEvidence as G, withSafeDirectory as Gn, KnowledgeRelationSchema as Gt, gradeClaims as H, renameDurable as Hn, KnowledgePageSchema as Ht, lintKnowledgeIndex as I, isMissingFile as In, KnowledgeBaseCandidateSchema as It, addSourcePath as J, writeJsonDurable as Jn, ResearchClaimRecordSchema as Jt, buildKnowledgeIndex as K, writeFileDurable as Kn, ResearchClaimEvidenceSchema as Kt, CHECKABLE_RUNG_THRESHOLD as L, listRegularFilesWithinRoot as Ln, KnowledgeEventSchema as Lt, visibilityIndexOf as M, normalizePagesDirectory as Mn, WIKILINK_REGEX as Mt, detectNearDuplicatePages as N, canonicalPathsEqual as Nn, extractWikilinks as Nt, validateKnowledgePage as O, knowledgeFileTransactionPlanHash as On, knowledgePageFromMarkdown as Ot, normalizePageText as P, canonicalRelativeWithinRoot as Pn, normalizeLinkTarget as Pt, sourceRegistryPath as Q, KNOWLEDGE_EVENT_TYPES as Qt, DEADLINE_EXIT_CODE as R, readRegularFileNoFollow as Rn, KnowledgeGraphEdgeSchema as Rt, encodeKnowledgeVisibilitySnapshot as S, withKnowledgeMutation as Sn, resolveRunScopedCitation as St, nonEmpty as T, assertKnowledgeMutationPath as Tn, initKnowledgeBase as Tt, gradeFor as U, syncDirectory as Un, KnowledgeRelationGraphSchema as Ut, claimCheckKey as V, removeDurable as Vn, KnowledgePageInvalidationSchema as Vt, verdictFor as W, withSafeDescendant as Wn, KnowledgeRelationNodeSchema as Wt, loadSourceRegistry as X, mediaTypeFor$1 as Xn, SourceAnchorSchema as Xt, addSourceText as Y, writeJsonDurableWithinRoot as Yn, ResearchSourceVersionSchema as Yt, snapshotSourceTextInput as Z, textSourceAdapter as Zn, SourceRecordSchema as Zt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as _, acquireDurableFileLock as _n, auditKnowledgeCitations as _t, applyKnowledgeWriteBlocksFile as a, claimId as an, KB_STORE_DIR as at, decodeKnowledgeVisibilitySnapshot as b, recoverPendingKnowledgeMutation as bn, resolveKnowledgeCitation as bt, KnowledgeDuplicateIntakeError as c, emptyClaimLedger as cn, buildKnowledgeGraph as ct, createFileRunLineageAuthority as d, mergeClaimLedgers as dn, KnowledgeCitationResolutionError as dt, assertDeepQuestionIntegrity as en, ClaimLedgerMigrationRequiredError as et, createRunScopedStores as f, mergeTrackedClaims as fn, assertCurrentRunCitationsResolved as ft, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as g, parseFrontmatter as gn, auditCurrentRunCitations as gt, originatedPages as h, formatFrontmatter as hn, assertRunScopedCitationsResolved as ht, applyKnowledgeWriteBlocks as i, claimEvidenceId as in, KB_INDEX_PATH as it, visibilityIdentity as j, DEFAULT_PAGES_DIRECTORY as jn, writeJson as jt, validateOrigin as k, prepareKnowledgeFileTransaction as kn, layoutFor as kt, assertKnowledgeWriteIntake as l, linkClaimContradictions as ln, knowledgePageRelations as lt, loadKnowledgeToolChain as m, researchSourceVersionKey as mn, assertKnowledgeCitationsResolved as mt, inspectKnowledgeIndex as n, assertResearchClaimLedgerIntegrity as nn, KB_CLAIM_LEDGER_DIR as nt, isSafeKnowledgePath as o, claimSourceHost as on, MemoryKbStore as ot, isKnowledgeToolChain as p, normalizeClaimText as pn, assertKnowledgeCitationAudit as pt, writeKnowledgeIndex as q, writeFileDurableWithinRoot as qn, ResearchClaimLedgerSchema as qt, stringMetadata as r, assertTrackedClaimIntegrity as rn, KB_EVENTS_PATH as rt, parseKnowledgeWriteBlocks as s, deepQuestionId as sn, assertClaimLedgerId as st, explainKnowledgeTarget as t, assertResearchClaimEvidenceIntegrity as tn, FileSystemKbStore as tt, RUN_LINEAGE_BASENAME as u, materializeRegisteredClaimEvidence as un, KnowledgeCitationAuditError as ut, assertSchemaVersion as v, inspectPendingKnowledgeMutation as vn, formatKnowledgeCitationReference as vt, knowledgeVisibilityArtifactRef as w, applyKnowledgeFileTransaction as wn, SCAFFOLD_PAGE_BASENAMES as wt, digest as x, runInKnowledgeMutationScope as xn, resolveKnowledgeCitations as xt, createKnowledgeVisibilitySnapshot as y, isKnowledgeMutationHeld as yn, parseKnowledgeCitationReference as yt, UncheckableClaimError as z, readRegularFileWithinRoot as zn, KnowledgeGraphNodeSchema as zt };
+export { snapshotSourceTextInput as $, mediaTypeFor$1 as $n, SourceRecordSchema as $t, validateKnowledgePage as A, finishKnowledgeFileTransaction as An, knowledgePageFromMarkdown as At, DEADLINE_EXIT_CODE as B, listRegularFilesWithinRoot as Bn, KnowledgeGraphEdgeSchema as Bt, immutablePageDigest as C, recoverPendingKnowledgeMutation as Cn, resolveKnowledgeCitations as Ct, normalizeVisibilityArtifact as D, applyKnowledgeFileTransaction as Dn, initKnowledgeBase as Dt, nonEmpty as E, withKnowledgeRead as En, SCAFFOLD_PAGE_BASENAMES as Et, detectNearDuplicatePages as F, normalizePagesDirectory as Fn, extractWikilinks as Ft, gradeFor as G, renameDurable as Gn, KnowledgeRelationGraphSchema as Gt, assertGradeableEvidence as H, readRegularFileWithinRoot as Hn, KnowledgeIndexSchema as Ht, normalizePageText as I, canonicalPathsEqual as In, normalizeLinkTarget as It, buildKnowledgeIndex as J, withSafeDirectory as Jn, ResearchClaimEvidenceSchema as Jt, verdictFor as K, syncDirectory as Kn, KnowledgeRelationNodeSchema as Kt, validateKnowledgeIndex as L, canonicalRelativeWithinRoot as Ln, DeepQuestionSchema as Lt, verifyKnowledgeVisibilitySnapshot as M, prepareKnowledgeFileTransaction as Mn, loadKnowledgePages as Mt, visibilityIdentity as N, rollbackKnowledgeFileTransaction as Nn, writeJson as Nt, normalizeVisibilityRef as O, assertKnowledgeMutationPath as On, isKnowledgePagePath as Ot, visibilityIndexOf as P, DEFAULT_PAGES_DIRECTORY as Pn, WIKILINK_REGEX as Pt, loadSourceRegistry as Q, writeJsonDurableWithinRoot as Qn, SourceAnchorSchema as Qt, lintKnowledgeIndex as R, isKernelAnchoredPath as Rn, KnowledgeBaseCandidateSchema as Rt, encodeKnowledgeVisibilitySnapshot as S, measureKnowledgeMutation as Sn, resolveKnowledgeCitation as St, knowledgeVisibilityArtifactRef as T, withKnowledgeMutation as Tn, resolveRunScopedCitations as Tt, claimCheckKey as U, relativeWithinRoot as Un, KnowledgePageInvalidationSchema as Ut, UncheckableClaimError as V, readRegularFileNoFollow as Vn, KnowledgeGraphNodeSchema as Vt, gradeClaims as W, removeDurable as Wn, KnowledgePageSchema as Wt, addSourcePath as X, writeFileDurableWithinRoot as Xn, ResearchClaimRecordSchema as Xt, writeKnowledgeIndex as Y, writeFileDurable as Yn, ResearchClaimLedgerSchema as Yt, addSourceText as Z, writeJsonDurable as Zn, ResearchSourceVersionSchema as Zt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as _, formatFrontmatter as _n, assertRunScopedCitationsResolved as _t, applyKnowledgeWriteBlocksFile as a, assertTrackedClaimIntegrity as an, KB_EVENTS_PATH as at, decodeKnowledgeVisibilitySnapshot as b, inspectPendingKnowledgeMutation as bn, formatKnowledgeCitationReference as bt, KnowledgeDuplicateIntakeError as c, claimSourceHost as cn, MemoryKbStore as ct, createFileRunLineageAuthority as d, linkClaimContradictions as dn, knowledgePageRelations as dt, KNOWLEDGE_EVENT_TYPES as en, textSourceAdapter as er, sourceRegistryPath as et, createRunScopedStores as f, materializeRegisteredClaimEvidence as fn, KnowledgeCitationAuditError as ft, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as g, researchSourceVersionKey as gn, assertKnowledgeCitationsResolved as gt, originatedPages as h, normalizeClaimText as hn, assertKnowledgeCitationAudit as ht, applyKnowledgeWriteBlocks as i, assertResearchClaimLedgerIntegrity as in, KB_CLAIM_LEDGER_DIR as it, validateOrigin as j, knowledgeFileTransactionPlanHash as jn, layoutFor as jt, snapshotImmutableVisibility as k, commitKnowledgeFileMutations as kn, isScaffoldPath as kt, assertKnowledgeWriteIntake as l, deepQuestionId as ln, assertClaimLedgerId as lt, loadKnowledgeToolChain as m, mergeTrackedClaims as mn, assertCurrentRunCitationsResolved as mt, inspectKnowledgeIndex as n, assertDeepQuestionIntegrity as nn, ClaimLedgerMigrationRequiredError as nt, isSafeKnowledgePath as o, claimEvidenceId as on, KB_INDEX_PATH as ot, isKnowledgeToolChain as p, mergeClaimLedgers as pn, KnowledgeCitationResolutionError as pt, verifyGradeableEvidence as q, withSafeDescendant as qn, KnowledgeRelationSchema as qt, stringMetadata as r, assertResearchClaimEvidenceIntegrity as rn, FileSystemKbStore as rt, parseKnowledgeWriteBlocks as s, claimId as sn, KB_STORE_DIR as st, explainKnowledgeTarget as t, ClaimLedgerGoalConflictError as tn, writeSourceRegistry as tt, RUN_LINEAGE_BASENAME as u, emptyClaimLedger as un, buildKnowledgeGraph as ut, assertSchemaVersion as v, parseFrontmatter as vn, auditCurrentRunCitations as vt, knowledgePageDigest as w, runInKnowledgeMutationScope as wn, resolveRunScopedCitation as wt, digest as x, isKnowledgeMutationHeld as xn, parseKnowledgeCitationReference as xt, createKnowledgeVisibilitySnapshot as y, acquireDurableFileLock as yn, auditKnowledgeCitations as yt, CHECKABLE_RUNG_THRESHOLD as z, isMissingFile as zn, KnowledgeEventSchema as zt };
 
-//# sourceMappingURL=inspect-CwIvMcno.js.map
+//# sourceMappingURL=inspect-C6c4zuKp.js.map