@gitroll/tacitt-cli 0.0.0-stage → 0.2.0

package/dist/codex-title-worker.mjs

@@ -0,0 +1,215 @@
+import { i as errorCode } from "./model-BJdTLNjT.mjs";
+import { a as titleHintLimits, i as encodeTitleError, o as titleInputSchema, t as assertTitleHeap } from "./heap-1FYhGds4.mjs";
+import { stat } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { parentPort, workerData } from "node:worker_threads";
+//#region packages/harnesses/src/metadata/codex-database/files.ts
+const absent = (error) => ["ENOENT", "ENOTDIR"].includes(errorCode(error) ?? "");
+async function databaseFile(path) {
+	try {
+		const value = await stat(path, { bigint: true });
+		if (!value.isFile() || value.size > BigInt(titleHintLimits.databaseBytes)) return null;
+		const wal = await stat(`${path}-wal`, { bigint: true }).catch((error) => {
+			if (absent(error)) return null;
+			throw error;
+		});
+		if (wal && (!wal.isFile() || wal.size > BigInt(titleHintLimits.databaseBytes))) return null;
+		return value;
+	} catch (error) {
+		if (absent(error)) return null;
+		throw error;
+	}
+}
+async function sameDatabase(path, before) {
+	const after = await databaseFile(path);
+	return after !== null && after.dev === before.dev && after.ino === before.ino;
+}
+function matches(value, source) {
+	const expected = source.snapshot;
+	return value.isFile() && value.dev.toString() === expected.dev && value.ino.toString() === expected.ino && value.size === BigInt(expected.size) && value.mtimeNs.toString() === expected.mtimeNs && value.ctimeNs.toString() === expected.ctimeNs;
+}
+/** Textual path equality never substitutes for the actual discovered physical snapshot. */
+async function boundRollout(path, source) {
+	if (!isAbsolute(path)) return false;
+	try {
+		const rollout = await stat(path, { bigint: true });
+		for (const part of source.parts) {
+			if (!matches(rollout, part)) continue;
+			if (matches(await stat(part.path, { bigint: true }), part)) return true;
+		}
+		return false;
+	} catch (error) {
+		if (absent(error)) return false;
+		throw error;
+	}
+}
+//#endregion
+//#region packages/harnesses/src/metadata/codex-database/rows.ts
+const maximum = titleHintLimits.fieldBytes;
+const bounded = (column, bytes = maximum) => `CASE WHEN typeof(${column}) = 'text' AND length(CAST(${column} AS BLOB)) <= ${bytes} THEN ${column} ELSE NULL END`;
+const limited = (column) => `CASE WHEN ${column} IS NULL OR (typeof(${column}) = 'text' AND length(CAST(${column} AS BLOB)) <= ${maximum}) THEN 0 ELSE 1 END`;
+function requireColumns(db, table, fields) {
+	const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+	const names = new Set(columns.map((row) => row["name"]));
+	if (fields.some((name) => !names.has(name))) throw new Error("CODEX_TITLE_SCHEMA_UNAVAILABLE");
+	return names;
+}
+function threadQuery(db) {
+	const name = requireColumns(db, "threads", [
+		"id",
+		"rollout_path",
+		"title",
+		"first_user_message",
+		"preview"
+	]).has("name") ? "name" : "NULL";
+	return db.prepare(`SELECT id, ${bounded("rollout_path", 16384)} AS path,
+    CASE WHEN ${name} IS NULL OR ${name} = '' THEN 0 ELSE 1 END AS named,
+    ${bounded(name)} AS name, ${bounded("title")} AS title,
+    substr(CAST(first_user_message AS BLOB), 1, ${maximum}) AS first,
+    ${limited("first_user_message")} AS firstLimited,
+    substr(CAST(preview AS BLOB), 1, ${maximum}) AS preview,
+    ${limited("preview")} AS previewLimited
+    FROM threads WHERE id = ? LIMIT 2`);
+}
+function desktopQuery(db) {
+	requireColumns(db, "local_thread_catalog", [
+		"thread_id",
+		"host_id",
+		"display_title",
+		"missing_candidate",
+		"pending_observed_title"
+	]);
+	requireColumns(db, "local_thread_catalog_hosts", ["host_id", "host_kind"]);
+	return db.prepare(`SELECT ${bounded("catalog.display_title")} AS title
+    FROM local_thread_catalog AS catalog
+    JOIN local_thread_catalog_hosts AS hosts ON hosts.host_id = catalog.host_id
+    WHERE catalog.thread_id = ? AND hosts.host_kind = 'local'
+      AND catalog.missing_candidate = 0 AND catalog.pending_observed_title = 0 LIMIT 9`);
+}
+const normalize$1 = (value) => value.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, " ").replace(/\s+/gu, " ").trim();
+function displayFallback(title, source) {
+	if (source === null) return false;
+	if (!(source instanceof Uint8Array)) return true;
+	let message;
+	try {
+		message = normalize$1(new TextDecoder("utf-8", { fatal: true }).decode(source));
+	} catch {
+		return true;
+	}
+	const candidate = normalize$1(title).replace(/(?:\.{3}|\u2026)$/u, "").trimEnd();
+	return !!message && (!candidate || message.startsWith(candidate));
+}
+function independentTitle(row) {
+	if (row["firstLimited"] !== 0 || row["previewLimited"] !== 0) return null;
+	const value = row["title"];
+	if (typeof value !== "string" || !normalize$1(value)) return null;
+	if (displayFallback(value, row["first"]) || displayFallback(value, row["preview"])) return null;
+	return value;
+}
+function corroborates(rows, title) {
+	return rows.length > 0 && rows.length <= 8 && rows.every((row) => row["title"] === title);
+}
+//#endregion
+//#region packages/harnesses/src/metadata/codex-database/read.ts
+function openDatabase(path) {
+	const db = new DatabaseSync(path, {
+		readOnly: true,
+		timeout: 0,
+		allowExtension: false
+	});
+	try {
+		db.exec("PRAGMA query_only = ON; PRAGMA trusted_schema = OFF; PRAGMA cache_size = -4096; BEGIN");
+		return db;
+	} catch (error) {
+		try {
+			db.close();
+		} catch (cleanupError) {
+			throw new AggregateError([error, cleanupError], "CODEX_TITLE_DATABASE_UNAVAILABLE", { cause: error });
+		}
+		throw error;
+	}
+}
+function closeDatabases(databases, failure) {
+	const errors = [];
+	for (const db of databases) {
+		if (!db) continue;
+		try {
+			db.exec("ROLLBACK");
+			db.close();
+		} catch (error) {
+			errors.push(error);
+			try {
+				db.close();
+			} catch (cleanupError) {
+				errors.push(cleanupError);
+			}
+		}
+	}
+	if (errors.length) throw new AggregateError(failure === void 0 ? errors : [failure, ...errors], "CODEX_TITLE_DATABASE_CLOSE_FAILED", failure === void 0 ? void 0 : { cause: failure });
+}
+/** Invoked only inside the isolated title Worker in production. */
+async function readDatabaseTitles(input) {
+	const { home, sources } = titleInputSchema.parse(input);
+	const byId = new Map(sources.map((source) => [source.sourceSessionId, source]));
+	const primaryPath = join(home, "state_5.sqlite");
+	const desktopPath = join(home, "sqlite", "codex-dev.db");
+	const primaryFile = await databaseFile(primaryPath);
+	if (!primaryFile) return [];
+	const primary = openDatabase(primaryPath);
+	let desktop;
+	let failure;
+	try {
+		const query = threadQuery(primary);
+		const desktopFile = await databaseFile(desktopPath);
+		if (desktopFile) desktop = openDatabase(desktopPath);
+		const legacy = desktop ? desktopQuery(desktop) : null;
+		const names = [];
+		let bytes = 2;
+		for (const source of sources) {
+			const rows = query.all(source.sourceSessionId);
+			const row = rows.length === 1 ? rows[0] : void 0;
+			if (!row || row["id"] !== source.sourceSessionId || typeof row["path"] !== "string") continue;
+			if (!await boundRollout(row["path"], source)) continue;
+			const title = row["named"] === 1 ? typeof row["name"] === "string" ? row["name"] : "" : independentTitle(row);
+			if (title === null) continue;
+			if (row["named"] !== 1 && (!legacy || !corroborates(legacy.all(source.sourceSessionId), title))) continue;
+			const entry = [source.sourceSessionId, title];
+			const next = Buffer.byteLength(JSON.stringify(entry)) + 1;
+			if (bytes + next > titleHintLimits.resultBytes) break;
+			bytes += next;
+			names.push(entry);
+		}
+		if (!await sameDatabase(primaryPath, primaryFile)) return [];
+		if (desktopFile && !await sameDatabase(desktopPath, desktopFile)) return [];
+		for (const [id] of names) {
+			const source = byId.get(id);
+			const row = query.get(id);
+			if (!source || !row || typeof row["path"] !== "string") return [];
+			if (!await boundRollout(row["path"], source)) return [];
+		}
+		return names;
+	} catch (error) {
+		failure = error;
+		throw error;
+	} finally {
+		closeDatabases([desktop, primary], failure);
+	}
+}
+//#endregion
+//#region packages/harnesses/src/metadata/codex-database/worker.ts
+if (!parentPort) throw new Error("CODEX_TITLE_WORKER_REQUIRED");
+try {
+	assertTitleHeap();
+	parentPort.postMessage({
+		kind: "result",
+		names: await readDatabaseTitles(workerData)
+	});
+} catch (error) {
+	parentPort.postMessage({
+		kind: "error",
+		error: encodeTitleError(error)
+	});
+}
+//#endregion
+export {};

package/dist/configured-preview-worker.mjs

@@ -0,0 +1,133 @@
+import { J as createConfiguredPreviewStream } from "./src-k0Ya1Bri.mjs";
+import { rn as workspaceSchema, tn as sessionSchema, yn as createStaticProcessor } from "./locate-U3-nkird.mjs";
+import { l as createNativeAdapters, u as createGitNameSeedProvider } from "./src-B5SArpVY.mjs";
+import { ni as effectiveTreatmentSchema } from "./src-CC95LYYp.mjs";
+import { a as classifyRecord, n as assertPreviewHeap, t as runPreview } from "./run-BeLHsZWb.mjs";
+import { z } from "zod";
+import { parentPort, workerData } from "node:worker_threads";
+//#region apps/cli/src/preview/run.ts
+async function runConfiguredPreview(request, cursor, processing, signal, notify) {
+	const source = await createConfiguredPreviewStream(request, processing, signal, (active) => {
+		notify({ kind: active ? "processing-start" : "processing-end" });
+	});
+	try {
+		let selected = /* @__PURE__ */ new Set();
+		let modes = [];
+		let ordinal = 0;
+		const input = {
+			sourceVersion: request.sourceVersion,
+			async *countStream(part) {
+				const sourceRole = source.sourceRole(part);
+				for await (const { text } of source.records(part, true)) yield {
+					kind: "record",
+					value: JSON.parse(text),
+					bytes: Buffer.byteLength(text),
+					sourceRole
+				};
+			},
+			select(summary, ordinals) {
+				selected = new Set(ordinals);
+				modes = summary.parts.map((part) => part.mode);
+			},
+			async *stream(part) {
+				const sourceRole = source.sourceRole(part);
+				const mode = modes[request.session.parts.findIndex((item) => item.id === part.id)];
+				if (!mode) throw new Error("PREVIEW_WITHHELD");
+				let retained;
+				const include = (text) => {
+					const value = JSON.parse(text);
+					const boundary = classifyRecord(value, request.session.harness, sourceRole);
+					retained = boundary;
+					if (mode === "event" ? boundary.eventUser : boundary.responseUser) ordinal++;
+					return selected.has(ordinal);
+				};
+				for await (const { text, processed } of source.records(part, false, include)) {
+					const value = JSON.parse(text);
+					if (processed) {
+						const boundary = classifyRecord(value, request.session.harness, sourceRole);
+						if (boundary.responseUser !== retained?.responseUser || boundary.eventUser !== retained.eventUser || boundary.known !== retained.known) throw new Error("PREVIEW_ENVELOPE_CHANGED");
+						yield {
+							kind: "record",
+							value,
+							bytes: Buffer.byteLength(text),
+							sourceRole
+						};
+					} else yield {
+						kind: "boundary",
+						...classifyRecord(value, request.session.harness, sourceRole),
+						bytes: 0
+					};
+				}
+			},
+			presentation: {
+				records: async (records) => JSON.stringify(records),
+				text: async (text) => text
+			},
+			processing: () => {
+				const text = source.metadata();
+				const metadataWithheld = Buffer.byteLength(text) > 16384;
+				return {
+					kind: "configured",
+					configurationId: request.treatment.id,
+					metadata: metadataWithheld ? null : text,
+					metadataWithheld
+				};
+			}
+		};
+		return await runPreview(request.session, cursor, notify, input);
+	} finally {
+		await source.close();
+	}
+}
+//#endregion
+//#region apps/cli/src/preview/worker.ts
+const inputSchema = z.object({
+	request: z.object({
+		session: sessionSchema,
+		workspace: workspaceSchema,
+		treatment: effectiveTreatmentSchema,
+		customTerms: z.object({
+			revision: z.string().min(1).max(64),
+			terms: z.array(z.string().max(1024)).max(1e5)
+		}).optional(),
+		sourceVersion: z.string().regex(/^[a-f0-9]{64}$/)
+	}),
+	cursor: z.string().max(128).nullable(),
+	environment: z.object({
+		platform: z.enum(["posix", "windows"]),
+		userHome: z.string().optional(),
+		temporaryRoots: z.array(z.string())
+	})
+});
+function notify(message) {
+	parentPort?.postMessage(message);
+}
+assertPreviewHeap();
+try {
+	const data = workerData;
+	const input = inputSchema.parse(data);
+	const environment = {
+		platform: input.environment.platform,
+		...input.environment.userHome === void 0 ? {} : { userHome: input.environment.userHome },
+		temporaryRoots: input.environment.temporaryRoots
+	};
+	const processing = {
+		adapters: createNativeAdapters(),
+		gitNames: createGitNameSeedProvider(),
+		processor: createStaticProcessor(),
+		environment,
+		limits: { maxUnitMs: 2e3 }
+	};
+	const signal = new AbortController().signal;
+	notify({
+		kind: "result",
+		page: await runConfiguredPreview(input.request, input.cursor, processing, signal, notify)
+	});
+} catch (error) {
+	notify({
+		kind: "error",
+		code: error instanceof Error && error.message === "PROCESSING_PROTECTED_CUSTOM_TERM" ? "PROCESSING_PROTECTED_CUSTOM_TERM" : error instanceof Error && error.message === "INVALID_PREVIEW_CURSOR" ? "INVALID_PREVIEW_CURSOR" : error instanceof Error && error.message === "PREVIEW_ENVELOPE_CHANGED" ? "PREVIEW_ENVELOPE_CHANGED" : error instanceof Error && ["SOURCE_CHANGED", "ARTIFACT_SOURCE_CHANGED"].includes(error.message) ? "SOURCE_CHANGED" : "PREVIEW_WITHHELD"
+	});
+}
+//#endregion
+export {};

package/dist/configured-session-worker.mjs

@@ -0,0 +1,117 @@
+import { A as runConfiguredSessionJob, Q as safeError, R as gitSeedsProvider, m as captureConfiguredSessionJob, u as runConfiguredScanJob } from "./src-k0Ya1Bri.mjs";
+import { yn as createStaticProcessor } from "./locate-U3-nkird.mjs";
+import { l as createNativeAdapters } from "./src-B5SArpVY.mjs";
+import { i as runJourneyOutputVerifyJob, n as runJourneyOutputJob, r as runJourneyOutputShardJob } from "./job-J3NFw3MH.mjs";
+import { parentPort } from "node:worker_threads";
+//#region apps/cli/src/configured-session-worker.ts
+const port = parentPort;
+const adapters = createNativeAdapters();
+const processor = createStaticProcessor();
+function post(message) {
+	port?.postMessage(message);
+}
+function isCaptureRequest(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "kind") === "capture";
+}
+function isRenderRequest(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "kind") === "render";
+}
+function isScanRequest(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "kind") === "scan";
+}
+function isJourneyOutputRequest(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "kind") === "journey-output";
+}
+function isJourneyOutputShardRequest(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "kind") === "journey-output-shard";
+}
+function isJourneyOutputVerifyRequest(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "kind") === "journey-output-verify";
+}
+function failureSourceId(error) {
+	let current = error;
+	for (let depth = 0; depth < 8 && current instanceof Error; depth++) {
+		const match = /configured record source=([A-Za-z0-9]+)/.exec(current.message);
+		if (match) return match[1];
+		current = current.cause;
+	}
+}
+function reportFailure(error) {
+	const code = safeError(error).message;
+	const sourceId = failureSourceId(error);
+	post({
+		kind: "error",
+		code,
+		...sourceId === void 0 ? {} : { sourceId }
+	});
+}
+function processingFor(job) {
+	return {
+		adapters,
+		processor,
+		..."customTerms" in job && job.customTerms ? { customTerms: job.customTerms } : {},
+		environment: job.environment,
+		...job.limits === void 0 ? {} : { limits: job.limits },
+		gitNames: gitSeedsProvider("gitSeeds" in job ? job.gitSeeds : [])
+	};
+}
+port?.on("message", async (message) => {
+	const signal = new AbortController().signal;
+	try {
+		if (isCaptureRequest(message)) post({
+			kind: "result",
+			result: await captureConfiguredSessionJob(message.job, signal)
+		});
+		else if (isScanRequest(message)) post({
+			kind: "result",
+			result: await runConfiguredScanJob(message.job, processingFor(message.job), signal, (bytes) => post({
+				kind: "source",
+				bytes
+			}), (path) => post({
+				kind: "spool",
+				path
+			}))
+		});
+		else if (isJourneyOutputRequest(message)) post({
+			kind: "result",
+			result: await runJourneyOutputJob(message.job, {
+				adapters,
+				processor
+			}, signal, (path) => post({
+				kind: "spool",
+				path
+			}))
+		});
+		else if (isJourneyOutputShardRequest(message)) post({
+			kind: "result",
+			result: await runJourneyOutputShardJob(message.job, {
+				adapters,
+				processor
+			}, signal, (path) => post({
+				kind: "spool",
+				path
+			}))
+		});
+		else if (isJourneyOutputVerifyRequest(message)) post({
+			kind: "result",
+			result: await runJourneyOutputVerifyJob(message.job, signal)
+		});
+		else if (isRenderRequest(message)) {
+			const job = message.job;
+			post({
+				kind: "result",
+				result: await runConfiguredSessionJob(job, processingFor(job), signal, (bytes) => post({
+					kind: "source",
+					bytes
+				}), (path) => post({
+					kind: "spool",
+					path
+				}))
+			});
+		}
+	} catch (error) {
+		reportFailure(error);
+	}
+});
+//#endregion
+export {};

package/dist/frame-waS5FnN5.mjs

@@ -0,0 +1,84 @@
+import { nr as ProcessingError } from "./locate-U3-nkird.mjs";
+//#region packages/processing/src/compression/frame.ts
+function createZstdFrameCheck(fail = () => {
+	throw new ProcessingError("PROCESSING_INVALID_RECORD");
+}) {
+	let stage = "magic";
+	let remaining = 4;
+	let bytes = [];
+	let checksum = false;
+	let lastBlock = false;
+	let frames = 0;
+	function next(nextStage, size) {
+		stage = nextStage;
+		remaining = size;
+		bytes = [];
+	}
+	function advance() {
+		const value = bytes.reduce((total, byte, index) => total + byte * 256 ** index, 0);
+		switch (stage) {
+			case "magic":
+				if (value === 4247762216) next("descriptor", 1);
+				else if (value >= 407710288 && value <= 407710303) next("skip-size", 4);
+				else fail();
+				break;
+			case "descriptor": {
+				if (value & 8) fail();
+				const single = (value & 32) !== 0;
+				const contentFlag = value >>> 6;
+				const dictionaryFlag = value & 3;
+				const contentSize = contentFlag === 0 ? Number(single) : 2 ** contentFlag;
+				const dictionarySize = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+				checksum = (value & 4) !== 0;
+				next("header", Number(!single) + contentSize + dictionarySize);
+				break;
+			}
+			case "header":
+				next("block", 3);
+				break;
+			case "block": {
+				const kind = value >>> 1 & 3;
+				const size = value >>> 3;
+				if (kind === 3 || size > 131072) fail();
+				lastBlock = (value & 1) !== 0;
+				next("body", kind === 1 ? 1 : size);
+				break;
+			}
+			case "body":
+				if (lastBlock) next("checksum", checksum ? 4 : 0);
+				else next("block", 3);
+				break;
+			case "skip-size":
+				next("skip-body", value);
+				break;
+			case "checksum":
+			case "skip-body":
+				frames++;
+				next("magic", 4);
+		}
+	}
+	return {
+		push(chunk) {
+			let offset = 0;
+			const boundaries = [];
+			while (offset < chunk.length || remaining === 0) {
+				if (remaining === 0) {
+					const previousFrames = frames;
+					advance();
+					if (frames !== previousFrames) boundaries.push(offset);
+					continue;
+				}
+				const length = Math.min(remaining, chunk.length - offset);
+				if (stage === "magic" || stage === "descriptor" || stage === "block" || stage === "skip-size") for (const byte of chunk.subarray(offset, offset + length)) bytes.push(byte);
+				offset += length;
+				remaining -= length;
+			}
+			return boundaries;
+		},
+		finish() {
+			if (stage !== "magic" || remaining !== 4 || frames === 0) fail();
+		}
+	};
+}
+//#endregion
+export { createZstdFrameCheck as t };

package/dist/heap-1FYhGds4.mjs

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { getHeapStatistics } from "node:v8";
+//#region packages/harnesses/src/metadata/codex-database/protocol.ts
+const titleHintLimits = {
+	milliseconds: 1e4,
+	candidates: 4096,
+	inputBytes: 16777216,
+	databaseBytes: 67108864,
+	fieldBytes: 4096,
+	resultBytes: 16777216
+};
+const nativeId = z.string().regex(/^[A-Za-z0-9._:-]{1,128}$/u);
+const snapshot = z.object({
+	dev: z.string().max(128),
+	ino: z.string().max(128),
+	size: z.number().int().nonnegative(),
+	mtimeNs: z.string().max(128),
+	ctimeNs: z.string().max(128)
+});
+const titleSourceSchema = z.object({
+	sourceSessionId: nativeId,
+	parts: z.array(z.object({
+		path: z.string().min(1).max(16384),
+		snapshot
+	})).min(1).max(64)
+});
+const titleInputSchema = z.object({
+	home: z.string().min(1).max(16384),
+	sources: z.array(titleSourceSchema).max(titleHintLimits.candidates).refine((sources) => new Set(sources.map((source) => source.sourceSessionId)).size === sources.length)
+});
+const errorSchema = z.lazy(() => z.object({
+	name: z.string().max(128),
+	message: z.string().max(4096),
+	code: z.string().max(128).nullable(),
+	cause: errorSchema.nullable(),
+	errors: z.array(errorSchema).max(4)
+}));
+const nativeTitle = z.string().refine((value) => Buffer.byteLength(value) <= titleHintLimits.fieldBytes);
+const titleReplySchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("result"),
+	names: z.array(z.tuple([nativeId, nativeTitle])).max(titleHintLimits.candidates)
+}), z.object({
+	kind: z.literal("error"),
+	error: errorSchema
+})]);
+/** Only bounded error provenance crosses this private thread boundary; no stack is sent. */
+function encodeTitleError(error, depth = 0) {
+	const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+	return {
+		name: error instanceof Error ? error.name.slice(0, 128) : "Error",
+		message: error instanceof Error ? error.message.slice(0, 4096) : "Unknown title-reader failure",
+		code: typeof code === "string" ? code.slice(0, 128) : null,
+		cause: error instanceof Error && error.cause !== void 0 && depth < 4 ? encodeTitleError(error.cause, depth + 1) : null,
+		errors: error instanceof AggregateError && depth < 4 ? error.errors.slice(0, 4).map((value) => encodeTitleError(value, depth + 1)) : []
+	};
+}
+function decodeTitleError(value) {
+	const options = value.cause === null ? void 0 : { cause: decodeTitleError(value.cause) };
+	const error = value.errors.length ? new AggregateError(value.errors.map(decodeTitleError), value.message, options) : new Error(value.message, options);
+	error.name = value.name;
+	if (value.code !== null) Object.assign(error, { code: value.code });
+	return error;
+}
+//#endregion
+//#region packages/harnesses/src/metadata/codex-database/heap.ts
+const titleHeapLimits = {
+	maxOldGenerationSizeMb: 128,
+	maxYoungGenerationSizeMb: 32
+};
+/** This bounds V8 allocations; SQLite's native allocations are not covered. */
+function assertTitleHeap(bytes = getHeapStatistics().heap_size_limit) {
+	if (bytes < 128 * 1024 ** 2 || bytes > 224 * 1024 ** 2) throw new Error("CODEX_TITLE_HEAP_LIMIT_INVALID");
+}
+//#endregion
+export { titleHintLimits as a, encodeTitleError as i, titleHeapLimits as n, titleInputSchema as o, decodeTitleError as r, titleReplySchema as s, assertTitleHeap as t };