@silo-ai/silo 0.0.0 → 0.1.0

package/dist/bin.mjs

@@ -0,0 +1,3338 @@
+#!/usr/bin/env node
+import { binary, command, number, option, optional, positional, runSafely, string, subcommands } from "cmd-ts";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { File } from "cmd-ts/dist/cjs/batteries/fs.js";
+import { DatabaseSync, backup, constants } from "node:sqlite";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { isIP } from "node:net";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { createServer } from "node:http";
+import "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { promisify } from "node:util";
+//#region src/model.ts
+var SiloError = class extends Error {
+	exitCode;
+	code;
+	path;
+	constructor(exitCode, code, message, path = "") {
+		super(message);
+		this.name = "SiloError";
+		this.exitCode = exitCode;
+		this.code = code;
+		this.path = path;
+	}
+};
+const exits = {
+	input: 2,
+	workspace: 3,
+	absent: 4,
+	notFound: 5,
+	schema: 6,
+	constraint: 7,
+	revision: 8,
+	io: 9,
+	integrity: 10
+};
+//#endregion
+//#region src/lock.ts
+function ownerIsAlive(path) {
+	try {
+		const pid = Number(readFileSync(path, "utf8"));
+		if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+function acquireFileLock(path, message) {
+	for (let attempt = 0; attempt < 2; attempt++) {
+		let descriptor;
+		try {
+			descriptor = openSync(path, "wx");
+		} catch {
+			if (attempt === 0 && !ownerIsAlive(path)) {
+				rmSync(path, { force: true });
+				continue;
+			}
+			throw new SiloError(exits.io, "sync_in_progress", message);
+		}
+		try {
+			writeFileSync(descriptor, String(process.pid));
+		} finally {
+			closeSync(descriptor);
+		}
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			rmSync(path, { force: true });
+		};
+	}
+	throw new SiloError(exits.io, "sync_in_progress", message);
+}
+//#endregion
+//#region src/registry.ts
+function fail(column, message) {
+	throw new SiloError(exits.schema, "invalid_semantic_value", message, column.name);
+}
+const text = (validate, normalize, check) => ({
+	storage: "TEXT",
+	canonicalize(value, column) {
+		if (typeof value !== "string") fail(column, `${column.type} requires a JSON string.`);
+		if (validate && !validate(value, column)) fail(column, `Value is not valid for ${column.type}.`);
+		return normalize ? normalize(value, column) : value;
+	},
+	check: check ? (quotedColumn) => check(quotedColumn) : void 0
+});
+const integer = (validate, check, render) => ({
+	storage: "INTEGER",
+	canonicalize(value, column) {
+		if (typeof value === "boolean" && column.type === "integer/boolean") return value ? 1 : 0;
+		if (typeof value !== "number" || !Number.isSafeInteger(value) || validate && !validate(value)) fail(column, `Value is not valid for ${column.type}.`);
+		return value;
+	},
+	check: check ? (q) => check(q) : void 0,
+	render(value) {
+		return render ? render(value) : value;
+	}
+});
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ulid = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+const date = /^\d{4}-\d{2}-\d{2}$/;
+const time = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})?$/;
+const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const hostname = /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
+function calendarDate(value) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+	if (!match) return false;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	const date = new Date(Date.UTC(year, month - 1, day));
+	return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function decimal(value, column) {
+	const precision = column.type_options?.precision;
+	const scale = column.type_options?.scale;
+	if (!Number.isInteger(precision) || !Number.isInteger(scale) || precision <= 0 || scale < 0 || scale > precision) fail(column, "text/decimal requires integer precision and scale options with 0 <= scale <= precision.");
+	const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(value);
+	if (!match || (match[3]?.length ?? 0) > scale) fail(column, "Decimal value exceeds its configured scale or uses an unsupported form.");
+	const digits = match[2].replace(/^0+(?=\d)/, "");
+	if (digits.length + scale > precision) fail(column, "Decimal value exceeds its configured precision.");
+	return `${match[1] === "+" ? "" : match[1]}${digits}.${(match[3] ?? "").padEnd(scale, "0")}`.replace(/\.$/, "");
+}
+const semanticTypes = {
+	text: text(),
+	integer: integer(),
+	real: {
+		storage: "REAL",
+		canonicalize(value, column) {
+			if (typeof value !== "number" || !Number.isFinite(value)) fail(column, "real requires a finite JSON number.");
+			return value;
+		}
+	},
+	blob: {
+		storage: "BLOB",
+		canonicalize(value, column) {
+			if (typeof value !== "string") fail(column, "blob requires a base64 JSON string.");
+			return Uint8Array.from(Buffer.from(value, "base64"));
+		}
+	},
+	any: {
+		storage: "ANY",
+		canonicalize(value, column) {
+			if (typeof value === "boolean") return value ? 1 : 0;
+			if (typeof value === "string") return value;
+			if (typeof value === "number" && Number.isFinite(value)) return value;
+			fail(column, "any accepts only JSON strings, finite numbers, booleans, or null.");
+		}
+	},
+	"text/uuid": text((v) => uuid.test(v), (v) => v.toLowerCase(), (q) => `length(${q}) = 36 AND ${q} = lower(${q}) AND substr(${q}, 9, 1) = '-' AND substr(${q}, 14, 1) = '-' AND substr(${q}, 19, 1) = '-' AND substr(${q}, 24, 1) = '-' AND ${q} NOT GLOB '*[^0-9a-f-]*'`),
+	"text/ulid": text((v) => ulid.test(v), (v) => v.toUpperCase(), (q) => `length(${q}) = 26 AND ${q} = upper(${q}) AND ${q} NOT GLOB '*[^0-9A-HJKMNP-TV-Z]*'`),
+	"text/slug": text((v) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(v)),
+	"text/git-oid": text((v, c) => new RegExp(`^[0-9a-f]{${c.type_options?.length ?? "40|64"}}$`, "i").test(v), (v) => v.toLowerCase()),
+	"text/date": text((v) => date.test(v) && calendarDate(v)),
+	"text/time": text((v) => time.test(v)),
+	"text/datetime": text((v) => /^\d{4}-\d{2}-\d{2}T.+(?:Z|[+-]\d{2}:\d{2})$/.test(v) && !Number.isNaN(Date.parse(v)), (v) => new Date(v).toISOString(), (q) => `${q} GLOB '????-??-??T*Z'`),
+	"text/json": {
+		storage: "TEXT",
+		canonicalize(value, column) {
+			if (value === void 0 || typeof value === "bigint") fail(column, "text/json requires a JSON object, array, string, number, or boolean.");
+			try {
+				const json = JSON.stringify(value);
+				if (json === void 0) fail(column, "text/json requires a JSON object, array, string, number, or boolean.");
+				return json;
+			} catch {
+				fail(column, "Value cannot be represented as JSON.");
+			}
+		}
+	},
+	"text/markdown": text(),
+	"text/html": text(),
+	"text/url": text((v) => {
+		try {
+			const u = new URL(v);
+			return Boolean(u.protocol && u.hostname);
+		} catch {
+			return false;
+		}
+	}),
+	"text/uri": text((v) => /^[a-z][a-z0-9+.-]*:/i.test(v)),
+	"text/email": text((v) => email.test(v)),
+	"text/ip": text((v) => isIP(v) !== 0),
+	"text/cidr": text((v) => {
+		const [ip, bits] = v.split("/");
+		const family = isIP(ip ?? "");
+		return family !== 0 && /^\d+$/.test(bits ?? "") && Number(bits) <= (family === 4 ? 32 : 128);
+	}),
+	"text/hostname": text((v) => hostname.test(v), (v) => v.toLowerCase()),
+	"text/path": text((v) => !v.includes("\0")),
+	"text/path-posix": text((v) => !v.includes("\0") && !v.includes("\\")),
+	"text/path-relative": text((v) => !v.startsWith("/") && !v.split("/").includes("..")),
+	"text/git-ref": text((v) => !/\.\.|[~^:?*[\\\s]|(?:^|\/)\.|\.lock$|\/$/.test(v)),
+	"text/semver": text((v) => /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(v)),
+	"text/base64": text((v) => /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(v)),
+	"text/hex": text((v) => /^(?:[0-9a-f]{2})*$/i.test(v), (v) => v.toLowerCase()),
+	"text/sha256": text((v) => /^[0-9a-f]{64}$/i.test(v), (v) => v.toLowerCase()),
+	"text/sha512": text((v) => /^[0-9a-f]{128}$/i.test(v), (v) => v.toLowerCase()),
+	"text/decimal": text(void 0, decimal),
+	"text/enum": text((v, c) => Array.isArray(c.type_options?.values) && c.type_options.values.includes(v)),
+	"integer/boolean": integer((v) => v === 0 || v === 1, (q) => `${q} IN (0, 1)`, (value) => Boolean(value)),
+	"integer/positive": integer((v) => v > 0, (q) => `${q} > 0`),
+	"integer/nonnegative": integer((v) => v >= 0, (q) => `${q} >= 0`),
+	"integer/port": integer((v) => v >= 0 && v <= 65535, (q) => `${q} BETWEEN 0 AND 65535`),
+	"integer/unix-seconds": integer(),
+	"integer/unix-milliseconds": integer(),
+	"integer/duration-ms": integer((v) => v >= 0, (q) => `${q} >= 0`),
+	"integer/money-minor": integer(),
+	"real/percentage": {
+		storage: "REAL",
+		canonicalize(value, column) {
+			if (typeof value !== "number" || value < 0 || value > 1) fail(column, "real/percentage requires a number from 0 through 1.");
+			return value;
+		},
+		check: (q) => `${q} BETWEEN 0 AND 1`
+	},
+	"blob/bytes": {
+		storage: "BLOB",
+		canonicalize(value, column) {
+			if (typeof value !== "string") fail(column, "blob/bytes requires base64 input.");
+			return Uint8Array.from(Buffer.from(value, "base64"));
+		}
+	}
+};
+function semantic(column) {
+	const found = semanticTypes[column.type];
+	if (!found) throw new SiloError(exits.schema, "unknown_semantic_type", `${column.type} is not registered.`, `columns.${column.name}.type`);
+	return found;
+}
+function canonicalize(column, value) {
+	if (value === null) {
+		if (column.nullable === false) fail(column, "Column is not nullable.");
+		return null;
+	}
+	return semantic(column).canonicalize(value, column);
+}
+//#endregion
+//#region src/schema.ts
+const identifier = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const actions = /* @__PURE__ */ new Set([
+	"NO ACTION",
+	"RESTRICT",
+	"SET NULL",
+	"SET DEFAULT",
+	"CASCADE"
+]);
+function quote(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+function validateIdentifier(name, path) {
+	if (typeof name !== "string" || !identifier.test(name) || name.toLowerCase().startsWith("_silo_")) throw new SiloError(exits.schema, "invalid_identifier", "Expected a SQLite identifier outside the reserved _silo_ namespace.", path);
+}
+function assertObject(value, path) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new SiloError(exits.input, "invalid_shape", "Expected a JSON object.", path);
+}
+function rejectUnknown(object, allowed, path) {
+	const key = Object.keys(object).find((candidate) => !allowed.includes(candidate));
+	if (key) throw new SiloError(exits.input, "unknown_field", `Unknown field ${key}.`, `${path}.${key}`);
+}
+function parseTable(value) {
+	assertObject(value, "$.");
+	rejectUnknown(value, [
+		"name",
+		"comment",
+		"columns",
+		"primary_key",
+		"foreign_keys",
+		"unique_constraints",
+		"indexes",
+		"checks",
+		"policies",
+		"strict",
+		"without_rowid"
+	], "$.");
+	validateIdentifier(value.name, "$.name");
+	if (typeof value.comment !== "string" || !value.comment.trim()) throw new SiloError(exits.schema, "comment_required", "A non-empty table comment is required.", "$.comment");
+	if (!Array.isArray(value.columns)) throw new SiloError(exits.input, "invalid_shape", "columns must be an array.", "$.columns");
+	const table = value;
+	const names = /* @__PURE__ */ new Set();
+	for (const [i, column] of table.columns.entries()) {
+		assertObject(column, `$.columns[${i}]`);
+		rejectUnknown(column, [
+			"name",
+			"type",
+			"type_options",
+			"nullable",
+			"default",
+			"comment",
+			"collate",
+			"generated"
+		], `$.columns[${i}]`);
+		validateIdentifier(column.name, `$.columns[${i}].name`);
+		if (names.has(column.name.toLowerCase())) throw new SiloError(exits.schema, "duplicate_column", "Column names are case-insensitively unique.", `$.columns[${i}].name`);
+		names.add(column.name.toLowerCase());
+		if (typeof column.comment !== "string" || !column.comment.trim()) throw new SiloError(exits.schema, "comment_required", "A non-empty column comment is required.", `$.columns[${i}].comment`);
+		if (typeof column.type !== "string") throw new SiloError(exits.schema, "unknown_semantic_type", "A semantic type is required.", `$.columns[${i}].type`);
+		semantic(column);
+		if (column.default) {
+			assertObject(column.default, `$.columns[${i}].default`);
+			rejectUnknown(column.default, ["literal", "expression"], `$.columns[${i}].default`);
+			if (Number(Object.hasOwn(column.default, "literal")) + Number(Object.hasOwn(column.default, "expression")) !== 1) throw new SiloError(exits.schema, "invalid_default", "A default requires exactly one literal or expression.", `$.columns[${i}].default`);
+			if (Object.hasOwn(column.default, "literal")) canonicalize(column, column.default.literal);
+		}
+		if (column.generated) {
+			assertObject(column.generated, `$.columns[${i}].generated`);
+			rejectUnknown(column.generated, ["expression", "storage"], `$.columns[${i}].generated`);
+		}
+		if (column.default && column.generated) throw new SiloError(exits.schema, "incompatible_features", "A generated column cannot have a default.", `$.columns[${i}]`);
+	}
+	const has = (name) => names.has(name.toLowerCase());
+	for (const [i, name] of (table.primary_key ?? []).entries()) if (!has(name)) throw new SiloError(exits.schema, "missing_column", "Primary-key column does not exist.", `$.primary_key[${i}]`);
+	for (const [i, foreign] of (table.foreign_keys ?? []).entries()) {
+		assertObject(foreign, `$.foreign_keys[${i}]`);
+		rejectUnknown(foreign, [
+			"columns",
+			"references",
+			"on_update",
+			"on_delete",
+			"deferrable",
+			"initially_deferred"
+		], `$.foreign_keys[${i}]`);
+		assertObject(foreign.references, `$.foreign_keys[${i}].references`);
+		rejectUnknown(foreign.references, ["table", "columns"], `$.foreign_keys[${i}].references`);
+		if (!foreign.columns?.length || foreign.columns.length !== foreign.references?.columns?.length) throw new SiloError(exits.schema, "invalid_foreign_key", "Foreign-key column lists must be non-empty and have equal length.", `$.foreign_keys[${i}]`);
+		for (const name of foreign.columns) if (!has(name)) throw new SiloError(exits.schema, "missing_column", "Foreign-key column does not exist.", `$.foreign_keys[${i}].columns`);
+		validateIdentifier(foreign.references.table, `$.foreign_keys[${i}].references.table`);
+		for (const name of foreign.references.columns) validateIdentifier(name, `$.foreign_keys[${i}].references.columns`);
+		for (const action of [foreign.on_update, foreign.on_delete]) if (action && !actions.has(action)) throw new SiloError(exits.schema, "invalid_foreign_key_action", `${action} is not a SQLite foreign-key action.`, `$.foreign_keys[${i}]`);
+	}
+	for (const [i, unique] of (table.unique_constraints ?? []).entries()) {
+		assertObject(unique, `$.unique_constraints[${i}]`);
+		rejectUnknown(unique, ["name", "columns"], `$.unique_constraints[${i}]`);
+		if (!Array.isArray(unique.columns) || !unique.columns.length) throw new SiloError(exits.schema, "invalid_unique", "Unique constraints require columns.", `$.unique_constraints[${i}].columns`);
+		for (const column of unique.columns) if (!has(column)) throw new SiloError(exits.schema, "missing_column", "Unique column does not exist.", `$.unique_constraints[${i}].columns`);
+	}
+	for (const [i, index] of (table.indexes ?? []).entries()) {
+		assertObject(index, `$.indexes[${i}]`);
+		rejectUnknown(index, [
+			"name",
+			"columns",
+			"unique",
+			"where",
+			"comment"
+		], `$.indexes[${i}]`);
+		if (!Array.isArray(index.columns) || !index.columns.length) throw new SiloError(exits.schema, "invalid_index", "Indexes require columns or expressions.", `$.indexes[${i}].columns`);
+		for (const [j, part] of index.columns.entries()) {
+			assertObject(part, `$.indexes[${i}].columns[${j}]`);
+			rejectUnknown(part, [
+				"column",
+				"expression",
+				"direction",
+				"collate"
+			], `$.indexes[${i}].columns[${j}]`);
+			if (typeof part.column === "string" && !has(part.column)) throw new SiloError(exits.schema, "missing_column", "Indexed column does not exist.", `$.indexes[${i}].columns[${j}].column`);
+		}
+	}
+	for (const [i, check] of (table.checks ?? []).entries()) {
+		assertObject(check, `$.checks[${i}]`);
+		rejectUnknown(check, [
+			"name",
+			"expression",
+			"comment"
+		], `$.checks[${i}]`);
+		if (!check.expression) throw new SiloError(exits.schema, "invalid_check", "Check expression is required.", `$.checks[${i}].expression`);
+	}
+	if (table.without_rowid && !table.primary_key?.length) throw new SiloError(exits.schema, "without_rowid_requires_key", "WITHOUT ROWID requires a primary key.", "$.without_rowid");
+	validatePolicies(table, has);
+	return structuredClone(table);
+}
+function validatePolicies(table, has) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const [i, policy] of (table.policies ?? []).entries()) {
+		if (!policy || typeof policy !== "object" || typeof policy.type !== "string") throw new SiloError(exits.schema, "invalid_policy", "A policy type is required.", `$.policies[${i}]`);
+		if (seen.has(policy.type)) throw new SiloError(exits.schema, "duplicate_policy", "A policy may be configured once per table.", `$.policies[${i}]`);
+		seen.add(policy.type);
+		rejectUnknown(policy, {
+			generated_identity: [
+				"type",
+				"column",
+				"strategy"
+			],
+			timestamps: [
+				"type",
+				"created_column",
+				"updated_column"
+			],
+			optimistic_revision: [
+				"type",
+				"column",
+				"initial"
+			],
+			immutable_rows: ["type"],
+			immutable_columns: ["type", "columns"],
+			append_only: ["type"],
+			natural_key_upsert: [
+				"type",
+				"columns",
+				"update_columns"
+			]
+		}[policy.type] ?? ["type"], `$.policies[${i}]`);
+		const required = (key) => {
+			if (typeof policy[key] !== "string" || !has(policy[key])) throw new SiloError(exits.schema, "policy_precondition", `Policy requires an existing ${key}.`, `$.policies[${i}].${key}`);
+		};
+		if (policy.type === "generated_identity") {
+			required("column");
+			if (!(/* @__PURE__ */ new Set([
+				"integer",
+				"uuid",
+				"ulid"
+			])).has(policy.strategy)) throw new SiloError(exits.schema, "invalid_identity_strategy", "Identity strategy must be integer, uuid, or ulid.", `$.policies[${i}].strategy`);
+			if (policy.strategy === "integer" && (table.primary_key?.length !== 1 || table.primary_key[0] !== policy.column)) throw new SiloError(exits.schema, "policy_precondition", "Integer identity must be the table's single primary key.", `$.policies[${i}]`);
+			const column = table.columns.find((item) => item.name === policy.column);
+			if (policy.strategy === "integer" && column.type !== "integer") throw new SiloError(exits.schema, "policy_precondition", "Integer identity requires the integer type.", `$.policies[${i}].column`);
+			if (policy.strategy === "uuid" && column.type !== "text/uuid" || policy.strategy === "ulid" && column.type !== "text/ulid") throw new SiloError(exits.schema, "policy_precondition", `${policy.strategy} identity requires its matching semantic type.`, `$.policies[${i}].column`);
+		} else if (policy.type === "timestamps") {
+			if (policy.created_column) required("created_column");
+			if (policy.updated_column) required("updated_column");
+			if (!policy.created_column && !policy.updated_column) throw new SiloError(exits.schema, "policy_precondition", "timestamps requires a created_column or updated_column.", `$.policies[${i}]`);
+			for (const key of ["created_column", "updated_column"]) if (policy[key] && table.columns.find((item) => item.name === policy[key]).type !== "text/datetime") throw new SiloError(exits.schema, "policy_precondition", `timestamps ${key} requires text/datetime.`, `$.policies[${i}].${key}`);
+		} else if (policy.type === "optimistic_revision") {
+			required("column");
+			if (!table.columns.find((item) => item.name === policy.column).type.startsWith("integer")) throw new SiloError(exits.schema, "policy_precondition", "Optimistic revision requires an integer column.", `$.policies[${i}].column`);
+		} else if (policy.type === "immutable_columns") {
+			if (!Array.isArray(policy.columns) || !policy.columns.length) throw new SiloError(exits.schema, "policy_precondition", "immutable_columns requires columns.", `$.policies[${i}].columns`);
+			for (const column of policy.columns) if (!has(column)) throw new SiloError(exits.schema, "policy_precondition", "Immutable column does not exist.", `$.policies[${i}].columns`);
+		} else if (policy.type === "natural_key_upsert") {
+			if (!Array.isArray(policy.columns) || !policy.columns.length) throw new SiloError(exits.schema, "policy_precondition", "natural_key_upsert requires columns.", `$.policies[${i}].columns`);
+			for (const column of policy.columns) if (!has(column)) throw new SiloError(exits.schema, "policy_precondition", "Natural-key column does not exist.", `$.policies[${i}].columns`);
+			for (const column of policy.update_columns ?? []) if (!has(column)) throw new SiloError(exits.schema, "policy_precondition", "Natural-key update column does not exist.", `$.policies[${i}].update_columns`);
+			const key = policy.columns;
+			if (![table.primary_key ?? [], ...(table.unique_constraints ?? []).map((item) => item.columns)].some((columns) => columns.length === key.length && columns.every((column, position) => column === key[position]))) throw new SiloError(exits.schema, "policy_precondition", "Natural-key upsert columns must exactly match a primary key or unique constraint.", `$.policies[${i}].columns`);
+		} else if (policy.type !== "immutable_rows" && policy.type !== "append_only") throw new SiloError(exits.schema, "unknown_policy", `${policy.type} is not registered.`, `$.policies[${i}].type`);
+	}
+	if (seen.has("append_only") && seen.has("immutable_rows")) throw new SiloError(exits.schema, "incompatible_policies", "append_only and immutable_rows are redundant and cannot be combined.", "$.policies");
+	if ((seen.has("append_only") || seen.has("immutable_rows")) && (seen.has("optimistic_revision") || seen.has("natural_key_upsert"))) throw new SiloError(exits.schema, "incompatible_policies", "Immutable and append-only rows cannot use update-oriented policies.", "$.policies");
+	if ((seen.has("append_only") || seen.has("immutable_rows")) && seen.has("timestamps") && table.policies?.find((item) => item.type === "timestamps")?.updated_column) throw new SiloError(exits.schema, "incompatible_policies", "An updated timestamp cannot be combined with an immutable or append-only row.", "$.policies");
+	const immutable = table.policies?.find((item) => item.type === "immutable_columns");
+	if (immutable) {
+		const managed = [table.policies?.find((item) => item.type === "timestamps")?.updated_column, table.policies?.find((item) => item.type === "optimistic_revision")?.column].filter(Boolean);
+		if (immutable.columns.some((column) => managed.includes(column))) throw new SiloError(exits.schema, "incompatible_policies", "CLI-managed update columns cannot also be immutable.", "$.policies");
+	}
+}
+function literal(value) {
+	if (value === null) return "NULL";
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+	if (value instanceof Uint8Array) return `X'${Buffer.from(value).toString("hex")}'`;
+	throw new SiloError(exits.schema, "invalid_default", "Default literal must be a JSON scalar.", "default.literal");
+}
+function columnSql(column, table) {
+	const type = semantic(column);
+	const integerIdentity = (table.policies ?? []).some((p) => p.type === "generated_identity" && p.column === column.name && p.strategy === "integer");
+	const pieces = [quote(column.name), integerIdentity ? "INTEGER PRIMARY KEY" : type.storage];
+	if (column.collate) {
+		validateIdentifier(column.collate, `${column.name}.collate`);
+		pieces.push(`COLLATE ${quote(column.collate)}`);
+	}
+	if (column.generated) pieces.push(`GENERATED ALWAYS AS (${column.generated.expression}) ${column.generated.storage ?? "VIRTUAL"}`);
+	if (column.nullable === false && !integerIdentity) pieces.push("NOT NULL");
+	if (column.default) {
+		if (Object.hasOwn(column.default, "literal")) pieces.push(`DEFAULT ${literal(canonicalize(column, column.default.literal))}`);
+		else if (column.default.expression) pieces.push(`DEFAULT (${column.default.expression})`);
+	}
+	const check = type.check?.(quote(column.name), column);
+	if (check) pieces.push(`CHECK (${check})`);
+	if (column.type === "text/enum") pieces.push(`CHECK (${quote(column.name)} IN (${column.type_options.values.map(literal).join(", ")}))`);
+	return pieces.join(" ");
+}
+function generatedName(table, kind, index) {
+	return `_silo_${table}_${kind}_${index}`;
+}
+function indexSql(table, index, position) {
+	if (index.name) validateIdentifier(index.name, `${table.name}.indexes[${position}].name`);
+	const logicalName = index.name ?? String(position);
+	const name = `_silo_idx_${table.name.length}_${table.name}_${logicalName}`;
+	const parts = index.columns.map((part) => {
+		if (part.column) validateIdentifier(part.column, `${table.name}.indexes[${position}].columns`);
+		if (!part.column && !part.expression) throw new SiloError(exits.schema, "invalid_index", "Index part requires column or expression.", `${table.name}.indexes[${position}].columns`);
+		return `${part.column ? quote(part.column) : `(${part.expression})`}${part.collate ? ` COLLATE ${quote(part.collate)}` : ""}${part.direction ? ` ${part.direction}` : ""}`;
+	});
+	return `CREATE ${index.unique ? "UNIQUE " : ""}INDEX ${quote(name)} ON ${quote(table.name)} (${parts.join(", ")})${index.where ? ` WHERE ${index.where}` : ""};`;
+}
+function compileTable(table) {
+	const integerIdentity = (table.policies ?? []).some((p) => p.type === "generated_identity" && p.strategy === "integer");
+	const constraints = [];
+	if (table.primary_key?.length && !integerIdentity) constraints.push(`PRIMARY KEY (${table.primary_key.map(quote).join(", ")})`);
+	for (const unique of table.unique_constraints ?? []) {
+		if (unique.name) validateIdentifier(unique.name, `${table.name}.unique_constraints.name`);
+		constraints.push(`${unique.name ? `CONSTRAINT ${quote(unique.name)} ` : ""}UNIQUE (${unique.columns.map(quote).join(", ")})`);
+	}
+	for (const check of table.checks ?? []) constraints.push(`${check.name ? `CONSTRAINT ${quote(check.name)} ` : ""}CHECK (${check.expression})`);
+	for (const fk of table.foreign_keys ?? []) constraints.push(`FOREIGN KEY (${fk.columns.map(quote).join(", ")}) REFERENCES ${quote(fk.references.table)} (${fk.references.columns.map(quote).join(", ")})${fk.on_update ? ` ON UPDATE ${fk.on_update}` : ""}${fk.on_delete ? ` ON DELETE ${fk.on_delete}` : ""}${fk.deferrable ? ` DEFERRABLE${fk.initially_deferred ? " INITIALLY DEFERRED" : ""}` : ""}`);
+	const body = [...table.columns.map((column) => columnSql(column, table)), ...constraints].join(",\n  ");
+	const options = [table.strict !== false ? "STRICT" : "", table.without_rowid ? "WITHOUT ROWID" : ""].filter(Boolean).join(", ");
+	const statements = [`CREATE TABLE ${quote(table.name)} (\n  ${body}\n)${options ? ` ${options}` : ""};`];
+	for (const [i, index] of (table.indexes ?? []).entries()) statements.push(indexSql(table, index, i));
+	for (const [i, unique] of (table.unique_constraints ?? []).entries());
+	statements.push(...compilePolicyTriggers(table));
+	return statements;
+}
+function compilePolicyTriggers(table) {
+	const result = [];
+	for (const [i, policy] of (table.policies ?? []).entries()) {
+		const name = generatedName(table.name, policy.type, i);
+		if (policy.type === "append_only" || policy.type === "immutable_rows") {
+			result.push(`CREATE TRIGGER ${quote(`${name}_update`)} BEFORE UPDATE ON ${quote(table.name)} BEGIN SELECT RAISE(ABORT, '${policy.type} forbids updates'); END;`);
+			result.push(`CREATE TRIGGER ${quote(`${name}_delete`)} BEFORE DELETE ON ${quote(table.name)} BEGIN SELECT RAISE(ABORT, '${policy.type} forbids deletes'); END;`);
+		} else if (policy.type === "immutable_columns") {
+			const changed = policy.columns.map((column) => `OLD.${quote(column)} IS NOT NEW.${quote(column)}`).join(" OR ");
+			result.push(`CREATE TRIGGER ${quote(name)} BEFORE UPDATE ON ${quote(table.name)} WHEN ${changed} BEGIN SELECT RAISE(ABORT, 'immutable column changed'); END;`);
+		} else if (policy.type === "timestamps" && policy.updated_column) {
+			const column = quote(policy.updated_column);
+			const locator = table.without_rowid ? table.primary_key.map((key) => `${quote(key)} = NEW.${quote(key)}`).join(" AND ") : "rowid = NEW.rowid";
+			result.push(`CREATE TRIGGER ${quote(name)} AFTER UPDATE ON ${quote(table.name)} WHEN NEW.${column} IS OLD.${column} BEGIN UPDATE ${quote(table.name)} SET ${column} = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE ${locator}; END;`);
+		}
+	}
+	return result;
+}
+function compileSchema(schema) {
+	return schema.tables.flatMap(compileTable);
+}
+function validateCompiledSchema(schema) {
+	const names = /* @__PURE__ */ new Set();
+	for (const [i, table] of schema.tables.entries()) {
+		const key = table.name.toLowerCase();
+		if (names.has(key)) throw new SiloError(exits.schema, "duplicate_table", "Table names are case-insensitively unique.", `$.tables[${i}].name`);
+		names.add(key);
+	}
+	for (const [i, table] of schema.tables.entries()) for (const [j, foreign] of (table.foreign_keys ?? []).entries()) {
+		const target = schema.tables.find((candidate) => candidate.name.toLowerCase() === foreign.references.table.toLowerCase());
+		if (!target) throw new SiloError(exits.schema, "missing_referenced_table", `${foreign.references.table} does not exist.`, `$.tables[${i}].foreign_keys[${j}]`);
+		for (const column of foreign.references.columns) if (!target.columns.some((candidate) => candidate.name.toLowerCase() === column.toLowerCase())) throw new SiloError(exits.schema, "missing_referenced_column", `${column} does not exist on ${target.name}.`, `$.tables[${i}].foreign_keys[${j}]`);
+		if (![target.primary_key ?? [], ...(target.unique_constraints ?? []).map((item) => item.columns)].some((columns) => columns.length === foreign.references.columns.length && columns.every((column, position) => column === foreign.references.columns[position]))) throw new SiloError(exits.schema, "invalid_foreign_key_target", "Referenced columns must exactly match a primary key or unique constraint.", `$.tables[${i}].foreign_keys[${j}]`);
+	}
+	const database = new DatabaseSync(":memory:");
+	try {
+		database.exec("PRAGMA foreign_keys=ON;");
+		database.exec(compileSchema(schema).join("\n"));
+		const check = database.prepare("PRAGMA integrity_check").get();
+		if (!Object.values(check).includes("ok")) throw new Error("integrity_check did not return ok");
+	} catch (error) {
+		throw new SiloError(exits.schema, "sqlite_compile_error", error instanceof Error ? error.message : String(error), "$.");
+	} finally {
+		database.close();
+	}
+}
+function policy(table, type) {
+	return table.policies?.find((candidate) => candidate.type === type);
+}
+function generatedValue(strategy) {
+	if (strategy === "uuid") return randomUUID().toLowerCase();
+	if (strategy === "ulid") {
+		const alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+		let time = Date.now();
+		let result = "";
+		for (let i = 0; i < 10; i++) {
+			result = alphabet[time % 32] + result;
+			time = Math.floor(time / 32);
+		}
+		for (let i = 0; i < 16; i++) result += alphabet[Math.floor(Math.random() * 32)];
+		return result;
+	}
+	throw new SiloError(exits.schema, "invalid_identity_strategy", "Generated identity strategy must be uuid, ulid, or integer.", "policy.strategy");
+}
+//#endregion
+//#region src/workspace.ts
+function normalizeOrigin(origin) {
+	const value = origin.trim();
+	if (value.replace(/[?#].*$/, "").split(/[/:]/).some((segment) => {
+		try {
+			const decoded = decodeURIComponent(segment);
+			return decoded === "." || decoded === "..";
+		} catch {
+			return true;
+		}
+	})) throw new SiloError(exits.workspace, "invalid_origin", "The origin remote contains an unsafe path segment.", "remote.origin.url");
+	let host;
+	let path;
+	const scp = /^(?:[^@/]+@)?([^:/]+):(.+)$/.exec(value);
+	if (scp && !value.includes("://")) {
+		host = scp[1];
+		path = scp[2];
+	} else {
+		let url;
+		try {
+			url = new URL(value);
+		} catch {
+			throw new SiloError(exits.workspace, "invalid_origin", "The origin remote is not a usable URL.", "remote.origin.url");
+		}
+		host = url.hostname;
+		path = url.pathname;
+	}
+	host = host.toLowerCase();
+	path = path.replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "");
+	const segments = path.split("/");
+	if (!host || !path || segments.some((part) => !part || part === "." || part === "..")) throw new SiloError(exits.workspace, "invalid_origin", "The origin remote has an unsafe or empty repository path.", "remote.origin.url");
+	return `${host}/${segments.join("/")}`;
+}
+function dataRoot() {
+	if (process.env.SILO_DATA_HOME) return join(process.env.SILO_DATA_HOME, "silo");
+	if (process.platform === "darwin") return join(homedir(), "Library", "Application Support", "silo");
+	if (process.platform === "win32") return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "silo");
+	return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "silo");
+}
+function git(cwd, args) {
+	try {
+		return execFileSync("git", args, {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		throw new SiloError(exits.workspace, "workspace_unresolved", "The current directory is not a Git worktree with a usable origin remote.");
+	}
+}
+function resolveWorkspace(cwd = process.cwd()) {
+	const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+	const origin = git(root, [
+		"config",
+		"--get",
+		"remote.origin.url"
+	]);
+	const identity = normalizeOrigin(origin);
+	const parts = identity.split("/");
+	const leaf = parts.pop();
+	return {
+		root,
+		origin,
+		identity,
+		databasePath: join(dataRoot(), "databases", ...parts, `${leaf}.sqlite`)
+	};
+}
+//#endregion
+//#region src/markdown.ts
+function cell(value) {
+	if (value === null || value === void 0) return "NULL";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (value instanceof Uint8Array) return `[BLOB ${value.byteLength} bytes]`;
+	return (typeof value === "object" ? JSON.stringify(value) : String(value)).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
+}
+function table(headers, rows) {
+	const lines = [`| ${headers.map(cell).join(" | ")} |`, `| ${headers.map(() => "---").join(" | ")} |`];
+	for (const row of rows) lines.push(`| ${row.map(cell).join(" | ")} |`);
+	return lines.join("\n");
+}
+function errorMarkdown(error) {
+	return table([
+		"Path",
+		"Code",
+		"Message"
+	], [[
+		error.path || "`$`",
+		`\`${error.code}\``,
+		error.message
+	]]);
+}
+function heading(title, body) {
+	return `# ${title}\n\n${body}\n`;
+}
+//#endregion
+//#region src/report.ts
+const slotPattern = /\{\{silo-query:([a-z][a-z0-9_-]*)\}\}/g;
+const queryName = /^[a-z][a-z0-9_-]*$/;
+const slug = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const resultLimit = 500;
+function object(value, path) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new SiloError(exits.input, "invalid_shape", "Expected a JSON object.", path);
+}
+function knownFields(value, allowed, path) {
+	const key = Object.keys(value).find((candidate) => !allowed.includes(candidate));
+	if (key) throw new SiloError(exits.input, "unknown_field", `Unknown field ${key}.`, `${path}.${key}`);
+}
+function validateReportSlug(value, path = "$.slug") {
+	if (typeof value !== "string" || !slug.test(value)) throw new SiloError(exits.input, "invalid_report_slug", "Expected a lowercase slug containing letters, digits, and single hyphens.", path);
+}
+function parseReportDefinition(value) {
+	object(value, "$");
+	knownFields(value, [
+		"slug",
+		"title",
+		"markdown",
+		"queries"
+	], "$");
+	validateReportSlug(value.slug);
+	if (typeof value.title !== "string" || !value.title.trim()) throw new SiloError(exits.input, "invalid_report_title", "title must be non-empty.", "$.title");
+	if (typeof value.markdown !== "string" || !value.markdown.trim()) throw new SiloError(exits.input, "invalid_report_markdown", "markdown must be non-empty.", "$.markdown");
+	if (!Array.isArray(value.queries) || !value.queries.length) throw new SiloError(exits.input, "invalid_report_queries", "queries must contain at least one saved query.", "$.queries");
+	const names = /* @__PURE__ */ new Set();
+	const queries = value.queries.map((candidate, index) => {
+		const path = `$.queries[${index}]`;
+		object(candidate, path);
+		knownFields(candidate, [
+			"name",
+			"sql",
+			"empty_markdown"
+		], path);
+		if (typeof candidate.name !== "string" || !queryName.test(candidate.name)) throw new SiloError(exits.input, "invalid_report_query_name", "Query names must start with a lowercase letter and contain lowercase letters, digits, underscores, or hyphens.", `${path}.name`);
+		if (names.has(candidate.name)) throw new SiloError(exits.input, "duplicate_report_query", `Duplicate query name ${candidate.name}.`, `${path}.name`);
+		names.add(candidate.name);
+		if (typeof candidate.sql !== "string" || !candidate.sql.trim()) throw new SiloError(exits.input, "invalid_report_query", "sql must be non-empty.", `${path}.sql`);
+		if (candidate.empty_markdown !== void 0 && (typeof candidate.empty_markdown !== "string" || !candidate.empty_markdown.trim())) throw new SiloError(exits.input, "invalid_empty_markdown", "empty_markdown must be a non-empty Markdown string when supplied.", `${path}.empty_markdown`);
+		return {
+			name: candidate.name,
+			sql: candidate.sql,
+			...candidate.empty_markdown === void 0 ? {} : { empty_markdown: candidate.empty_markdown }
+		};
+	});
+	const referenced = /* @__PURE__ */ new Set();
+	for (const match of value.markdown.matchAll(slotPattern)) referenced.add(match[1]);
+	if (value.markdown.replace(slotPattern, "").includes("{{silo-query:")) throw new SiloError(exits.input, "invalid_report_slot", "Query slots must use {{silo-query:name}} with a valid query name.", "$.markdown");
+	for (const name of referenced) if (!names.has(name)) throw new SiloError(exits.input, "unknown_report_query", `The template references unknown query ${name}.`, "$.markdown");
+	for (const name of names) if (!referenced.has(name)) throw new SiloError(exits.input, "unused_report_query", `Saved query ${name} has no template slot.`, "$.queries");
+	return {
+		slug: value.slug,
+		title: value.title.trim(),
+		markdown: value.markdown,
+		queries
+	};
+}
+function meaningfulSql(value) {
+	let lineComment = false;
+	let blockComment = false;
+	for (let index = 0; index < value.length; index++) {
+		const char = value[index];
+		const next = value[index + 1];
+		if (lineComment) {
+			if (char === "\n") lineComment = false;
+			continue;
+		}
+		if (blockComment) {
+			if (char === "*" && next === "/") {
+				blockComment = false;
+				index++;
+			}
+			continue;
+		}
+		if (char === "-" && next === "-") {
+			lineComment = true;
+			index++;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			blockComment = true;
+			index++;
+			continue;
+		}
+		if (!/\s/.test(char)) return true;
+	}
+	return false;
+}
+function assertSingleStatement(sql, path) {
+	let quote;
+	let lineComment = false;
+	let blockComment = false;
+	for (let index = 0; index < sql.length; index++) {
+		const char = sql[index];
+		const next = sql[index + 1];
+		if (lineComment) {
+			if (char === "\n") lineComment = false;
+			continue;
+		}
+		if (blockComment) {
+			if (char === "*" && next === "/") {
+				blockComment = false;
+				index++;
+			}
+			continue;
+		}
+		if (quote) {
+			if (char === quote) if (quote !== "]" && next === quote) index++;
+			else quote = void 0;
+			continue;
+		}
+		if (char === "-" && next === "-") {
+			lineComment = true;
+			index++;
+		} else if (char === "/" && next === "*") {
+			blockComment = true;
+			index++;
+		} else if (char === "'" || char === "\"" || char === "`") quote = char;
+		else if (char === "[") quote = "]";
+		else if (char === ";" && meaningfulSql(sql.slice(index + 1))) throw new SiloError(exits.input, "multiple_report_statements", "A saved query must contain exactly one SQLite statement.", path);
+	}
+}
+function runQuery(database, query, index) {
+	const path = `$.queries[${index}].sql`;
+	assertSingleStatement(query.sql, path);
+	try {
+		const statement = database.prepare(query.sql);
+		statement.setReturnArrays(true);
+		const rawColumns = statement.columns().map((column) => column.name || "column");
+		if (!rawColumns.length) throw new SiloError(exits.input, "report_query_has_no_columns", "A saved query must return result columns.", path);
+		const seen = /* @__PURE__ */ new Map();
+		const columns = rawColumns.map((name) => {
+			const count = (seen.get(name) ?? 0) + 1;
+			seen.set(name, count);
+			return count === 1 ? name : `${name}_${count}`;
+		});
+		const rows = [];
+		let truncated = false;
+		for (const row of statement.iterate()) {
+			if (rows.length === resultLimit) {
+				truncated = true;
+				break;
+			}
+			rows.push(row);
+		}
+		const rendered = rows.length ? table(columns, rows) : query.empty_markdown ?? "_No rows._";
+		return truncated ? `${rendered}\n\n> Results truncated to ${resultLimit} rows.` : rendered;
+	} catch (error) {
+		if (error instanceof SiloError) throw error;
+		throw new SiloError(exits.input, "invalid_report_query", error instanceof Error ? error.message : String(error), path);
+	}
+}
+function renderReport(database, definition) {
+	const allowed = /* @__PURE__ */ new Set([
+		constants.SQLITE_SELECT,
+		constants.SQLITE_READ,
+		constants.SQLITE_FUNCTION,
+		constants.SQLITE_RECURSIVE
+	]);
+	database.setAuthorizer((action, first, second) => {
+		const resource = action === constants.SQLITE_READ ? first : action === constants.SQLITE_FUNCTION ? second : null;
+		if (resource && (resource.startsWith("_silo_") || resource.startsWith("sqlite_") || [
+			"load_extension",
+			"readfile",
+			"writefile",
+			"fts3_tokenizer"
+		].includes(resource.toLowerCase()))) return constants.SQLITE_DENY;
+		return allowed.has(action) ? constants.SQLITE_OK : constants.SQLITE_DENY;
+	});
+	try {
+		const results = new Map(definition.queries.map((query, index) => [query.name, runQuery(database, query, index)]));
+		return definition.markdown.replace(slotPattern, (_, name) => results.get(name));
+	} finally {
+		database.setAuthorizer(null);
+	}
+}
+//#endregion
+//#region src/database.ts
+const FORMAT_VERSION = 2;
+const TOOL_VERSION = "0.1.0";
+function binding(value) {
+	if (value === null || typeof value === "number" || typeof value === "bigint" || typeof value === "string" || value instanceof Uint8Array) return value;
+	throw new SiloError(exits.input, "unsupported_sqlite_value", "The semantic value cannot be bound to SQLite.");
+}
+function now() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function laterThan(value) {
+	const current = Date.now();
+	const previous = typeof value === "string" ? Date.parse(value) : NaN;
+	return new Date(Number.isFinite(previous) ? Math.max(current, previous + 1) : current).toISOString();
+}
+function sqliteError(error) {
+	if (error instanceof SiloError) throw error;
+	const message = error instanceof Error ? error.message : String(error);
+	const sqlite = error;
+	const code = (typeof sqlite.errcode === "number" ? sqlite.errcode & 255 : void 0) === 19 || /constraint|unique|foreign key|not null|check/i.test(`${typeof sqlite.errstr === "string" ? sqlite.errstr : ""} ${message}`) ? exits.constraint : exits.io;
+	throw new SiloError(code, code === exits.constraint ? "sqlite_constraint" : "sqlite_error", message);
+}
+function configure(database, writable) {
+	database.exec("PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000; PRAGMA trusted_schema=OFF;");
+	if (writable) {
+		const result = database.prepare("PRAGMA journal_mode=WAL").get();
+		if (!Object.values(result).some((value) => String(value).toLowerCase() === "wal")) throw new SiloError(exits.io, "wal_unavailable", "SQLite could not establish WAL journal mode.");
+		database.exec("PRAGMA synchronous=NORMAL;");
+	}
+	const version = String(Object.values(database.prepare("SELECT sqlite_version() AS version").get())[0]);
+	const [major, minor] = version.split(".").map(Number);
+	if (major < 3 || major === 3 && minor < 37) throw new SiloError(exits.integrity, "sqlite_too_old", `SQLite ${version} is older than the required 3.37.0.`);
+}
+function initialize(database, workspace, schema) {
+	const timestamp = now();
+	database.exec(`
+    CREATE TABLE _silo_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL) STRICT;
+    CREATE TABLE _silo_schema (id INTEGER PRIMARY KEY CHECK (id = 1), schema_json TEXT NOT NULL) STRICT;
+    CREATE TABLE _silo_reports (
+      slug TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      template_markdown TEXT NOT NULL,
+      rendered_markdown TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      refreshed_at TEXT NOT NULL,
+      last_refresh_attempt_at TEXT NOT NULL,
+      last_refresh_error TEXT
+    ) STRICT;
+    CREATE TABLE _silo_report_queries (
+      report_slug TEXT NOT NULL REFERENCES _silo_reports(slug) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      sql TEXT NOT NULL,
+      empty_markdown TEXT,
+      position INTEGER NOT NULL CHECK (position >= 0),
+      PRIMARY KEY (report_slug, name),
+      UNIQUE (report_slug, position)
+    ) STRICT;
+  `);
+	const insert = database.prepare("INSERT INTO _silo_meta (key, value) VALUES (?, ?)");
+	const values = {
+		format_version: String(FORMAT_VERSION),
+		registry_version: String(schema.registry_version),
+		tool_version: TOOL_VERSION,
+		identity: workspace.identity,
+		original_origin: workspace.origin,
+		created_at: timestamp,
+		updated_at: timestamp
+	};
+	if (schema.template_imports?.length) values.template_names = JSON.stringify(schema.template_imports.map((item) => item.name));
+	for (const [key, value] of Object.entries(values)) insert.run(key, value);
+	database.prepare("INSERT INTO _silo_schema (id, schema_json) VALUES (1, ?)").run(JSON.stringify(schema));
+}
+function metadata(database) {
+	try {
+		const rows = database.prepare("SELECT key, value FROM _silo_meta ORDER BY key").all();
+		const values = Object.fromEntries(rows.map((row) => [row.key, row.value]));
+		if (!values.identity || Number(values.format_version) !== FORMAT_VERSION) throw new SiloError(exits.integrity, "incompatible_database", "Database metadata is missing or incompatible.");
+		return {
+			identity: values.identity,
+			original_origin: values.original_origin,
+			created_at: values.created_at,
+			updated_at: values.updated_at,
+			format_version: Number(values.format_version),
+			tool_version: values.tool_version
+		};
+	} catch (error) {
+		if (error instanceof SiloError) throw error;
+		throw new SiloError(exits.integrity, "unrecognized_database", "The file is not a recognized Silo database.");
+	}
+}
+function readSchema(database) {
+	try {
+		const row = database.prepare("SELECT schema_json FROM _silo_schema WHERE id = 1").get();
+		if (!row) throw new Error("schema row missing");
+		return JSON.parse(row.schema_json);
+	} catch (error) {
+		throw new SiloError(exits.integrity, "schema_metadata_invalid", error instanceof Error ? error.message : String(error));
+	}
+}
+function normalizeDdl(sql) {
+	const tokens = [];
+	for (let i = 0; i < sql.length;) {
+		const char = sql[i];
+		if (/\s/.test(char)) {
+			i++;
+			continue;
+		}
+		if (char === "-" && sql[i + 1] === "-") {
+			i = sql.indexOf("\n", i + 2);
+			if (i < 0) break;
+			continue;
+		}
+		if (char === "/" && sql[i + 1] === "*") {
+			const end = sql.indexOf("*/", i + 2);
+			i = end < 0 ? sql.length : end + 2;
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`" || char === "[") {
+			const close = char === "[" ? "]" : char;
+			let token = char;
+			i++;
+			while (i < sql.length) {
+				token += sql[i];
+				if (sql[i] === close) {
+					if (close !== "]" && sql[i + 1] === close) {
+						token += close;
+						i += 2;
+						continue;
+					}
+					i++;
+					break;
+				}
+				i++;
+			}
+			tokens.push(token);
+			continue;
+		}
+		if (/[A-Za-z0-9_$]/.test(char)) {
+			let end = i + 1;
+			while (end < sql.length && /[A-Za-z0-9_$]/.test(sql[end])) end++;
+			tokens.push(sql.slice(i, end).toLowerCase());
+			i = end;
+			continue;
+		}
+		const operator = [
+			"->>",
+			"||",
+			">=",
+			"<=",
+			"<>",
+			"!=",
+			"==",
+			"->"
+		].find((candidate) => sql.startsWith(candidate, i));
+		tokens.push(operator ?? char);
+		i += operator?.length ?? 1;
+	}
+	return tokens.join(" ");
+}
+function physicalFingerprint(database, schema) {
+	const tableNames = new Set(schema.tables.map((table) => table.name.toLowerCase()));
+	return database.prepare("SELECT type, name, tbl_name, sql FROM sqlite_schema WHERE type IN ('table', 'index', 'trigger') AND sql IS NOT NULL ORDER BY type, name").all().filter((row) => tableNames.has(row.tbl_name.toLowerCase())).map((row) => `${row.type}:${row.name.toLowerCase()}:${row.tbl_name.toLowerCase()}:${normalizeDdl(row.sql)}`);
+}
+function verifyPhysical(database, schema) {
+	const expectedDatabase = new DatabaseSync(":memory:");
+	try {
+		expectedDatabase.exec("PRAGMA foreign_keys=ON;");
+		expectedDatabase.exec(compileSchema(schema).join("\n"));
+		const expected = physicalFingerprint(expectedDatabase, schema);
+		const actual = physicalFingerprint(database, schema);
+		if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new SiloError(exits.integrity, "physical_schema_mismatch", "Physical tables, indexes, or triggers do not match authoritative schema metadata.");
+	} finally {
+		expectedDatabase.close();
+	}
+}
+function validateSynchronizedSchema(schema) {
+	for (const table of schema.tables) {
+		if (!table.primary_key?.length) throw new SiloError(exits.schema, "sync_primary_key_required", `Synchronized table ${table.name} must declare a primary key.`);
+		const nullable = table.primary_key.find((name) => table.columns.find((column) => column.name === name)?.nullable !== false);
+		if (nullable) throw new SiloError(exits.schema, "sync_primary_key_nullable", `Synchronized primary key ${table.name}.${nullable} must be non-nullable.`);
+	}
+}
+var SiloDatabase = class SiloDatabase {
+	workspace;
+	database;
+	releaseWriterLock;
+	closed = false;
+	constructor(workspace, database, releaseWriterLock) {
+		this.workspace = workspace;
+		this.database = database;
+		this.releaseWriterLock = releaseWriterLock;
+	}
+	static open(workspace, writable = false, allowSyncLock = false) {
+		if (!existsSync(workspace.databasePath)) throw new SiloError(exits.absent, "database_absent", "No Silo database exists for this workspace.");
+		let database;
+		let releaseWriterLock;
+		try {
+			if (writable && !allowSyncLock) {
+				releaseWriterLock = acquireFileLock(`${workspace.databasePath}.write-lock`, "Another writer or synchronization operation is using this database.");
+				if (existsSync(`${workspace.databasePath}.sync-lock`)) throw new SiloError(exits.io, "sync_in_progress", "A synchronization operation is already using this database.");
+			}
+			database = new DatabaseSync(workspace.databasePath, { readOnly: !writable });
+			configure(database, writable);
+			if (metadata(database).identity !== workspace.identity) throw new SiloError(exits.integrity, "identity_mismatch", "Database identity does not match the normalized origin.");
+			const instance = new SiloDatabase(workspace, database, releaseWriterLock);
+			verifyPhysical(database, instance.getSchema());
+			return instance;
+		} catch (error) {
+			database?.close();
+			releaseWriterLock?.();
+			sqliteError(error);
+		}
+	}
+	static createWithSchema(workspace, schema) {
+		if (existsSync(workspace.databasePath)) throw new SiloError(exits.schema, "database_exists", "A database already exists for this workspace.");
+		validateCompiledSchema(schema);
+		mkdirSync(dirname(workspace.databasePath), { recursive: true });
+		const releaseWriterLock = acquireFileLock(`${workspace.databasePath}.write-lock`, "Another writer or synchronization operation is using this database.");
+		if (existsSync(`${workspace.databasePath}.sync-lock`)) {
+			releaseWriterLock();
+			throw new SiloError(exits.io, "sync_in_progress", "A synchronization operation is already using this database.");
+		}
+		if (existsSync(workspace.databasePath)) {
+			releaseWriterLock();
+			throw new SiloError(exits.schema, "database_exists", "A database already exists for this workspace.");
+		}
+		let database;
+		try {
+			database = new DatabaseSync(workspace.databasePath);
+			configure(database, true);
+			database.exec("BEGIN IMMEDIATE");
+			initialize(database, workspace, schema);
+			database.exec(compileSchema(schema).join("\n"));
+			const instance = new SiloDatabase(workspace, database, releaseWriterLock);
+			instance.verify(schema);
+			database.exec("COMMIT");
+			return instance;
+		} catch (error) {
+			try {
+				database?.exec("ROLLBACK");
+			} catch {}
+			database?.close();
+			rmSync(workspace.databasePath, { force: true });
+			rmSync(`${workspace.databasePath}-wal`, { force: true });
+			rmSync(`${workspace.databasePath}-shm`, { force: true });
+			releaseWriterLock();
+			sqliteError(error);
+		}
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			this.database.close();
+		} finally {
+			this.releaseWriterLock?.();
+		}
+	}
+	getMetadata() {
+		return metadata(this.database);
+	}
+	getSchema() {
+		return readSchema(this.database);
+	}
+	readReport(slug) {
+		validateReportSlug(slug, "$.slug");
+		const row = this.database.prepare(`SELECT slug, title, template_markdown, rendered_markdown, created_at, updated_at,
+                refreshed_at, last_refresh_attempt_at, last_refresh_error
+         FROM _silo_reports WHERE slug = ?`).get(slug);
+		if (!row) throw new SiloError(exits.notFound, "report_not_found", `No report has slug ${slug}.`);
+		const queries = this.database.prepare(`SELECT name, sql, empty_markdown FROM _silo_report_queries
+         WHERE report_slug = ? ORDER BY position`).all(slug);
+		return {
+			slug: row.slug,
+			title: row.title,
+			markdown: row.template_markdown,
+			queries: queries.map((query) => ({
+				name: query.name,
+				sql: query.sql,
+				...query.empty_markdown === null ? {} : { empty_markdown: query.empty_markdown }
+			})),
+			rendered_markdown: row.rendered_markdown,
+			created_at: row.created_at,
+			updated_at: row.updated_at,
+			refreshed_at: row.refreshed_at,
+			last_refresh_attempt_at: row.last_refresh_attempt_at,
+			last_refresh_error: row.last_refresh_error
+		};
+	}
+	getReport(slug) {
+		return this.readReport(slug);
+	}
+	listReports() {
+		return this.database.prepare(`SELECT slug, title, refreshed_at, last_refresh_attempt_at, last_refresh_error
+         FROM _silo_reports ORDER BY slug`).all();
+	}
+	putReport(input) {
+		const definition = parseReportDefinition(input);
+		const timestamp = now();
+		return this.mutateRows((report) => ({
+			command: "report.put",
+			report: report.slug
+		}), () => {
+			const rendered = renderReport(this.database, definition);
+			this.database.prepare(`INSERT INTO _silo_reports (
+               slug, title, template_markdown, rendered_markdown, created_at, updated_at,
+               refreshed_at, last_refresh_attempt_at, last_refresh_error
+             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)
+             ON CONFLICT (slug) DO UPDATE SET
+               title = excluded.title,
+               template_markdown = excluded.template_markdown,
+               rendered_markdown = excluded.rendered_markdown,
+               updated_at = excluded.updated_at,
+               refreshed_at = excluded.refreshed_at,
+               last_refresh_attempt_at = excluded.last_refresh_attempt_at,
+               last_refresh_error = NULL`).run(definition.slug, definition.title, definition.markdown, rendered, timestamp, timestamp, timestamp, timestamp);
+			this.database.prepare("DELETE FROM _silo_report_queries WHERE report_slug = ?").run(definition.slug);
+			const insert = this.database.prepare(`INSERT INTO _silo_report_queries
+             (report_slug, name, sql, empty_markdown, position) VALUES (?, ?, ?, ?, ?)`);
+			for (const [position, query] of definition.queries.entries()) insert.run(definition.slug, query.name, query.sql, query.empty_markdown ?? null, position);
+			return this.readReport(definition.slug);
+		});
+	}
+	refreshReport(slug) {
+		validateReportSlug(slug, "$.slug");
+		const timestamp = now();
+		try {
+			return this.mutateRows((report) => ({
+				command: "report.refresh",
+				report: report.slug
+			}), () => {
+				const current = this.readReport(slug);
+				const definition = {
+					slug: current.slug,
+					title: current.title,
+					markdown: current.markdown,
+					queries: current.queries
+				};
+				const rendered = renderReport(this.database, definition);
+				this.database.prepare(`UPDATE _silo_reports SET rendered_markdown = ?, refreshed_at = ?,
+                 last_refresh_attempt_at = ?, last_refresh_error = NULL WHERE slug = ?`).run(rendered, timestamp, timestamp, slug);
+				return this.readReport(slug);
+			});
+		} catch (error) {
+			if (!(error instanceof SiloError) || error.code !== "report_not_found") try {
+				this.mutateRows(() => ({
+					command: "report.refresh_error",
+					report: slug
+				}), () => {
+					this.database.prepare(`UPDATE _silo_reports SET last_refresh_attempt_at = ?, last_refresh_error = ?
+                   WHERE slug = ?`).run(timestamp, error instanceof SiloError ? `${error.code}: ${error.message}` : error instanceof Error ? error.message : String(error), slug);
+				});
+			} catch (recordError) {
+				sqliteError(recordError);
+			}
+			sqliteError(error);
+		}
+	}
+	deleteReport(slug) {
+		validateReportSlug(slug, "$.slug");
+		this.mutateRows(() => ({
+			command: "report.delete",
+			report: slug
+		}), () => {
+			if (!this.database.prepare("DELETE FROM _silo_reports WHERE slug = ?").run(slug).changes) throw new SiloError(exits.notFound, "report_not_found", `No report has slug ${slug}.`);
+		});
+	}
+	getSyncState() {
+		if (!this.database.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = '_silo_sync'").get()) return void 0;
+		return this.database.prepare("SELECT * FROM _silo_sync WHERE id = 1").get();
+	}
+	configureSync(remoteUrl, databaseId = randomUUID()) {
+		const existing = this.getSyncState();
+		if (existing) {
+			if (existing.remote_url !== remoteUrl) throw new SiloError(exits.workspace, "sync_already_configured", `This database is already synchronized with ${existing.remote_url}.`);
+			return existing;
+		}
+		validateSynchronizedSchema(this.getSchema());
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			this.database.exec(`
+        CREATE TABLE _silo_sync (
+          id INTEGER PRIMARY KEY CHECK (id = 1),
+          database_id TEXT NOT NULL UNIQUE,
+          remote_url TEXT NOT NULL,
+          base_generation TEXT,
+          base_etag TEXT,
+          conflict_transaction_id TEXT
+        ) STRICT;
+        CREATE TABLE _silo_outbox (
+          sequence INTEGER PRIMARY KEY,
+          transaction_id TEXT NOT NULL UNIQUE,
+          kind TEXT NOT NULL CHECK (kind IN ('data', 'schema')),
+          base_generation TEXT,
+          schema_revision INTEGER NOT NULL,
+          operation_json TEXT NOT NULL CHECK (json_valid(operation_json)),
+          changeset BLOB NOT NULL,
+          created_at TEXT NOT NULL
+        ) STRICT;
+      `);
+			this.database.prepare("INSERT INTO _silo_sync (id, database_id, remote_url) VALUES (1, ?, ?)").run(databaseId, remoteUrl);
+			this.database.exec("COMMIT");
+			return this.getSyncState();
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	pendingTransactions() {
+		if (!this.getSyncState()) return [];
+		return this.database.prepare("SELECT * FROM _silo_outbox ORDER BY sequence").all().map(({ operation_json, ...row }) => ({
+			...row,
+			operation: JSON.parse(operation_json)
+		}));
+	}
+	setSyncConflict(transactionId) {
+		if (!this.getSyncState()) throw new SiloError(exits.workspace, "sync_not_configured", "Synchronization is not configured.");
+		this.database.prepare("UPDATE _silo_sync SET conflict_transaction_id = ? WHERE id = 1").run(transactionId);
+	}
+	markSynchronized(generation, etag) {
+		if (!this.getSyncState()) throw new SiloError(exits.workspace, "sync_not_configured", "Synchronization is not configured.");
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			this.database.prepare("UPDATE _silo_sync SET base_generation = ?, base_etag = ?, conflict_transaction_id = NULL WHERE id = 1").run(generation, etag);
+			this.database.prepare("DELETE FROM _silo_outbox").run();
+			this.database.exec("COMMIT");
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	async backupCanonical(path, generation) {
+		if (!this.getSyncState()) throw new SiloError(exits.workspace, "sync_not_configured", "Synchronization is not configured.");
+		this.database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+		await backup(this.database, path);
+		const canonical = new DatabaseSync(path);
+		try {
+			configure(canonical, true);
+			canonical.exec("BEGIN IMMEDIATE");
+			canonical.prepare("DELETE FROM _silo_outbox").run();
+			canonical.prepare("UPDATE _silo_sync SET base_generation = ?, base_etag = NULL, conflict_transaction_id = NULL WHERE id = 1").run(generation);
+			canonical.exec("COMMIT");
+		} catch (error) {
+			try {
+				canonical.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		} finally {
+			canonical.close();
+		}
+	}
+	rebasePending(pending, generation, etag, discardTransactionId) {
+		if (!this.getSyncState()) throw new SiloError(exits.integrity, "sync_metadata_missing", "Restored sync metadata is missing.");
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			this.database.prepare("DELETE FROM _silo_outbox").run();
+			this.database.prepare("UPDATE _silo_sync SET base_generation = ?, base_etag = ?, conflict_transaction_id = NULL WHERE id = 1").run(generation, etag);
+			for (const item of pending) {
+				if (item.transaction_id === discardTransactionId) continue;
+				if (item.kind !== "data" || item.schema_revision !== this.getSchema().revision) {
+					this.database.exec("ROLLBACK");
+					return item.transaction_id;
+				}
+				if (!this.database.applyChangeset(item.changeset)) {
+					this.database.exec("ROLLBACK");
+					return item.transaction_id;
+				}
+				this.database.prepare(`INSERT INTO _silo_outbox
+              (sequence, transaction_id, kind, base_generation, schema_revision, operation_json, changeset, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(item.sequence, item.transaction_id, item.kind, generation, item.schema_revision, JSON.stringify(item.operation), item.changeset, item.created_at);
+			}
+			this.verify(this.getSchema());
+			const integrity = this.database.prepare("PRAGMA integrity_check").get();
+			if (!Object.values(integrity).some((value) => value === "ok")) throw new SiloError(exits.integrity, "integrity_check_failed", "SQLite integrity check failed.");
+			this.database.exec("COMMIT");
+			return;
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	mutateRows(operation, mutate) {
+		const sync = this.getSyncState();
+		const session = sync ? this.database.createSession() : void 0;
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			const result = mutate();
+			if (session) {
+				const changeset = session.changeset();
+				if (changeset.byteLength) this.database.prepare(`INSERT INTO _silo_outbox
+                (transaction_id, kind, base_generation, schema_revision, operation_json, changeset, created_at)
+               VALUES (?, 'data', ?, ?, ?, ?, ?)`).run(randomUUID(), sync.base_generation, this.getSchema().revision, JSON.stringify(operation(result)), changeset, now());
+			}
+			this.database.exec("COMMIT");
+			return result;
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			return sqliteError(error);
+		} finally {
+			session?.close();
+		}
+	}
+	prepareSchemaMutation(proposed) {
+		const sync = this.getSyncState();
+		if (!sync) return void 0;
+		if (sync.conflict_transaction_id) throw new SiloError(exits.revision, "sync_conflict_unresolved", `Resolve synchronized transaction ${sync.conflict_transaction_id} before changing schema.`);
+		if (this.pendingTransactions().length) throw new SiloError(exits.revision, "sync_schema_requires_clean_base", "Push or discard pending transactions before changing synchronized schema.");
+		validateSynchronizedSchema(proposed);
+		return sync;
+	}
+	recordSchemaMutation(sync, operation, beforeRevision, afterRevision) {
+		if (!sync) return;
+		this.database.prepare(`INSERT INTO _silo_outbox
+          (transaction_id, kind, base_generation, schema_revision, operation_json, changeset, created_at)
+         VALUES (?, 'schema', ?, ?, ?, ?, ?)`).run(randomUUID(), sync.base_generation, afterRevision, JSON.stringify({
+			...operation,
+			before_revision: beforeRevision,
+			after_revision: afterRevision
+		}), /* @__PURE__ */ new Uint8Array(), now());
+	}
+	replaceSchema(schema) {
+		this.database.prepare("UPDATE _silo_schema SET schema_json = ? WHERE id = 1").run(JSON.stringify(schema));
+		this.database.prepare("UPDATE _silo_meta SET value = ? WHERE key = 'updated_at'").run(now());
+		if (schema.template_imports?.length) this.database.prepare("INSERT INTO _silo_meta (key, value) VALUES ('template_names', ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value").run(JSON.stringify(schema.template_imports.map((item) => item.name)));
+	}
+	createTable(input) {
+		const table = parseTable(input);
+		const schema = this.getSchema();
+		if (schema.tables.some((candidate) => candidate.name.toLowerCase() === table.name.toLowerCase())) throw new SiloError(exits.schema, "table_exists", `${table.name} already exists.`, "$.name");
+		const proposed = {
+			...schema,
+			revision: schema.revision + 1,
+			tables: [...schema.tables, table]
+		};
+		validateCompiledSchema(proposed);
+		const sync = this.prepareSchemaMutation(proposed);
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			this.database.exec(compileTable(table).join("\n"));
+			this.replaceSchema(proposed);
+			this.verify(proposed);
+			this.recordSchemaMutation(sync, {
+				command: "table.create",
+				table: table.name
+			}, schema.revision, proposed.revision);
+			this.database.exec("COMMIT");
+			return table;
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	importTemplate(name, template) {
+		const schema = this.getSchema();
+		const existing = new Set(schema.tables.map((table) => table.name.toLowerCase()));
+		const conflict = template.tables.find((table) => existing.has(table.name.toLowerCase()));
+		if (conflict) throw new SiloError(exits.schema, "template_table_conflict", `Template ${name} conflicts with existing table ${conflict.name}.`, "$.tables");
+		const proposed = {
+			...schema,
+			revision: schema.revision + 1,
+			tables: [...schema.tables, ...template.tables],
+			template_imports: [...schema.template_imports ?? [], {
+				name,
+				imported_at: now()
+			}],
+			agent_instructions: [...schema.agent_instructions ?? [], ...template.agent_instructions ? [{
+				source: `template:${name}`,
+				content: template.agent_instructions
+			}] : []]
+		};
+		validateCompiledSchema(proposed);
+		const sync = this.prepareSchemaMutation(proposed);
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			this.database.exec(template.tables.flatMap(compileTable).join("\n"));
+			this.replaceSchema(proposed);
+			this.verify(proposed);
+			this.recordSchemaMutation(sync, {
+				command: "schema.import",
+				template: name
+			}, schema.revision, proposed.revision);
+			this.database.exec("COMMIT");
+			return proposed;
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	alterTable(name, input) {
+		if (!input || typeof input !== "object" || Array.isArray(input)) throw new SiloError(exits.input, "invalid_shape", "Expected an alter request object.");
+		const request = input;
+		const unknown = Object.keys(request).find((key) => key !== "add_columns" && key !== "add_indexes");
+		if (unknown) throw new SiloError(exits.input, "unknown_field", `Unknown field ${unknown}.`, `$.${unknown}`);
+		const schema = this.getSchema();
+		const position = schema.tables.findIndex((table) => table.name.toLowerCase() === name.toLowerCase());
+		if (position < 0) throw new SiloError(exits.notFound, "table_not_found", `${name} does not exist.`);
+		const current = schema.tables[position];
+		const candidate = parseTable({
+			...current,
+			columns: [...current.columns, ...request.add_columns ?? []],
+			indexes: [...current.indexes ?? [], ...request.add_indexes ?? []]
+		});
+		for (const column of request.add_columns ?? []) {
+			const value = column;
+			if (value.generated || value.nullable === false && value.default === void 0) throw new SiloError(exits.schema, "unsupported_alter", "Added columns must be nullable or have a compatible constant default, and cannot be generated.");
+			if (value.default?.expression) throw new SiloError(exits.schema, "unsupported_alter", "Added-column defaults must be JSON literals in the initial release.");
+		}
+		const proposed = {
+			...schema,
+			revision: schema.revision + 1,
+			tables: schema.tables.map((table, i) => i === position ? candidate : table)
+		};
+		validateCompiledSchema(proposed);
+		const sync = this.prepareSchemaMutation(proposed);
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			for (const column of request.add_columns ?? []) this.database.exec(`ALTER TABLE ${quote(current.name)} ADD COLUMN ${compileTable({
+				...current,
+				columns: [column],
+				primary_key: void 0,
+				foreign_keys: [],
+				unique_constraints: [],
+				indexes: [],
+				checks: [],
+				policies: []
+			})[0].match(/\(\n  (.*)\n\)/s)[1]};`);
+			if ((candidate.indexes?.slice(current.indexes?.length ?? 0) ?? []).length) {
+				const indexes = compileTable(candidate).filter((statement) => /^CREATE (?:UNIQUE )?INDEX /.test(statement));
+				for (const statement of indexes.slice(current.indexes?.length ?? 0)) this.database.exec(statement);
+			}
+			this.replaceSchema(proposed);
+			this.verify(proposed);
+			this.recordSchemaMutation(sync, {
+				command: "table.alter",
+				table: current.name
+			}, schema.revision, proposed.revision);
+			this.database.exec("COMMIT");
+			return candidate;
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	dropTable(name) {
+		const schema = this.getSchema();
+		const existing = schema.tables.find((table) => table.name.toLowerCase() === name.toLowerCase());
+		if (!existing) throw new SiloError(exits.notFound, "table_not_found", `${name} does not exist.`);
+		const proposed = {
+			...schema,
+			revision: schema.revision + 1,
+			tables: schema.tables.filter((table) => table.name !== existing.name)
+		};
+		validateCompiledSchema(proposed);
+		const sync = this.prepareSchemaMutation(proposed);
+		try {
+			this.database.exec("BEGIN IMMEDIATE");
+			this.database.exec(`DROP TABLE ${quote(existing.name)}`);
+			this.replaceSchema(proposed);
+			this.verify(proposed);
+			this.recordSchemaMutation(sync, {
+				command: "table.drop",
+				table: existing.name
+			}, schema.revision, proposed.revision);
+			this.database.exec("COMMIT");
+		} catch (error) {
+			try {
+				this.database.exec("ROLLBACK");
+			} catch {}
+			sqliteError(error);
+		}
+	}
+	verify(schema) {
+		verifyPhysical(this.database, schema);
+	}
+	table(name) {
+		const table = this.getSchema().tables.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase());
+		if (!table) throw new SiloError(exits.notFound, "table_not_found", `${name} does not exist.`);
+		return table;
+	}
+	addRows(name, input, upsert = false) {
+		const table = this.table(name);
+		const rows = Array.isArray(input) ? input : [input];
+		if (!rows.length) throw new SiloError(exits.input, "invalid_shape", "At least one row is required.");
+		return this.mutateRows((results) => ({
+			command: upsert ? "row.upsert" : "row.add",
+			table: table.name,
+			keys: table.primary_key ? results.map((row) => table.primary_key.map((key) => row[key])) : []
+		}), () => {
+			const results = [];
+			for (const raw of rows) {
+				if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new SiloError(exits.input, "invalid_shape", "Each row must be an object.");
+				const request = raw;
+				const row = this.prepareRow(table, request, true);
+				const columns = Object.keys(row);
+				let sql = columns.length ? `INSERT INTO ${quote(table.name)} (${columns.map(quote).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})` : `INSERT INTO ${quote(table.name)} DEFAULT VALUES`;
+				let naturalKeys;
+				if (upsert) {
+					const upsertPolicy = policy(table, "natural_key_upsert");
+					if (!upsertPolicy) throw new SiloError(exits.schema, "upsert_not_declared", "The table has no natural_key_upsert policy.");
+					const keys = upsertPolicy.columns;
+					if (keys.some((key) => row[key] === void 0)) throw new SiloError(exits.input, "upsert_key_required", "Every natural-key upsert column must be provided.");
+					naturalKeys = keys;
+					const allowed = (upsertPolicy.update_columns ?? Object.keys(request).filter((column) => !keys.includes(column))).filter((column) => columns.includes(column));
+					if (!allowed.length) {
+						const existing = this.findPersistedRow(table, keys, row);
+						if (existing) {
+							results.push(existing);
+							continue;
+						}
+					}
+					sql += ` ON CONFLICT (${keys.map(quote).join(", ")}) ${allowed.length ? `DO UPDATE SET ${allowed.map((column) => `${quote(column)} = excluded.${quote(column)}`).join(", ")}` : "DO NOTHING"}`;
+				}
+				sql += ` RETURNING ${table.without_rowid ? "" : "rowid AS \"_silo_rowid\", "}*`;
+				const returned = this.database.prepare(sql).get(...Object.values(row));
+				results.push(this.readPersistedRow(table, returned, naturalKeys, row));
+			}
+			return results;
+		});
+	}
+	readPersistedRow(table, returned, fallbackColumns, fallbackValues) {
+		let where;
+		let values;
+		if (returned?._silo_rowid !== void 0) {
+			where = "rowid = ?";
+			values = [binding(returned._silo_rowid)];
+		} else {
+			const columns = returned ? table.primary_key : fallbackColumns;
+			if (!columns?.length) throw new SiloError(exits.integrity, "persisted_row_unresolved", "The persisted row could not be located after mutation.");
+			where = columns.map((column) => `${quote(column)} = ?`).join(" AND ");
+			values = columns.map((column) => binding(returned ? returned[column] : fallbackValues?.[column]));
+		}
+		const persisted = this.database.prepare(`SELECT * FROM ${quote(table.name)} WHERE ${where}`).get(...values);
+		if (!persisted) throw new SiloError(exits.integrity, "persisted_row_unresolved", "The persisted row could not be located after mutation.");
+		return this.renderRow(table, persisted);
+	}
+	findPersistedRow(table, columns, source) {
+		const persisted = this.database.prepare(`SELECT * FROM ${quote(table.name)} WHERE ${columns.map((column) => `${quote(column)} = ?`).join(" AND ")}`).get(...columns.map((column) => source[column]));
+		return persisted ? this.renderRow(table, persisted) : void 0;
+	}
+	prepareRow(table, raw, insert) {
+		const known = new Map(table.columns.map((column) => [column.name, column]));
+		for (const key of Object.keys(raw)) if (!known.has(key)) throw new SiloError(exits.input, "unknown_field", `Unknown field ${key}.`, `$.${key}`);
+		else if (known.get(key).generated) throw new SiloError(exits.input, "generated_column_input", `Generated column ${key} cannot be written directly.`, `$.${key}`);
+		const row = {};
+		for (const [key, value] of Object.entries(raw)) row[key] = binding(canonicalize(known.get(key), value));
+		if (insert) {
+			const identity = policy(table, "generated_identity");
+			if (identity && identity.strategy !== "integer" && row[identity.column] === void 0) row[identity.column] = generatedValue(identity.strategy);
+			const timestamps = policy(table, "timestamps");
+			if (timestamps) {
+				const timestamp = now();
+				if (timestamps.created_column && row[timestamps.created_column] === void 0) row[timestamps.created_column] = timestamp;
+				if (timestamps.updated_column && row[timestamps.updated_column] === void 0) row[timestamps.updated_column] = timestamp;
+			}
+			const revision = policy(table, "optimistic_revision");
+			if (revision && row[revision.column] === void 0) row[revision.column] = binding(revision.initial ?? 1);
+		}
+		return row;
+	}
+	keyWhere(table, key) {
+		const keys = table.primary_key?.length ? table.primary_key : table.columns.filter((column) => policy(table, "generated_identity")?.column === column.name).map((column) => column.name);
+		if (!keys?.length) throw new SiloError(exits.schema, "primary_key_required", "Row-by-key operations require a primary key or generated identity.");
+		let values;
+		if (keys.length === 1) values = [key];
+		else if (Array.isArray(key)) values = key;
+		else if (typeof key === "string") try {
+			const decoded = JSON.parse(key);
+			values = Array.isArray(decoded) ? decoded : [];
+		} catch {
+			values = [];
+		}
+		else values = [];
+		if (values.length !== keys.length) throw new SiloError(exits.input, "invalid_key", `Expected ${keys.length} key values.`);
+		return {
+			sql: keys.map((column) => `${quote(column)} = ?`).join(" AND "),
+			values: values.map((value, i) => {
+				const column = table.columns.find((candidate) => candidate.name === keys[i]);
+				let decoded = value;
+				if (typeof value === "string") {
+					if (semantic(column).storage !== "TEXT" || column.type === "text/json" || /^"(?:[^"\\]|\\.)*"$/.test(value)) try {
+						decoded = JSON.parse(value);
+					} catch {}
+				}
+				return binding(canonicalize(column, decoded));
+			})
+		};
+	}
+	getRow(name, key) {
+		const table = this.table(name);
+		const where = this.keyWhere(table, key);
+		const row = this.database.prepare(`SELECT * FROM ${quote(table.name)} WHERE ${where.sql}`).get(...where.values);
+		if (!row) throw new SiloError(exits.notFound, "row_not_found", "No row matches the supplied key.");
+		return this.renderRow(table, row);
+	}
+	listRows(name, limit, offset) {
+		const table = this.table(name);
+		const order = table.primary_key?.length ? ` ORDER BY ${table.primary_key.map(quote).join(", ")}` : table.without_rowid ? "" : " ORDER BY rowid";
+		return this.database.prepare(`SELECT * FROM ${quote(table.name)}${order} LIMIT ? OFFSET ?`).all(limit, offset).map((row) => this.renderRow(table, row));
+	}
+	renderRow(table, row) {
+		return Object.fromEntries(Object.entries(row).map(([name, value]) => [name, semantic(table.columns.find((column) => column.name === name)).render?.(value) ?? value]));
+	}
+	updateRow(name, key, input) {
+		const table = this.table(name);
+		if (!input || typeof input !== "object" || Array.isArray(input)) throw new SiloError(exits.input, "invalid_shape", "Expected a row object.");
+		const raw = { ...input };
+		const expected = raw._expected_revision;
+		delete raw._expected_revision;
+		if (this.getSyncState() && table.primary_key?.some((column) => column in raw)) throw new SiloError(exits.input, "sync_primary_key_immutable", "Synchronized primary-key values cannot be updated.");
+		const row = this.prepareRow(table, raw, false);
+		const timestamps = policy(table, "timestamps");
+		const revision = policy(table, "optimistic_revision");
+		const where = this.keyWhere(table, key);
+		if (timestamps?.updated_column) {
+			const column = timestamps.updated_column;
+			row[column] = laterThan(this.database.prepare(`SELECT ${quote(column)} AS value FROM ${quote(table.name)} WHERE ${where.sql}`).get(...where.values)?.value);
+		}
+		if (revision) {
+			if (!Number.isSafeInteger(expected)) throw new SiloError(exits.input, "expected_revision_required", "_expected_revision is required for this table.");
+			where.sql += ` AND ${quote(revision.column)} = ?`;
+			where.values.push(Number(expected));
+			row[revision.column] = Number(expected) + 1;
+		}
+		const columns = Object.keys(row);
+		if (!columns.length) throw new SiloError(exits.input, "empty_update", "At least one field must be updated.");
+		return this.mutateRows(() => ({
+			command: "row.update",
+			table: table.name,
+			key
+		}), () => {
+			const result = this.database.prepare(`UPDATE ${quote(table.name)} SET ${columns.map((column) => `${quote(column)} = ?`).join(", ")} WHERE ${where.sql}`).run(...Object.values(row), ...where.values);
+			if (!result.changes) throw new SiloError(revision ? exits.revision : exits.notFound, revision ? "revision_conflict" : "row_not_found", revision ? "The row revision did not match." : "No row matches the supplied key.");
+			return Number(result.changes);
+		});
+	}
+	deleteRow(name, key) {
+		const table = this.table(name);
+		const where = this.keyWhere(table, key);
+		return this.mutateRows(() => ({
+			command: "row.delete",
+			table: table.name,
+			key
+		}), () => {
+			const result = this.database.prepare(`DELETE FROM ${quote(table.name)} WHERE ${where.sql}`).run(...where.values);
+			if (!result.changes) throw new SiloError(exits.notFound, "row_not_found", "No row matches the supplied key.");
+			return Number(result.changes);
+		});
+	}
+	query(sql) {
+		try {
+			const statement = this.database.prepare(sql);
+			statement.setReturnArrays(true);
+			const rawColumns = statement.columns().map((column) => column.name || "column");
+			const seen = /* @__PURE__ */ new Map();
+			return {
+				columns: rawColumns.map((name) => {
+					const count = (seen.get(name) ?? 0) + 1;
+					seen.set(name, count);
+					return count === 1 ? name : `${name}_${count}`;
+				}),
+				rows: statement.all()
+			};
+		} catch (error) {
+			sqliteError(error);
+		}
+	}
+	ddl() {
+		return compileSchema(this.getSchema()).join("\n\n");
+	}
+};
+function emptySchema() {
+	return {
+		format_version: 1,
+		registry_version: 1,
+		revision: 1,
+		tables: []
+	};
+}
+function schemaFromTemplate(name, template, importedAt = now()) {
+	const schema = {
+		...emptySchema(),
+		tables: template.tables,
+		template_imports: [{
+			name,
+			imported_at: importedAt
+		}],
+		...template.agent_instructions ? { agent_instructions: [{
+			source: `template:${name}`,
+			content: template.agent_instructions
+		}] } : {}
+	};
+	validateCompiledSchema(schema);
+	return schema;
+}
+function sqliteVersion() {
+	const database = new DatabaseSync(":memory:");
+	try {
+		database.exec("CREATE TABLE _capability_probe (value TEXT) STRICT; DROP TABLE _capability_probe;");
+		return String(Object.values(database.prepare("SELECT sqlite_version() AS version").get())[0]);
+	} finally {
+		database.close();
+	}
+}
+function readTemplate(name) {
+	if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name)) throw new SiloError(exits.input, "invalid_template_name", "Template names use letters, digits, hyphens, and underscores.");
+	const localPath = join(dataRoot(), "templates", `${name}.json`);
+	const bundledPath = join(fileURLToPath(new URL("../templates", import.meta.url)), `${name}.json`);
+	const path = existsSync(localPath) ? localPath : bundledPath;
+	if (!existsSync(path)) throw new SiloError(exits.notFound, "template_not_found", `${name} does not exist.`);
+	try {
+		const value = JSON.parse(readFileSync(path, "utf8"));
+		if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("template must be an object");
+		const unknown = Object.keys(value).find((key) => ![
+			"format_version",
+			"agent_instructions",
+			"tables"
+		].includes(key));
+		if (unknown) throw new Error(`unknown field ${unknown}`);
+		if (value.format_version !== void 0 && value.format_version !== 1) throw new Error("format_version must be 1");
+		if (value.agent_instructions !== void 0 && (typeof value.agent_instructions !== "string" || !value.agent_instructions.trim())) throw new Error("agent_instructions must be a non-empty string");
+		if (!Array.isArray(value.tables)) throw new Error("tables must be an array");
+		const tables = value.tables.map(parseTable);
+		validateCompiledSchema({
+			format_version: 1,
+			registry_version: 1,
+			revision: 1,
+			tables
+		});
+		return {
+			format_version: 1,
+			...value.agent_instructions ? { agent_instructions: value.agent_instructions } : {},
+			tables
+		};
+	} catch (error) {
+		if (error instanceof SiloError) throw error;
+		throw new SiloError(exits.input, "invalid_template", error instanceof Error ? error.message : String(error));
+	}
+}
+function listTemplates() {
+	const roots = [fileURLToPath(new URL("../templates", import.meta.url)), join(dataRoot(), "templates")];
+	return [...new Set(roots.flatMap((root) => existsSync(root) ? readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -5)) : []))].sort();
+}
+function discoverDatabases() {
+	const root = join(dataRoot(), "databases");
+	if (!existsSync(root)) return [];
+	const paths = [];
+	const walk = (directory) => {
+		for (const entry of readdirSync(directory, { withFileTypes: true })) {
+			const path = join(directory, entry.name);
+			if (entry.isDirectory()) walk(path);
+			else if (entry.name.endsWith(".sqlite")) paths.push(path);
+		}
+	};
+	walk(root);
+	return paths.sort().map((path) => {
+		let identity;
+		let database;
+		try {
+			database = new DatabaseSync(path, { readOnly: true });
+			configure(database, false);
+			const meta = metadata(database);
+			identity = meta.identity;
+			verifyPhysical(database, readSchema(database));
+			return {
+				path,
+				state: "recognized",
+				identity: meta.identity
+			};
+		} catch (error) {
+			return {
+				path,
+				state: error instanceof SiloError && error.code === "unrecognized_database" ? "unrecognized" : error instanceof SiloError && error.exitCode === exits.integrity ? "incompatible" : "unreadable",
+				identity,
+				message: error instanceof Error ? error.message : String(error)
+			};
+		} finally {
+			database?.close();
+		}
+	});
+}
+//#endregion
+//#region src/report-viewer.tsx
+const stylesheet = readFileSync(new URL("./report-viewer.css", import.meta.url), "utf8");
+function ReportMarkdown({ markdown }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "report-markdown",
+		children: /* @__PURE__ */ jsx(ReactMarkdown, {
+			remarkPlugins: [remarkGfm],
+			skipHtml: true,
+			children: markdown
+		})
+	});
+}
+function renderReportHtml(markdown) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(ReportMarkdown, { markdown }));
+}
+function SavedQueries({ queries }) {
+	return /* @__PURE__ */ jsxs("details", {
+		className: "query-panel",
+		children: [/* @__PURE__ */ jsxs("summary", { children: [
+			"Saved queries (",
+			queries.length,
+			")"
+		] }), /* @__PURE__ */ jsx("div", {
+			className: "query-list",
+			children: queries.map((query) => /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h3", { children: query.name }), /* @__PURE__ */ jsx("pre", { children: /* @__PURE__ */ jsx("code", { children: query.sql }) })] }, query.name))
+		})]
+	});
+}
+function renderSavedQueries(queries) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(SavedQueries, { queries }));
+}
+function clientScript(slug, token) {
+	return `
+const slug = ${JSON.stringify(slug)};
+const token = ${JSON.stringify(token)};
+const content = document.querySelector('[data-report-content]');
+const status = document.querySelector('[data-refresh-status]');
+const refreshed = document.querySelector('[data-refreshed-at]');
+const error = document.querySelector('[data-refresh-error]');
+const reportTitle = document.querySelector('[data-report-title]');
+const savedQueries = document.querySelector('[data-saved-queries]');
+let refreshRequest;
+
+function displayTime(value) {
+  return new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeStyle: 'short' }).format(new Date(value));
+}
+
+async function refresh() {
+  if (refreshRequest) return refreshRequest;
+  document.body.dataset.refreshState = 'refreshing';
+  status.textContent = 'Refreshing…';
+  error.hidden = true;
+  refreshRequest = fetch('/api/reports/' + encodeURIComponent(slug) + '/refresh', {
+    method: 'POST',
+    headers: { 'x-silo-token': token }
+  }).then(async (response) => {
+    const body = await response.json();
+    if (!response.ok) throw new Error(body.error?.message || 'Refresh failed.');
+    content.innerHTML = body.html;
+    reportTitle.textContent = body.title;
+    if (savedQueries.innerHTML !== body.queries_html) savedQueries.innerHTML = body.queries_html;
+    document.title = body.title + ' · Silo';
+    refreshed.dateTime = body.refreshed_at;
+    refreshed.textContent = displayTime(body.refreshed_at);
+    status.textContent = 'Current';
+    document.body.dataset.refreshState = 'current';
+  }).catch((cause) => {
+    status.textContent = 'Showing last good result';
+    error.textContent = cause instanceof Error ? cause.message : String(cause);
+    error.hidden = false;
+    document.body.dataset.refreshState = 'stale';
+  }).finally(() => {
+    refreshRequest = undefined;
+  });
+  return refreshRequest;
+}
+
+window.addEventListener('focus', () => {
+  if (!document.hidden) refresh();
+});
+document.addEventListener('visibilitychange', () => {
+  if (!document.hidden) refresh();
+});
+refresh();
+`;
+}
+function reportDocument(report, token, nonce) {
+	const script = clientScript(report.slug, token);
+	return `<!doctype html>${renderToStaticMarkup(/* @__PURE__ */ jsxs("html", {
+		lang: "en",
+		children: [/* @__PURE__ */ jsxs("head", { children: [
+			/* @__PURE__ */ jsx("meta", { charSet: "utf-8" }),
+			/* @__PURE__ */ jsx("meta", {
+				name: "viewport",
+				content: "width=device-width, initial-scale=1"
+			}),
+			/* @__PURE__ */ jsx("meta", {
+				name: "color-scheme",
+				content: "light dark"
+			}),
+			/* @__PURE__ */ jsx("title", { children: `${report.title} · Silo` }),
+			/* @__PURE__ */ jsx("link", {
+				rel: "stylesheet",
+				href: "/report-viewer.css"
+			})
+		] }), /* @__PURE__ */ jsxs("body", {
+			"data-refresh-state": report.last_refresh_error ? "stale" : "current",
+			children: [
+				/* @__PURE__ */ jsxs("header", {
+					className: "site-header",
+					children: [/* @__PURE__ */ jsxs("a", {
+						className: "brand",
+						href: `/reports/${encodeURIComponent(report.slug)}`,
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "brand-mark",
+							"aria-hidden": "true",
+							children: "S"
+						}), /* @__PURE__ */ jsx("span", { children: "Silo report" })]
+					}), /* @__PURE__ */ jsxs("div", {
+						className: "refresh-state",
+						"aria-live": "polite",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "status-dot",
+							"aria-hidden": "true"
+						}), /* @__PURE__ */ jsx("span", {
+							"data-refresh-status": true,
+							children: report.last_refresh_error ? "Showing last good result" : "Current"
+						})]
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "page-shell",
+					children: [/* @__PURE__ */ jsx("main", {
+						className: "report-card",
+						"data-report-content": true,
+						children: /* @__PURE__ */ jsx(ReportMarkdown, { markdown: report.rendered_markdown })
+					}), /* @__PURE__ */ jsxs("aside", {
+						className: "report-sidebar",
+						"aria-label": "Report details",
+						children: [/* @__PURE__ */ jsxs("section", {
+							className: "metadata-card",
+							children: [
+								/* @__PURE__ */ jsx("p", {
+									className: "eyebrow",
+									children: "Report"
+								}),
+								/* @__PURE__ */ jsx("h2", {
+									"data-report-title": true,
+									children: report.title
+								}),
+								/* @__PURE__ */ jsxs("dl", { children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("dt", { children: "Slug" }), /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx("code", { children: report.slug }) })] }), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("dt", { children: "Last refreshed" }), /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx("time", {
+									dateTime: report.refreshed_at,
+									"data-refreshed-at": true,
+									children: new Date(report.refreshed_at).toLocaleString()
+								}) })] })] }),
+								/* @__PURE__ */ jsx("p", {
+									className: "refresh-error",
+									role: "alert",
+									"data-refresh-error": true,
+									hidden: !report.last_refresh_error,
+									children: report.last_refresh_error
+								})
+							]
+						}), /* @__PURE__ */ jsx("div", {
+							"data-saved-queries": true,
+							children: /* @__PURE__ */ jsx(SavedQueries, { queries: report.queries })
+						})]
+					})]
+				}),
+				/* @__PURE__ */ jsx("script", {
+					nonce,
+					dangerouslySetInnerHTML: { __html: script }
+				})
+			]
+		})]
+	}))}`;
+}
+function send(response, status, contentType, body) {
+	response.writeHead(status, {
+		"content-type": contentType,
+		"content-length": Buffer.byteLength(body),
+		"cache-control": "no-store"
+	});
+	response.end(body);
+}
+function sameToken(actual, expected) {
+	if (!actual) return false;
+	const left = Buffer.from(actual);
+	const right = Buffer.from(expected);
+	return left.length === right.length && timingSafeEqual(left, right);
+}
+function closeDatabase(database, action) {
+	try {
+		return action(database);
+	} finally {
+		database.close();
+	}
+}
+async function launch(url) {
+	const command = process.platform === "darwin" ? {
+		executable: "open",
+		args: [url]
+	} : process.platform === "win32" ? {
+		executable: "rundll32",
+		args: ["url.dll,FileProtocolHandler", url]
+	} : {
+		executable: "xdg-open",
+		args: [url]
+	};
+	await new Promise((resolve, reject) => {
+		const child = spawn(command.executable, command.args, {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
+}
+async function startReportViewer(workspace, slug, options = {}) {
+	closeDatabase(SiloDatabase.open(workspace), (database) => database.getReport(slug));
+	const token = randomBytes(32).toString("base64url");
+	const nonce = randomBytes(24).toString("base64url");
+	let origin = "";
+	const reportPath = `/reports/${encodeURIComponent(slug)}`;
+	const refreshPath = `/api/reports/${encodeURIComponent(slug)}/refresh`;
+	const server = createServer((request, response) => {
+		(async () => {
+			const url = new URL(request.url ?? "/", origin);
+			if (request.method === "GET" && url.pathname === "/report-viewer.css") {
+				send(response, 200, "text/css; charset=utf-8", stylesheet);
+				return;
+			}
+			if (request.method === "GET" && url.pathname === reportPath) {
+				const html = reportDocument(closeDatabase(SiloDatabase.open(workspace), (database) => database.getReport(slug)), token, nonce);
+				response.setHeader("content-security-policy", `default-src 'none'; style-src 'self'; script-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`);
+				response.setHeader("x-content-type-options", "nosniff");
+				response.setHeader("referrer-policy", "no-referrer");
+				send(response, 200, "text/html; charset=utf-8", html);
+				return;
+			}
+			if (request.method === "POST" && url.pathname === refreshPath) {
+				if (request.headers.host !== new URL(origin).host || request.headers.origin !== origin || !sameToken(Array.isArray(request.headers["x-silo-token"]) ? request.headers["x-silo-token"][0] : request.headers["x-silo-token"], token)) {
+					send(response, 403, "application/json; charset=utf-8", JSON.stringify({ error: { message: "Refresh request rejected." } }));
+					return;
+				}
+				try {
+					const report = closeDatabase(SiloDatabase.open(workspace, true), (database) => database.refreshReport(slug));
+					send(response, 200, "application/json; charset=utf-8", JSON.stringify({
+						html: renderReportHtml(report.rendered_markdown),
+						title: report.title,
+						queries_html: renderSavedQueries(report.queries),
+						refreshed_at: report.refreshed_at
+					}));
+				} catch (error) {
+					const silo = error instanceof SiloError ? error : new SiloError(exits.io, "unexpected_error", error instanceof Error ? error.message : String(error));
+					send(response, silo.exitCode === exits.notFound ? 404 : silo.exitCode === exits.input ? 400 : 500, "application/json; charset=utf-8", JSON.stringify({ error: {
+						code: silo.code,
+						message: silo.message
+					} }));
+				}
+				return;
+			}
+			send(response, 404, "text/plain; charset=utf-8", "Not found.\n");
+		})().catch((error) => {
+			if (!response.headersSent) send(response, 500, "application/json; charset=utf-8", JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
+			else response.destroy(error instanceof Error ? error : void 0);
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	const address = server.address();
+	if (!address || typeof address === "string") {
+		server.close();
+		throw new SiloError(exits.io, "viewer_address_unavailable", "Could not resolve the viewer address.");
+	}
+	origin = `http://127.0.0.1:${address.port}`;
+	const url = `${origin}${reportPath}`;
+	if (options.launchBrowser !== false) try {
+		await launch(url);
+	} catch (error) {
+		server.close();
+		throw new SiloError(exits.io, "browser_open_failed", error instanceof Error ? error.message : String(error));
+	}
+	return {
+		server,
+		url,
+		token,
+		close: () => new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()))
+	};
+}
+//#endregion
+//#region src/sync.ts
+const exec = promisify(execFile);
+function parseRemoteUrl(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new SiloError(exits.input, "invalid_sync_remote", "Expected an s3://bucket/prefix URL.");
+	}
+	const prefix = url.pathname.replace(/^\/+|\/+$/g, "");
+	if (url.protocol !== "s3:" || !url.hostname || !prefix || url.search || url.hash) throw new SiloError(exits.input, "invalid_sync_remote", "Expected an s3://bucket/prefix URL.");
+	return {
+		bucket: url.hostname,
+		prefix
+	};
+}
+function parseManifest(value) {
+	try {
+		const manifest = JSON.parse(value);
+		if (manifest.format_version !== 1 || typeof manifest.database_id !== "string" || typeof manifest.identity !== "string" || typeof manifest.generation !== "string" || typeof manifest.publication_id !== "string" || manifest.parent_generation !== null && typeof manifest.parent_generation !== "string" || !Number.isSafeInteger(manifest.schema_revision) || typeof manifest.database_sha256 !== "string" || !/^[0-9a-f]{64}$/.test(manifest.database_sha256) || typeof manifest.created_at !== "string") throw new Error("required fields are missing or invalid");
+		return manifest;
+	} catch (error) {
+		throw new SiloError(exits.integrity, "sync_manifest_invalid", `Remote HEAD is invalid: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+var S3SyncRemote = class {
+	url;
+	bucket;
+	prefix;
+	client;
+	constructor(url, client) {
+		this.url = url;
+		const parsed = parseRemoteUrl(url);
+		this.bucket = parsed.bucket;
+		this.prefix = parsed.prefix;
+		const endpoint = process.env.AWS_ENDPOINT_URL_S3;
+		this.client = client ?? new S3Client({
+			region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1",
+			...endpoint ? {
+				endpoint,
+				forcePathStyle: true
+			} : {}
+		});
+	}
+	get headKey() {
+		return `${this.prefix}/HEAD`;
+	}
+	async readHead() {
+		try {
+			const response = await this.client.send(new GetObjectCommand({
+				Bucket: this.bucket,
+				Key: this.headKey
+			}));
+			if (!response.Body || !response.ETag) throw new SiloError(exits.integrity, "sync_manifest_incomplete", "Remote HEAD has no body or entity tag.");
+			return {
+				manifest: parseManifest(await response.Body.transformToString()),
+				etag: response.ETag
+			};
+		} catch (error) {
+			if (error.$metadata?.httpStatusCode === 404 || error.name === "NoSuchKey") return void 0;
+			if (error instanceof SiloError) throw error;
+			throw new SiloError(exits.io, "sync_remote_read_failed", error instanceof Error ? error.message : String(error));
+		}
+	}
+	async publishHead(manifest, expectedEtag) {
+		const input = {
+			Bucket: this.bucket,
+			Key: this.headKey,
+			Body: `${JSON.stringify(manifest)}\n`,
+			ContentType: "application/json",
+			...expectedEtag === null ? { IfNoneMatch: "*" } : { IfMatch: expectedEtag }
+		};
+		try {
+			const response = await this.client.send(new PutObjectCommand(input));
+			if (!response.ETag) throw new SiloError(exits.io, "sync_head_etag_missing", "Object storage did not return an entity tag for HEAD.");
+			return response.ETag;
+		} catch (error) {
+			const status = error.$metadata?.httpStatusCode;
+			if (status === 409 || status === 412) throw new SiloError(exits.revision, "sync_head_changed", "Remote HEAD changed during publication; pull and retry.");
+			if (error instanceof SiloError) throw error;
+			throw new SiloError(exits.io, "sync_remote_write_failed", error instanceof Error ? error.message : String(error));
+		}
+	}
+	generationUrl(generation) {
+		return `s3://${this.bucket}/${this.prefix}/generations/${generation}`;
+	}
+};
+var LitestreamCheckpoint = class {
+	executable;
+	constructor(executable = process.env.LITESTREAM_PATH ?? "litestream") {
+		this.executable = executable;
+	}
+	async check() {
+		try {
+			const { stdout, stderr } = await exec(this.executable, ["version"]);
+			const output = `${stdout} ${stderr}`.trim();
+			const version = /v?(\d+)\.(\d+)\.(\d+)/.exec(output);
+			const parts = version?.slice(1).map(Number);
+			if (!(parts && (parts[0] > 0 || parts[1] > 5 || parts[1] === 5 && parts[2] >= 12))) throw new SiloError(exits.io, "litestream_incompatible", `Litestream 0.5.12 or newer is required; found ${output || "an unknown version"}.`);
+			return version[0];
+		} catch (error) {
+			if (error instanceof SiloError) throw error;
+			throw new SiloError(exits.io, "litestream_unavailable", "Litestream 0.5.12 or newer is required on PATH or through LITESTREAM_PATH.");
+		}
+	}
+	async publish(databasePath, replicaUrl) {
+		await this.check();
+		await new Promise((resolve, reject) => {
+			const child = spawn(this.executable, [
+				"replicate",
+				databasePath,
+				replicaUrl
+			], { stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			] });
+			let stderr = "";
+			child.stderr.on("data", (chunk) => {
+				stderr = `${stderr}${String(chunk)}`.slice(-16384);
+			});
+			let requestedStop = false;
+			const stop = setTimeout(() => {
+				requestedStop = true;
+				child.kill("SIGINT");
+			}, 1500);
+			child.once("error", (error) => {
+				clearTimeout(stop);
+				reject(error);
+			});
+			child.once("close", (code, signal) => {
+				clearTimeout(stop);
+				if (code === 0 || requestedStop && signal === "SIGINT") resolve();
+				else reject(new SiloError(exits.io, "litestream_publish_failed", stderr.trim() || `Litestream exited with status ${code ?? signal}.`));
+			});
+		});
+	}
+	async restore(replicaUrl, outputPath) {
+		await this.check();
+		removeDatabase(outputPath);
+		try {
+			await exec(this.executable, [
+				"restore",
+				"-json",
+				"-o",
+				outputPath,
+				replicaUrl
+			]);
+		} catch (error) {
+			throw new SiloError(exits.io, "litestream_restore_failed", error instanceof Error ? error.message : String(error));
+		}
+	}
+};
+const defaultServices = {
+	remote: (url) => new S3SyncRemote(url),
+	checkpoint: new LitestreamCheckpoint()
+};
+function temporaryPath(workspace, label) {
+	return `${workspace.databasePath}.${label}.${randomUUID()}.sqlite`;
+}
+function removeDatabase(path) {
+	for (const suffix of [
+		"",
+		"-wal",
+		"-shm",
+		"-journal",
+		"-txid"
+	]) rmSync(`${path}${suffix}`, { force: true });
+}
+function hashDatabase(path) {
+	return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function validateHead(workspace, head, databaseId) {
+	if (head.manifest.identity !== workspace.identity) throw new SiloError(exits.integrity, "sync_identity_mismatch", "Remote HEAD belongs to a different Git workspace identity.");
+	if (databaseId && head.manifest.database_id !== databaseId) throw new SiloError(exits.integrity, "sync_database_mismatch", "Remote HEAD belongs to a different Silo database.");
+}
+function installDatabase(source, destination) {
+	removeDatabase(`${destination}.previous`);
+	for (const suffix of [
+		"-wal",
+		"-shm",
+		"-journal"
+	]) rmSync(`${destination}${suffix}`, { force: true });
+	try {
+		renameSync(source, destination);
+	} catch {
+		const previous = `${destination}.previous`;
+		if (existsSync(destination)) renameSync(destination, previous);
+		try {
+			renameSync(source, destination);
+			removeDatabase(previous);
+		} catch (error) {
+			if (existsSync(previous) && !existsSync(destination)) renameSync(previous, destination);
+			throw error;
+		}
+	}
+}
+async function withSyncLock(workspace, handler) {
+	mkdirSync(dirname(workspace.databasePath), { recursive: true });
+	const release = acquireFileLock(`${workspace.databasePath}.sync-lock`, "Another synchronization operation is running.");
+	try {
+		if (existsSync(`${workspace.databasePath}.write-lock`)) throw new SiloError(exits.io, "sync_in_progress", "Another writer is using this database.");
+		return await handler();
+	} finally {
+		release();
+	}
+}
+var SiloSync = class {
+	workspace;
+	services;
+	constructor(workspace, services = defaultServices) {
+		this.workspace = workspace;
+		this.services = services;
+	}
+	async initialize(remoteUrl) {
+		return withSyncLock(this.workspace, async () => {
+			await this.services.checkpoint.check();
+			const remote = this.services.remote(remoteUrl);
+			const head = await remote.readHead();
+			if (head) validateHead(this.workspace, head);
+			if (!existsSync(this.workspace.databasePath)) {
+				if (!head) throw new SiloError(exits.absent, "sync_database_absent", "Neither a local database nor a remote HEAD exists.");
+				const restored = temporaryPath(this.workspace, "bootstrap");
+				try {
+					await this.restoreAndVerify(remote, head, restored);
+					installDatabase(restored, this.workspace.databasePath);
+					const database = SiloDatabase.open(this.workspace, true, true);
+					try {
+						database.markSynchronized(head.manifest.generation, head.etag);
+					} finally {
+						database.close();
+					}
+				} finally {
+					removeDatabase(restored);
+				}
+			} else {
+				const database = SiloDatabase.open(this.workspace, true, true);
+				try {
+					const state = database.getSyncState();
+					if (head && !state) throw new SiloError(exits.revision, "sync_local_diverged", "A remote database already exists; initialize from a workspace without local state.");
+					const configured = database.configureSync(remoteUrl, head?.manifest.database_id);
+					if (head) validateHead(this.workspace, head, configured.database_id);
+				} finally {
+					database.close();
+				}
+			}
+			return this.status();
+		});
+	}
+	async status() {
+		if (!existsSync(this.workspace.databasePath)) return {
+			state: "unconfigured",
+			remote_url: null,
+			database_id: null,
+			local_generation: null,
+			remote_generation: null,
+			pending_transactions: 0,
+			conflict_transaction_id: null
+		};
+		const database = SiloDatabase.open(this.workspace);
+		let state;
+		let pending;
+		try {
+			state = database.getSyncState();
+			pending = database.pendingTransactions();
+		} finally {
+			database.close();
+		}
+		if (!state) return {
+			state: "unconfigured",
+			remote_url: null,
+			database_id: null,
+			local_generation: null,
+			remote_generation: null,
+			pending_transactions: 0,
+			conflict_transaction_id: null
+		};
+		const head = await this.services.remote(state.remote_url).readHead();
+		if (head) validateHead(this.workspace, head, state.database_id);
+		const remoteGeneration = head?.manifest.generation ?? null;
+		let status;
+		if (state.conflict_transaction_id) status = "conflicted";
+		else if (!head) status = "ahead";
+		else if (state.base_generation === remoteGeneration) status = pending.length ? "ahead" : "clean";
+		else if (pending.length) status = "diverged";
+		else status = "behind";
+		return {
+			state: status,
+			remote_url: state.remote_url,
+			database_id: state.database_id,
+			local_generation: state.base_generation,
+			remote_generation: remoteGeneration,
+			pending_transactions: pending.length,
+			conflict_transaction_id: state.conflict_transaction_id
+		};
+	}
+	async pull(discardTransactionId) {
+		return withSyncLock(this.workspace, async () => {
+			await this.pullUnlocked(discardTransactionId);
+			return this.status();
+		});
+	}
+	async pullUnlocked(discardTransactionId) {
+		await this.services.checkpoint.check();
+		const local = SiloDatabase.open(this.workspace, true, true);
+		let state;
+		let pending;
+		try {
+			state = local.getSyncState();
+			if (!state) throw new SiloError(exits.workspace, "sync_not_configured", "Synchronization is not configured.");
+			pending = local.pendingTransactions();
+			if (discardTransactionId && !pending.some((item) => item.transaction_id === discardTransactionId)) throw new SiloError(exits.notFound, "sync_transaction_not_found", `${discardTransactionId} is not a pending transaction.`);
+		} finally {
+			local.close();
+		}
+		const remote = this.services.remote(state.remote_url);
+		const head = await remote.readHead();
+		if (!head) throw new SiloError(exits.absent, "sync_remote_absent", "Remote HEAD does not exist.");
+		validateHead(this.workspace, head, state.database_id);
+		if (state.base_generation === head.manifest.generation && !discardTransactionId) return;
+		const restored = temporaryPath(this.workspace, "pull");
+		try {
+			await this.restoreAndVerify(remote, head, restored);
+			const rebased = SiloDatabase.open({
+				...this.workspace,
+				databasePath: restored
+			}, true, true);
+			let conflict;
+			try {
+				conflict = rebased.rebasePending(pending, head.manifest.generation, head.etag, discardTransactionId);
+			} finally {
+				rebased.close();
+			}
+			if (conflict) {
+				const original = SiloDatabase.open(this.workspace, true, true);
+				try {
+					original.setSyncConflict(conflict);
+				} finally {
+					original.close();
+				}
+				const operation = pending.find((item) => item.transaction_id === conflict)?.operation;
+				const context = [
+					String(operation?.command ?? "unknown operation"),
+					operation?.table ? `table ${String(operation.table)}` : "",
+					operation?.key !== void 0 ? `key ${JSON.stringify(operation.key)}` : ""
+				].filter(Boolean).join(", ");
+				throw new SiloError(exits.revision, "sync_changeset_conflict", `Transaction ${conflict} (${context}) conflicts with remote generation ${head.manifest.generation}.`);
+			}
+			installDatabase(restored, this.workspace.databasePath);
+		} finally {
+			removeDatabase(restored);
+		}
+	}
+	async push() {
+		return withSyncLock(this.workspace, async () => {
+			await this.services.checkpoint.check();
+			let database = SiloDatabase.open(this.workspace, true, true);
+			let state;
+			let pendingCount;
+			try {
+				state = database.getSyncState();
+				pendingCount = database.pendingTransactions().length;
+			} finally {
+				database.close();
+			}
+			if (!state) throw new SiloError(exits.workspace, "sync_not_configured", "Synchronization is not configured.");
+			const remote = this.services.remote(state.remote_url);
+			let head = await remote.readHead();
+			if (head) validateHead(this.workspace, head, state.database_id);
+			if (!head && state.base_generation) throw new SiloError(exits.integrity, "sync_remote_head_missing", "Remote HEAD disappeared after this database was synchronized.");
+			if (head && state.base_generation === head.manifest.generation && !pendingCount) return this.status();
+			if (head && state.base_generation !== head.manifest.generation) {
+				await this.pullUnlocked();
+				const refreshed = SiloDatabase.open(this.workspace);
+				try {
+					state = refreshed.getSyncState();
+				} finally {
+					refreshed.close();
+				}
+				head = await remote.readHead();
+				if (head) validateHead(this.workspace, head, state.database_id);
+			}
+			database = SiloDatabase.open(this.workspace, true, true);
+			const publicationId = randomUUID();
+			const generation = randomUUID();
+			const candidate = temporaryPath(this.workspace, "publish");
+			const verified = temporaryPath(this.workspace, "verify");
+			try {
+				await database.backupCanonical(candidate, generation);
+				const manifest = {
+					format_version: 1,
+					database_id: state.database_id,
+					identity: this.workspace.identity,
+					generation,
+					publication_id: publicationId,
+					parent_generation: head?.manifest.generation ?? null,
+					schema_revision: database.getSchema().revision,
+					database_sha256: hashDatabase(candidate),
+					created_at: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				database.close();
+				await this.services.checkpoint.publish(candidate, remote.generationUrl(generation));
+				await this.services.checkpoint.restore(remote.generationUrl(generation), verified);
+				if (hashDatabase(verified) !== manifest.database_sha256) throw new SiloError(exits.integrity, "sync_checkpoint_hash_mismatch", "The restored checkpoint does not match the published database.");
+				const verification = SiloDatabase.open({
+					...this.workspace,
+					databasePath: verified
+				}, false, true);
+				try {
+					if (verification.getSchema().revision !== manifest.schema_revision) throw new SiloError(exits.integrity, "sync_checkpoint_schema_mismatch", "The published checkpoint schema does not match its manifest.");
+					const integrity = verification.query("PRAGMA integrity_check");
+					if (integrity.rows.length !== 1 || integrity.rows[0]?.[0] !== "ok") throw new SiloError(exits.integrity, "integrity_check_failed", "The published checkpoint failed SQLite integrity checking.");
+				} finally {
+					verification.close();
+				}
+				let etag;
+				try {
+					etag = await remote.publishHead(manifest, head?.etag ?? null);
+				} catch (error) {
+					if (!(error instanceof SiloError) || error.code !== "sync_head_changed") throw error;
+					const current = await remote.readHead();
+					if (!current || current.manifest.publication_id !== publicationId) throw error;
+					etag = current.etag;
+				}
+				const updated = SiloDatabase.open(this.workspace, true, true);
+				try {
+					updated.markSynchronized(generation, etag);
+				} finally {
+					updated.close();
+				}
+			} finally {
+				try {
+					database.close();
+				} catch {}
+				removeDatabase(candidate);
+				removeDatabase(verified);
+			}
+			return this.status();
+		});
+	}
+	async restoreAndVerify(remote, head, outputPath) {
+		await this.services.checkpoint.restore(remote.generationUrl(head.manifest.generation), outputPath);
+		if (hashDatabase(outputPath) !== head.manifest.database_sha256) throw new SiloError(exits.integrity, "sync_checkpoint_hash_mismatch", "The restored checkpoint does not match remote HEAD.");
+		const database = SiloDatabase.open({
+			...this.workspace,
+			databasePath: outputPath
+		});
+		try {
+			const state = database.getSyncState();
+			if (!state || state.database_id !== head.manifest.database_id) throw new SiloError(exits.integrity, "sync_checkpoint_identity_mismatch", "The restored checkpoint does not match remote HEAD.");
+			if (database.getSchema().revision !== head.manifest.schema_revision) throw new SiloError(exits.integrity, "sync_checkpoint_schema_mismatch", "The restored checkpoint schema does not match remote HEAD.");
+			const integrity = database.query("PRAGMA integrity_check");
+			if (integrity.rows.length !== 1 || integrity.rows[0]?.[0] !== "ok") throw new SiloError(exits.integrity, "integrity_check_failed", "The restored checkpoint failed SQLite integrity checking.");
+		} finally {
+			database.close();
+		}
+	}
+};
+//#endregion
+//#region src/cli.ts
+const inputFile = option({
+	type: optional(File),
+	long: "file",
+	short: "f",
+	description: "Read the JSON request from this file instead of stdin."
+});
+function readInput(file) {
+	const source = file ? readFileSync(file, "utf8") : readFileSync(0, "utf8");
+	if (!source.trim()) throw new SiloError(exits.input, "empty_input", "Expected a JSON request on stdin or through --file.");
+	try {
+		return JSON.parse(source);
+	} catch (error) {
+		throw new SiloError(exits.input, "invalid_json", error instanceof Error ? error.message : String(error));
+	}
+}
+function output(value) {
+	process.stdout.write(value.endsWith("\n") ? value : `${value}\n`);
+}
+function renderSchema(schema) {
+	const summary = table(["Property", "Value"], [
+		["Format", schema.format_version],
+		["Registry", schema.registry_version],
+		["Revision", schema.revision],
+		["Templates", schema.template_imports?.map((item) => item.name).join(", ") ?? null]
+	]);
+	const tables = schema.tables.length ? table([
+		"Table",
+		"Comment",
+		"Columns"
+	], schema.tables.map((item) => [
+		item.name,
+		item.comment,
+		item.columns.length
+	])) : "_No tables._";
+	return `${summary}\n\n## Agent instructions\n\n${schema.agent_instructions?.length ? schema.agent_instructions.map((item) => `### ${item.source}\n\n${item.content}`).join("\n\n") : "_No agent instructions._"}\n\n## Tables\n\n${tables}`;
+}
+function renderTable(definition) {
+	const properties = table(["Property", "Value"], [
+		["Strict", definition.strict !== false],
+		["Without rowid", definition.without_rowid ?? false],
+		["Primary key", definition.primary_key?.join(", ") ?? null]
+	]);
+	const columns = table([
+		"Column",
+		"Semantic type",
+		"Physical type",
+		"Nullable",
+		"Default",
+		"Comment"
+	], definition.columns.map((column) => [
+		column.name,
+		column.type,
+		column.type.split("/")[0].toUpperCase(),
+		column.nullable !== false,
+		column.default ? JSON.stringify(column.default) : null,
+		column.comment
+	]));
+	const policies = definition.policies?.length ? table([
+		"Policy",
+		"Enforcement",
+		"Parameters"
+	], definition.policies.map((item) => [
+		item.type,
+		[
+			"immutable_rows",
+			"immutable_columns",
+			"append_only",
+			"timestamps"
+		].includes(item.type) ? "trigger + cli" : "cli",
+		JSON.stringify(Object.fromEntries(Object.entries(item).filter(([key]) => key !== "type")))
+	])) : "_No policies._";
+	const foreignKeys = definition.foreign_keys?.length ? table([
+		"Columns",
+		"References",
+		"On update",
+		"On delete"
+	], definition.foreign_keys.map((item) => [
+		item.columns.join(", "),
+		`${item.references.table}(${item.references.columns.join(", ")})`,
+		item.on_update ?? "NO ACTION",
+		item.on_delete ?? "NO ACTION"
+	])) : "_No foreign keys._";
+	const indexes = definition.indexes?.length ? table([
+		"Name",
+		"Unique",
+		"Parts",
+		"Where"
+	], definition.indexes.map((item) => [
+		item.name ?? null,
+		item.unique ?? false,
+		item.columns.map((part) => part.column ?? part.expression).join(", "),
+		item.where ?? null
+	])) : "_No explicit indexes._";
+	const checks = definition.checks?.length ? table([
+		"Name",
+		"Expression",
+		"Comment"
+	], definition.checks.map((item) => [
+		item.name ?? null,
+		item.expression,
+		item.comment ?? null
+	])) : "_No table checks._";
+	return `${definition.comment}\n\n${properties}\n\n## Columns\n\n${columns}\n\n## Foreign Keys\n\n${foreignKeys}\n\n## Indexes\n\n${indexes}\n\n## Checks\n\n${checks}\n\n## Policies\n\n${policies}`;
+}
+function withErrors(handler) {
+	return async (args) => {
+		try {
+			await handler(args);
+		} catch (error) {
+			const silo = error instanceof SiloError ? error : new SiloError(exits.io, "unexpected_error", error instanceof Error ? error.message : String(error));
+			process.stderr.write(heading("Error", errorMarkdown(silo)));
+			process.exitCode = silo.exitCode;
+		}
+	};
+}
+async function useDatabase(database, handler) {
+	try {
+		return await handler(database);
+	} finally {
+		database.close();
+	}
+}
+const status = command({
+	name: "status",
+	description: "Resolve the Git workspace and report its Silo database state.",
+	args: {},
+	handler: withErrors(async () => {
+		const workspace = resolveWorkspace();
+		let state = "absent";
+		let revision = null;
+		try {
+			await useDatabase(SiloDatabase.open(workspace), (database) => {
+				state = "recognized";
+				revision = database.getSchema().revision;
+			});
+		} catch (error) {
+			if (!(error instanceof SiloError) || error.exitCode !== exits.absent) throw error;
+		}
+		output(heading("Silo Status", table(["Property", "Value"], [
+			["Workspace", workspace.root],
+			["Identity", workspace.identity],
+			["Database", workspace.databasePath],
+			["State", state],
+			["Schema revision", revision],
+			["SQLite", sqliteVersion()]
+		])));
+	})
+});
+const databaseList = command({
+	name: "list",
+	description: "Discover Silo databases in the application-data catalog.",
+	args: {},
+	handler: withErrors(async () => {
+		const entries = discoverDatabases();
+		output(heading("Databases", entries.length ? table([
+			"Identity",
+			"State",
+			"Path",
+			"Message"
+		], entries.map((entry) => [
+			entry.identity ?? null,
+			entry.state,
+			entry.path,
+			entry.message ?? null
+		])) : "_No databases._"));
+	})
+});
+const templateList = command({
+	name: "list",
+	description: "List globally installed JSON schema templates.",
+	args: {},
+	handler: withErrors(async () => {
+		const names = listTemplates();
+		output(heading("Templates", names.length ? names.map((name) => `- \`${name}\``).join("\n") : "_No templates._"));
+	})
+});
+const templateShow = command({
+	name: "show",
+	description: "Validate and show a schema template.",
+	args: { name: positional({
+		type: string,
+		displayName: "name",
+		description: "Template filename without .json."
+	}) },
+	handler: withErrors(async ({ name }) => output(heading(`Template: ${name}`, `\`\`\`json\n${JSON.stringify(readTemplate(name), null, 2)}\n\`\`\``)))
+});
+const schemaShow = command({
+	name: "show",
+	description: "Show the authoritative logical schema.",
+	args: {},
+	handler: withErrors(async () => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const meta = database.getMetadata();
+			output(heading("Schema", `${table(["Property", "Value"], [
+				["Identity", meta.identity],
+				["Database", database.workspace.databasePath],
+				["Metadata format", meta.format_version],
+				["Tool version", meta.tool_version]
+			])}\n\n${renderSchema(database.getSchema())}`));
+		});
+	})
+});
+const schemaExport = command({
+	name: "export",
+	description: "Export the canonical logical schema as fenced JSON.",
+	args: {},
+	handler: withErrors(async () => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => output(heading("Schema Export", `\`\`\`json\n${JSON.stringify(database.getSchema(), null, 2)}\n\`\`\``)));
+	})
+});
+const schemaDdl = command({
+	name: "ddl",
+	description: "Show diagnostic compiled SQLite DDL. Logical metadata remains authoritative.",
+	args: {},
+	handler: withErrors(async () => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => output(heading("Compiled SQLite DDL", `\`\`\`sql\n${database.ddl()}\n\`\`\``)));
+	})
+});
+const schemaImport = command({
+	name: "import",
+	description: "Import a validated template into this workspace schema.",
+	examples: [{
+		description: "Import the tasks template",
+		command: "silo schema import tasks"
+	}],
+	args: { template: positional({
+		type: string,
+		displayName: "template"
+	}) },
+	handler: withErrors(async ({ template }) => {
+		const source = readTemplate(template);
+		const workspace = resolveWorkspace();
+		let database;
+		let schema;
+		try {
+			try {
+				database = SiloDatabase.open(workspace, true);
+				schema = database.importTemplate(template, source);
+			} catch (error) {
+				if (!(error instanceof SiloError) || error.code !== "database_absent") throw error;
+				schema = schemaFromTemplate(template, source);
+				database = SiloDatabase.createWithSchema(workspace, schema);
+			}
+			output(heading("Schema Template Imported", table([
+				"Template",
+				"Tables",
+				"Revision"
+			], [[
+				template,
+				schema.tables.length,
+				schema.revision
+			]])));
+		} finally {
+			database?.close();
+		}
+	})
+});
+const tableList = command({
+	name: "list",
+	description: "List tables from authoritative logical metadata.",
+	args: {},
+	handler: withErrors(async () => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const tables = database.getSchema().tables;
+			output(heading("Tables", tables.length ? table(["Table", "Comment"], tables.map((item) => [item.name, item.comment])) : "_No tables._"));
+		});
+	})
+});
+const tableShow = command({
+	name: "show",
+	description: "Show a table's semantic types and policy enforcement.",
+	args: { table: positional({
+		type: string,
+		displayName: "table"
+	}) },
+	handler: withErrors(async ({ table }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => output(heading(`Table: ${table}`, renderTable(database.table(table)))));
+	})
+});
+const tableCreate = command({
+	name: "create",
+	description: "Create a STRICT table from JSON, creating the workspace database on first use.",
+	examples: [{
+		description: "Read a request from stdin",
+		command: "silo table create < table.json"
+	}],
+	args: { file: inputFile },
+	handler: withErrors(async ({ file }) => {
+		const workspace = resolveWorkspace();
+		const input = readInput(file);
+		let database;
+		let definition;
+		try {
+			try {
+				database = SiloDatabase.open(workspace, true);
+			} catch (error) {
+				if (!(error instanceof SiloError) || error.exitCode !== exits.absent) throw error;
+				definition = parseTable(input);
+				database = SiloDatabase.createWithSchema(workspace, {
+					...emptySchema(),
+					tables: [definition]
+				});
+			}
+			definition ??= database.createTable(input);
+			output(heading("Table Created", table(["Table", "Columns"], [[definition.name, definition.columns.length]])));
+		} finally {
+			database?.close();
+		}
+	})
+});
+const tableAlter = command({
+	name: "alter",
+	description: "Add nullable/defaulted columns or indexes from JSON.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		file: inputFile
+	},
+	handler: withErrors(async ({ table: table$1, file }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			const result = database.alterTable(table$1, readInput(file));
+			output(heading("Table Altered", table([
+				"Table",
+				"Columns",
+				"Indexes"
+			], [[
+				result.name,
+				result.columns.length,
+				result.indexes?.length ?? 0
+			]])));
+		});
+	})
+});
+const tableDrop = command({
+	name: "drop",
+	description: "Permanently drop a table; the explicit command is destructive intent.",
+	args: { table: positional({
+		type: string,
+		displayName: "table"
+	}) },
+	handler: withErrors(async ({ table }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			database.dropTable(table);
+			output(heading("Table Dropped", `\`${table}\` was dropped.`));
+		});
+	})
+});
+const rowAdd = command({
+	name: "add",
+	description: "Atomically insert one JSON object or an array of objects.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		file: inputFile
+	},
+	handler: withErrors(async ({ table: table$2, file }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			const rows = database.addRows(table$2, readInput(file));
+			output(heading("Rows Added", table(Object.keys(rows[0]), rows.map(Object.values))));
+		});
+	})
+});
+const rowUpsert = command({
+	name: "upsert",
+	description: "Insert or update through the declared natural-key policy.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		file: inputFile
+	},
+	handler: withErrors(async ({ table: table$3, file }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			const rows = database.addRows(table$3, readInput(file), true);
+			output(heading("Rows Upserted", table(Object.keys(rows[0]), rows.map(Object.values))));
+		});
+	})
+});
+const rowGet = command({
+	name: "get",
+	description: "Get a row by a schema-decoded key; composite keys use a JSON array.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		key: positional({
+			type: string,
+			displayName: "key"
+		})
+	},
+	handler: withErrors(async ({ table: table$4, key: value }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const row = database.getRow(table$4, value);
+			output(heading("Row", table(Object.keys(row), [Object.values(row)])));
+		});
+	})
+});
+const rowList = command({
+	name: "list",
+	description: "List rows deterministically by primary key or rowid.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		limit: option({
+			type: number,
+			long: "limit",
+			defaultValue: () => 100,
+			description: "Maximum rows."
+		}),
+		offset: option({
+			type: number,
+			long: "offset",
+			defaultValue: () => 0,
+			description: "Rows to skip."
+		})
+	},
+	handler: withErrors(async ({ table: table$5, limit, offset }) => {
+		if (!Number.isSafeInteger(limit) || limit < 0 || !Number.isSafeInteger(offset) || offset < 0) throw new SiloError(exits.input, "invalid_pagination", "limit and offset must be nonnegative integers.");
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const rows = database.listRows(table$5, limit, offset);
+			output(heading("Rows", rows.length ? table(Object.keys(rows[0]), rows.map(Object.values)) : "_No rows._"));
+		});
+	})
+});
+const rowUpdate = command({
+	name: "update",
+	description: "Update by key; revisioned tables require _expected_revision.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		key: positional({
+			type: string,
+			displayName: "key"
+		}),
+		file: inputFile
+	},
+	handler: withErrors(async ({ table: table$6, key: value, file }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			output(heading("Row Updated", table(["Changes"], [[database.updateRow(table$6, value, readInput(file))]])));
+		});
+	})
+});
+const rowDelete = command({
+	name: "delete",
+	description: "Permanently delete a row by key.",
+	args: {
+		table: positional({
+			type: string,
+			displayName: "table"
+		}),
+		key: positional({
+			type: string,
+			displayName: "key"
+		})
+	},
+	handler: withErrors(async ({ table: table$7, key: value }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			output(heading("Row Deleted", table(["Changes"], [[database.deleteRow(table$7, value)]])));
+		});
+	})
+});
+const reportPut = command({
+	name: "put",
+	description: "Create or atomically replace and refresh a Markdown report from JSON.",
+	examples: [{
+		description: "Read a report definition",
+		command: "silo report put < report.json"
+	}],
+	args: { file: inputFile },
+	handler: withErrors(async ({ file }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			const report = database.putReport(readInput(file));
+			output(heading("Report Saved", table([
+				"Slug",
+				"Title",
+				"Queries",
+				"Refreshed"
+			], [[
+				report.slug,
+				report.title,
+				report.queries.length,
+				report.refreshed_at
+			]])));
+		});
+	})
+});
+const reportList = command({
+	name: "list",
+	description: "List saved Markdown reports and their refresh state.",
+	args: {},
+	handler: withErrors(async () => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const reports = database.listReports();
+			output(heading("Reports", reports.length ? table([
+				"Slug",
+				"Title",
+				"Refreshed",
+				"Last refresh error"
+			], reports.map((report) => [
+				report.slug,
+				report.title,
+				report.refreshed_at,
+				report.last_refresh_error
+			])) : "_No reports._"));
+		});
+	})
+});
+const reportShow = command({
+	name: "show",
+	description: "Show the last successful rendering and saved query definitions.",
+	args: { slug: positional({
+		type: string,
+		displayName: "slug"
+	}) },
+	handler: withErrors(async ({ slug }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const report = database.getReport(slug);
+			const queries = report.queries.map((query) => `### ${query.name}\n\n\`\`\`sql\n${query.sql}\n\`\`\``).join("\n\n");
+			output(heading(`Report: ${report.title}`, `${table(["Property", "Value"], [
+				["Slug", report.slug],
+				["Updated", report.updated_at],
+				["Refreshed", report.refreshed_at],
+				["Last refresh error", report.last_refresh_error]
+			])}\n\n## Rendered report\n\n${report.rendered_markdown}\n\n## Saved queries\n\n${queries}`));
+		});
+	})
+});
+const reportRefresh = command({
+	name: "refresh",
+	description: "Rerun saved queries and atomically replace a report rendering.",
+	args: { slug: positional({
+		type: string,
+		displayName: "slug"
+	}) },
+	handler: withErrors(async ({ slug }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			const report = database.refreshReport(slug);
+			output(heading(`Report Refreshed: ${report.title}`, report.rendered_markdown));
+		});
+	})
+});
+const reportDelete = command({
+	name: "delete",
+	description: "Permanently delete a report and its saved queries.",
+	args: { slug: positional({
+		type: string,
+		displayName: "slug"
+	}) },
+	handler: withErrors(async ({ slug }) => {
+		await useDatabase(SiloDatabase.open(resolveWorkspace(), true), (database) => {
+			database.deleteReport(slug);
+			output(heading("Report Deleted", `\`${slug}\` was deleted.`));
+		});
+	})
+});
+const reportOpen = command({
+	name: "open",
+	description: "Open a report in the local viewer and serve refresh requests until interrupted.",
+	args: { slug: positional({
+		type: string,
+		displayName: "slug"
+	}) },
+	handler: withErrors(async ({ slug }) => {
+		output(heading("Report Viewer", `${(await startReportViewer(resolveWorkspace(), slug)).url}\n\nThe loopback server remains active until this command is interrupted.`));
+	})
+});
+const sql = command({
+	name: "sql",
+	description: "Run one query through a read-only SQLite connection; omit it to read stdin.",
+	examples: [{
+		description: "Query a table",
+		command: "silo sql 'SELECT * FROM issues'"
+	}],
+	args: { query: positional({
+		type: optional(string),
+		displayName: "query"
+	}) },
+	handler: withErrors(async ({ query }) => {
+		const source = query ?? readFileSync(0, "utf8");
+		if (!source.trim()) throw new SiloError(exits.input, "empty_query", "Expected a SQL query argument or stdin.");
+		await useDatabase(SiloDatabase.open(resolveWorkspace()), (database) => {
+			const result = database.query(source);
+			output(heading("Query Result", result.rows.length ? table(result.columns, result.rows) : result.columns.length ? table(result.columns, []) : "_Query returned no result columns._"));
+		});
+	})
+});
+function renderSyncStatus(status) {
+	return heading("Synchronization", table(["Property", "Value"], [
+		["State", status.state],
+		["Remote", status.remote_url],
+		["Database ID", status.database_id],
+		["Local generation", status.local_generation],
+		["Remote generation", status.remote_generation],
+		["Pending transactions", status.pending_transactions],
+		["Conflict transaction", status.conflict_transaction_id]
+	]));
+}
+const syncInit = command({
+	name: "init",
+	description: "Connect this workspace to an S3-compatible synchronization remote.",
+	args: { remote: positional({
+		type: string,
+		displayName: "s3-url"
+	}) },
+	handler: withErrors(async ({ remote }) => {
+		output(renderSyncStatus(await new SiloSync(resolveWorkspace()).initialize(remote)));
+	})
+});
+const syncStatus = command({
+	name: "status",
+	description: "Compare local synchronization state with remote HEAD.",
+	args: {},
+	handler: withErrors(async () => {
+		output(renderSyncStatus(await new SiloSync(resolveWorkspace()).status()));
+	})
+});
+const syncDiscard = command({
+	name: "discard",
+	description: "Discard one pending transaction by rebuilding from remote state.",
+	args: { transaction: positional({
+		type: string,
+		displayName: "transaction-id"
+	}) },
+	handler: withErrors(async ({ transaction }) => {
+		output(renderSyncStatus(await new SiloSync(resolveWorkspace()).pull(transaction)));
+	})
+});
+const pull = command({
+	name: "pull",
+	description: "Restore remote HEAD and reapply pending local changesets.",
+	args: {},
+	handler: withErrors(async () => {
+		output(renderSyncStatus(await new SiloSync(resolveWorkspace()).pull()));
+	})
+});
+//#endregion
+//#region src/bin.ts
+const result = await runSafely(binary(subcommands({
+	name: "silo",
+	version: "0.1.0",
+	cmds: {
+		status,
+		push: command({
+			name: "push",
+			description: "Publish a merged immutable checkpoint and conditionally advance remote HEAD.",
+			args: {},
+			handler: withErrors(async () => {
+				output(renderSyncStatus(await new SiloSync(resolveWorkspace()).push()));
+			})
+		}),
+		pull,
+		sync: subcommands({
+			name: "sync",
+			cmds: {
+				init: syncInit,
+				status: syncStatus,
+				discard: syncDiscard
+			}
+		}),
+		database: subcommands({
+			name: "database",
+			cmds: { list: databaseList }
+		}),
+		template: subcommands({
+			name: "template",
+			cmds: {
+				list: templateList,
+				show: templateShow
+			}
+		}),
+		schema: subcommands({
+			name: "schema",
+			cmds: {
+				show: schemaShow,
+				export: schemaExport,
+				ddl: schemaDdl,
+				import: schemaImport
+			}
+		}),
+		table: subcommands({
+			name: "table",
+			cmds: {
+				list: tableList,
+				show: tableShow,
+				create: tableCreate,
+				alter: tableAlter,
+				drop: tableDrop
+			}
+		}),
+		row: subcommands({
+			name: "row",
+			cmds: {
+				add: rowAdd,
+				get: rowGet,
+				list: rowList,
+				update: rowUpdate,
+				delete: rowDelete,
+				upsert: rowUpsert
+			}
+		}),
+		report: subcommands({
+			name: "report",
+			cmds: {
+				put: reportPut,
+				list: reportList,
+				show: reportShow,
+				refresh: reportRefresh,
+				delete: reportDelete,
+				open: reportOpen
+			}
+		}),
+		sql
+	}
+})), process.argv);
+if (result._tag === "error") {
+	const { message, into, exitCode } = result.error.config;
+	(into === "stdout" ? process.stdout : process.stderr).write(message.endsWith("\n") ? message : `${message}\n`);
+	process.exitCode = exitCode === 1 ? 2 : exitCode;
+}
+//#endregion
+export {};