@hollware/server 0.0.2 → 0.2.0

package/dist/index.mjs

@@ -1,4 +1,3847 @@
+import { EVENT_ID_HEADER, HollwareError, OPERATIONS, SIGNATURE_HEADER, TIMESTAMP_HEADER, describeBuiltInContracts, describeResolvedSite, describeSite, getEntry, getTranslations, hashPersonalToken, isPersonalToken, isScope, listEntries, newId, processMarkdown, publish, renderHtml, resolveConfig, runContracts, signWebhook, sizeLimitViolation, uniqueSlugViolation, uniqueTranslationViolation } from "@hollware/core";
+import { Hono } from "hono";
+import { drizzle } from "drizzle-orm/d1";
+import { and, desc, eq, getTableColumns, inArray, isNull, lte, ne, or, sql } from "drizzle-orm";
+import { alias, check, foreignKey, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, McpServer, acceptedContent, createMcpHandler, inputRequired, inputResponse } from "@modelcontextprotocol/server";
+import * as z from "zod";
+import { WorkerEntrypoint } from "cloudflare:workers";
+//#region package.json
+var version = "0.2.0";
+//#endregion
+//#region src/auth/bearer.ts
+/**
+* `Bearer`, one or more spaces, then one token with no whitespace in it, and nothing else. The
+* scheme is case-insensitive (RFC 7235); the runtime has already trimmed the whole value.
+*/
+const BEARER = /^bearer +(\S+)$/i;
+/**
+* The token of an `Authorization: Bearer <token>` header, as sent, or `null` when the request
+* presents none: no header, another scheme, no token, or more than one (two headers arrive joined
+* with a comma, so they read as two tokens). It never looks at the URL: a token in a query string
+* ends up in logs, referrers and history, so Hollware does not accept one.
+*
+* It does not judge the token. A string that is not a personal token is a token that was
+* presented and refused, which `checkPersonalToken` says and `unauthorized` answers differently
+* from a request without credentials.
+*/
+function readBearerToken(request) {
+	const header = request.headers.get("authorization");
+	if (header === null) return null;
+	return BEARER.exec(header)?.[1] ?? null;
+}
+//#endregion
+//#region src/auth/responses.ts
+/** The challenge of every 401 and 403 (RFC 6750). */
+const REALM = "Bearer realm=\"hollware\"";
+/**
+* A JSON error response that no cache keeps. `challenge` is the `WWW-Authenticate` value of a
+* 401 or a 403 that answers a bearer token.
+*/
+function authErrorResponse(status, body, challenge) {
+	const headers = new Headers({ "cache-control": "no-store" });
+	if (challenge !== void 0) headers.set("www-authenticate", challenge);
+	return Response.json(body, {
+		status,
+		headers
+	});
+}
+/**
+* 401. Without a `reason` the request presented no token, and the challenge only names the realm
+* (RFC 6750: a request without credentials gets no error code). With one, a token was presented
+* and refused, and the challenge says `invalid_token`. The answer is the same for every reason:
+* a caller that sends tokens at random never learns which of them exist, or ever did. The reason
+* is for the log; the fix says how to get a token that works.
+*/
+function unauthorized(reason) {
+	if (reason === void 0) return authErrorResponse(401, {
+		code: "unauthorized",
+		message: "The request carries no personal token.",
+		fix: "Send a personal token as \"Authorization: Bearer <token>\". Create one with `hollware token create`."
+	}, REALM);
+	return authErrorResponse(401, {
+		code: "unauthorized",
+		message: "The personal token was not accepted.",
+		fix: "Tokens expire and can be revoked. Create a new one with `hollware token create` and send it as \"Authorization: Bearer <token>\"."
+	}, `${REALM}, error="invalid_token"`);
+}
+/**
+* 403 for a token that authenticated but lacks scopes. It names every scope that is missing, in
+* the body and in the challenge (RFC 6750), so that a client asks for all of them at once.
+*/
+function insufficientScope(missing) {
+	return authErrorResponse(403, {
+		code: "insufficient_scope",
+		message: `The token lacks a scope this operation requires. Missing: ${missing.join(", ")}.`,
+		fix: "Send a token that carries every missing scope. Create one with `hollware token create`; a token only gets the scopes its user's role allows."
+	}, `${REALM}, error="insufficient_scope", scope="${missing.join(" ")}"`);
+}
+//#endregion
+//#region src/auth/guard.ts
+/**
+* What the Host and Origin of a request are compared with: the host and the origin that `new URL`
+* makes of the variable (lowercase, no default port). Path, query and fragment play no part.
+* `null` when the variable is not an absolute `http` or `https` URL, or is not a string at all.
+*/
+function readPublicUrl(value) {
+	if (typeof value !== "string") return null;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+	return {
+		host: url.host,
+		hostWithDefaultPort: url.port === "" ? `${url.host}:${url.protocol === "https:" ? 443 : 80}` : null,
+		origin: url.origin
+	};
+}
+/**
+* The guard that runs in front of every route, against DNS rebinding and cross-site requests
+* from a browser (ADR-019). It fails closed: every request it does not recognize is refused.
+*
+* - `HOLLWARE_PUBLIC_URL` missing or not an `http` or `https` URL: 500. Without it nothing can
+*   be compared, and skipping the check would leave the Worker open.
+* - A `Host` header that is missing, or is not the host of the public URL, port included: 403.
+*   The comparison ignores case, and takes the default port of the scheme written out
+*   (`cms.example.com:443` for an `https` URL), which some clients send for the same server.
+*   Any other port is another host.
+* - An `Origin` header that is present and is not the origin of the public URL, scheme and port
+*   included: 403. That covers the opaque `null` origin and an empty value. A request without
+*   `Origin` passes: only browsers send it, and they are what the check is for.
+*
+* It returns the response to send, or `null` when the request may go on. No answer repeats the
+* request: the 403s say what to send instead, and the 500 only says what is missing.
+*
+* The helpers of the MCP SDK (`hostHeaderValidationResponse`, `originValidationResponse`) do not
+* fit: they compare hostnames only, so they accept any port and, for `Origin`, any scheme, and
+* they accept a `Host` such as `user@cms.example.com` or `cms.example.com/x`.
+*
+* @param publicUrl The `HOLLWARE_PUBLIC_URL` variable as the environment holds it.
+*/
+function checkHostAndOrigin(request, publicUrl) {
+	const expected = readPublicUrl(publicUrl);
+	if (expected === null) return authErrorResponse(500, {
+		code: "misconfigured",
+		message: "HOLLWARE_PUBLIC_URL is required: it is missing, or it is not an http or https URL.",
+		fix: "Set the HOLLWARE_PUBLIC_URL variable of the Worker to its public URL, such as https://cms.example.com, and deploy again."
+	});
+	const host = request.headers.get("host")?.toLowerCase() ?? null;
+	if (host === null || host !== expected.host && host !== expected.hostWithDefaultPort) return authErrorResponse(403, {
+		code: "forbidden_host",
+		message: "The Host header of the request is not the public URL of this Hollware.",
+		fix: `Send the request to ${expected.origin}, the public URL of this Hollware (HOLLWARE_PUBLIC_URL).`
+	});
+	const origin = request.headers.get("origin");
+	if (origin !== null && origin.toLowerCase() !== expected.origin) return authErrorResponse(403, {
+		code: "forbidden_origin",
+		message: "The Origin header of the request is not the public URL of this Hollware.",
+		fix: `Call Hollware from a client that sends no Origin header, or from a page served at ${expected.origin}.`
+	});
+	return null;
+}
+//#endregion
+//#region src/auth/roles.ts
+/**
+* The roles of a user, as the `users_role` CHECK of the schema lists them. In v0.1 only the owner
+* exists: `hollware init` creates it. The other two are in the CHECK already, so that v0.3 can
+* invite people without a rebuild of the table (ADR-023).
+*/
+const ROLES = [
+	"owner",
+	"editor",
+	"reviewer"
+];
+/** Whether a string is one of the roles. */
+function isRole(value) {
+	return ROLES.some((role) => role === value);
+}
+/**
+* The scopes each role allows. What a token may do is its own scopes intersected with these,
+* read from the user's current role on every request (ADR-005, ADR-019). An operation asks for
+* scopes, never for a role.
+*
+* - `owner` may do everything: all four scopes.
+* - `editor` and `reviewer` allow none in v0.1. Nothing creates such a user yet, and which scopes
+*   each one gets (an editor writes, a reviewer approves) is for v0.3 to decide, together with
+*   the admin that invites them. Until then a token of such a user authenticates, but every
+*   operation answers 403 `insufficient_scope`.
+*/
+const ROLE_SCOPES = {
+	owner: [
+		"content:read",
+		"content:write",
+		"content:publish",
+		"schema:admin"
+	],
+	editor: [],
+	reviewer: []
+};
+/**
+* The scopes a token really has: those it carries that the role of its user allows, in the order
+* of the role. A role that is not one of the roles allows nothing, so a role added to the schema
+* before this table knows it grants no access.
+*/
+function effectiveScopes(role, tokenScopes) {
+	if (!isRole(role)) return [];
+	return ROLE_SCOPES[role].filter((scope) => tokenScopes.includes(scope));
+}
+//#endregion
+//#region src/auth/token.ts
+/** `last_used_at` of a token is written at most once in this time. */
+const TOUCH_INTERVAL_MS = 36e5;
+/** The token with the role of its user, by the hash of the token, in the one site. */
+const LOOKUP = `SELECT t.id AS token_id, t.site_id AS site_id, t.user_id AS user_id,
+    t.scopes AS scopes, t.expires_at AS expires_at, t.revoked_at AS revoked_at,
+    t.last_used_at AS last_used_at, u.role AS role
+  FROM tokens AS t JOIN users AS u ON u.id = t.user_id
+  WHERE t.hash = ?1 AND t.site_id = ?2`;
+/**
+* The scopes a token carries, from the JSON array the `tokens` table stores. Anything that is not
+* one of the scopes is left out, and a value that is not an array of scopes has none: a token
+* never gets more than what the catalog names.
+*/
+function parseTokenScopes(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed)) return [];
+	return parsed.filter((value) => typeof value === "string" && isScope(value));
+}
+/**
+* Whether an expiry has passed. A token is expired at the very instant of its expiry, and one
+* whose expiry cannot be read is expired too: the check fails closed. The expiry is read as an
+* instant, so any ISO 8601 spelling of it works, with or without milliseconds.
+*/
+function hasExpired(expiresAt, now) {
+	if (expiresAt === null) return false;
+	const instant = Date.parse(expiresAt);
+	return Number.isNaN(instant) || instant <= now.getTime();
+}
+/** The instant an hour before `now`, spelled as `last_used_at` is: ISO 8601 UTC with milliseconds. */
+function anHourBefore(now) {
+	return (/* @__PURE__ */ new Date(now.getTime() - TOUCH_INTERVAL_MS)).toISOString();
+}
+/**
+* Writes `last_used_at` (and `updated_at`) of a token to `now`, unless it was written within the
+* hour before: the condition is in the `UPDATE`, so two requests that both read an old value
+* still write once. A failure is logged and swallowed: a statistic never fails the request, and
+* the returned promise never rejects, so nobody has to handle it.
+*/
+async function recordTokenUse(db, token, now) {
+	try {
+		await db.prepare(`UPDATE tokens SET last_used_at = ?1, updated_at = ?1
+          WHERE id = ?2 AND site_id = ?3 AND (last_used_at IS NULL OR last_used_at < ?4)`).bind(now.toISOString(), token.id, token.site, anHourBefore(now)).run();
+	} catch (error) {
+		console.error("hollware: could not record the last use of a token", error);
+	}
+}
+/**
+* Authenticates a personal token (ADR-019). A string without the shape of a token is `unknown`
+* without a query. Otherwise one query finds the token by the hash of the whole string, in this
+* site only, together with the role of its user; the answer is, in this order:
+*
+* - `unknown`: no such token in this site. A token of another site is the same as no token, and
+*   nothing says it exists elsewhere.
+* - `revoked`: it has a revocation date, whatever the date says: it is never read, so a clock that
+*   runs ahead of the Worker's, where the token was revoked, cannot keep it alive for a while.
+* - `expired`: its expiry is now or past (see `hasExpired`).
+* - `ok`: the principal, whose scopes are the token's own intersected with those of the role its
+*   user has now. A token whose user has no scopes (an editor, in v0.1) still authenticates, and
+*   every operation then answers `insufficient_scope`.
+*
+* Pass the `D1Database` binding itself and not a replica session: a token that was revoked must
+* stop working on the next request, and only the primary knows. A D1 failure rejects, and a caller
+* must never read that as a valid token.
+*/
+async function checkPersonalToken(db, token, options) {
+	if (!isPersonalToken(token)) return {
+		ok: false,
+		reason: "unknown"
+	};
+	const row = await db.prepare(LOOKUP).bind(await hashPersonalToken(token), options.site).first();
+	if (row === null) return {
+		ok: false,
+		reason: "unknown"
+	};
+	if (row.revoked_at !== null) return {
+		ok: false,
+		reason: "revoked"
+	};
+	if (hasExpired(row.expires_at, options.now)) return {
+		ok: false,
+		reason: "expired"
+	};
+	const recent = row.last_used_at !== null && row.last_used_at >= anHourBefore(options.now);
+	return {
+		ok: true,
+		principal: {
+			kind: "token",
+			userId: row.user_id,
+			tokenId: row.token_id,
+			site: row.site_id,
+			scopes: effectiveScopes(row.role, parseTokenScopes(row.scopes))
+		},
+		touch: recent ? null : recordTokenUse(db, {
+			id: row.token_id,
+			site: row.site_id
+		}, options.now)
+	};
+}
+//#endregion
+//#region src/db/d1.ts
+/**
+* Drizzle's D1 driver is typed over a `D1Database`, but at runtime it only calls `prepare` and
+* `batch` (drizzle-orm d1/session.js), so it also runs on a session. This is a `D1Database` over
+* a `D1Like` without a cast: the three methods drizzle never calls throw, so a driver that starts
+* calling one fails loudly instead of reaching the wrong database (spike S4).
+*/
+function asD1Database(db) {
+	const unavailable = (method) => {
+		throw new Error(`The store runs on prepare() and batch() only, so D1 ${method}() is not there`);
+	};
+	return {
+		prepare: (query) => db.prepare(query),
+		batch: (statements) => db.batch(statements),
+		exec: () => unavailable("exec"),
+		withSession: () => unavailable("withSession"),
+		dump: () => unavailable("dump")
+	};
+}
+/** Drizzle over `db`, with no schema (the store builds its queries from the table objects). */
+function connect(db) {
+	return drizzle(asD1Database(db));
+}
+//#endregion
+//#region src/limits.ts
+/**
+* The limits every operation runs under, pinned for the adapters and the store (the v0.1 plan).
+*/
+/**
+* The largest answer of an operation, in UTF-8 bytes of its JSON. A larger one is the error
+* `output_too_large`, with a fix that says how to ask for less; content is never truncated.
+*/
+const OUTPUT_CAP_BYTES = 1048576;
+/** How long an operation may take before it answers the error `timeout`. */
+const OPERATION_TIMEOUT_MS = 1e4;
+/**
+* The largest row the store writes, counted in UTF-8 bytes across all its columns. D1 refuses
+* rows over 2 MB in production, and Miniflare does not enforce it, so the store checks first.
+*/
+const MAX_ROW_BYTES = 19e5;
+/** The most values bound in one statement: D1 allows 100, and lookups go in chunks of this. */
+const MAX_BOUND_PARAMETERS = 90;
+//#endregion
+//#region src/db/chunks.ts
+/**
+* D1 refuses a statement with more than 100 bound values, and Miniflare enforces it too. Lookups
+* and multi-row inserts go in chunks that stay under `MAX_BOUND_PARAMETERS`.
+*/
+/**
+* How many rows of `perRow` bound values one statement can take when it also binds `shared`
+* values of its own. At least one: a row that does not fit alone is a bug of the statement.
+*/
+function rowsPerStatement(shared, perRow) {
+	return Math.max(1, Math.floor((90 - shared) / perRow));
+}
+/** `items` in groups of at most `size`, in order. */
+function chunk(items, size) {
+	const groups = [];
+	for (let start = 0; start < items.length; start += size) groups.push(items.slice(start, start + size));
+	return groups;
+}
+//#endregion
+//#region src/db/cursor.ts
+function invalidCursor() {
+	return new HollwareError("invalid_input", "The cursor is not valid for this listing.", "Pass the nextCursor of the previous answer unchanged, to the same operation, or leave cursor out to start from the first page.");
+}
+function encodeBase64Url(text) {
+	let binary = "";
+	for (const byte of new TextEncoder().encode(text)) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+/** The text a base64url string holds, or `null` when it is not base64url of UTF-8. */
+function decodeBase64Url(text) {
+	if (!/^[A-Za-z0-9_-]*$/.test(text)) return null;
+	try {
+		const binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
+		const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+		return new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		}).decode(bytes);
+	} catch {
+		return null;
+	}
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/** The cursor that continues a `view` listing after `position`. */
+function encodeCursor(view, position) {
+	return encodeBase64Url(JSON.stringify({
+		v: view,
+		k: position.key,
+		i: position.id
+	}));
+}
+/**
+* The position a cursor stands for. A cursor that no listing of this view returned, whatever is
+* wrong with it, is the error `invalid_input` with a fix.
+*/
+function decodeCursor(cursor, view) {
+	const text = decodeBase64Url(cursor);
+	const value = text === null ? void 0 : parseJson(text);
+	if (typeof value === "object" && value !== null && "v" in value && "k" in value && "i" in value && value.v === view && typeof value.k === "string" && typeof value.i === "string") return {
+		key: value.k,
+		id: value.i
+	};
+	throw invalidCursor();
+}
+//#endregion
+//#region src/db/columns.ts
+/**
+* The columns every table shares. Each helper returns a new builder, because a Drizzle column
+* belongs to one table. Only the repository functions write rows, so these defaults are what
+* every row gets.
+*/
+/** The current time in UTC, as ISO 8601 with milliseconds: `2026-10-12T18:30:00.000Z`. */
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/** The primary key: a prefixed ULID, such as `ent_01JAB3XQ8ZK4M6N2P5R7S9T0VW`. */
+function id(prefix) {
+	return text("id").primaryKey().$defaultFn(() => newId(prefix));
+}
+/**
+* The site a row belongs to: the site's key in `hollware.config.ts`, which is also the id of its
+* row in `sites`. Every table but the deployment-wide ones carries it (ADR-006).
+*/
+function siteId() {
+	return text("site_id").notNull();
+}
+/** `created_at` and `updated_at`, in UTC; `updated_at` moves on every update. */
+function timestamps() {
+	return {
+		createdAt: text("created_at").notNull().$defaultFn(nowIso),
+		updatedAt: text("updated_at").notNull().$defaultFn(nowIso).$onUpdateFn(nowIso)
+	};
+}
+sqliteTable("_hollware_meta", {
+	key: text("key").primaryKey().notNull(),
+	value: text("value").notNull()
+});
+/** The sites of the deployment. The id is the site's key in `hollware.config.ts`. */
+const sites = sqliteTable("sites", {
+	id: text("id").primaryKey(),
+	...timestamps()
+});
+/** People. A user belongs to the deployment; tokens carry the site. */
+const users = sqliteTable("users", {
+	id: id("usr"),
+	name: text("name"),
+	role: text("role").notNull(),
+	...timestamps()
+}, (t) => [check("users_role", sql`${t.role} IN ('owner', 'editor', 'reviewer')`)]);
+/** Personal tokens (ADR-019): only the hash is stored. */
+const tokens = sqliteTable("tokens", {
+	id: id("tok"),
+	siteId: siteId(),
+	userId: text("user_id").notNull(),
+	label: text("label").notNull(),
+	hash: text("hash").notNull(),
+	/** A JSON array of scopes. */
+	scopes: text("scopes").notNull(),
+	expiresAt: text("expires_at"),
+	revokedAt: text("revoked_at"),
+	lastUsedAt: text("last_used_at"),
+	...timestamps()
+}, (t) => [
+	unique("tokens_id_site").on(t.id, t.siteId),
+	unique("tokens_hash").on(t.hash),
+	foreignKey({
+		name: "tokens_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "tokens_user",
+		columns: [t.userId],
+		foreignColumns: [users.id]
+	}),
+	check("tokens_scopes", sql`json_valid(${t.scopes}) AND json_type(${t.scopes}) = 'array'`)
+]);
+/** One entry per site, collection, locale and slug; its content lives in `revisions`. */
+const entries = sqliteTable("entries", {
+	id: id("ent"),
+	siteId: siteId(),
+	collection: text("collection").notNull(),
+	locale: text("locale").notNull(),
+	slug: text("slug").notNull(),
+	translationGroup: text("translation_group"),
+	status: text("status").notNull(),
+	/** Bumped by every change of the entry: the optimistic write compares it. */
+	version: integer("version").notNull(),
+	headRev: text("head_rev").notNull(),
+	publishedRev: text("published_rev"),
+	publishedAt: text("published_at"),
+	publishedSortKey: text("published_sort_key"),
+	scheduledAt: text("scheduled_at"),
+	...timestamps()
+}, (t) => [
+	unique("entries_id_site").on(t.id, t.siteId),
+	unique("entries_slug").on(t.siteId, t.collection, t.locale, t.slug),
+	unique("entries_translation").on(t.siteId, t.collection, t.translationGroup, t.locale),
+	index("entries_head").on(t.siteId, t.collection, t.updatedAt, t.id),
+	index("entries_head_locale").on(t.siteId, t.collection, t.locale, t.updatedAt, t.id),
+	index("entries_published").on(t.siteId, t.collection, t.locale, t.publishedSortKey, t.id).where(sql`${t.status} = 'published'`),
+	foreignKey({
+		name: "entries_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	check("entries_status", sql`${t.status} IN ('draft', 'scheduled', 'published')`),
+	check("entries_version", sql`${t.version} >= 1`),
+	check("entries_draft", sql`${t.status} <> 'draft' OR (${t.publishedRev} IS NULL AND ${t.publishedSortKey} IS NULL AND ${t.scheduledAt} IS NULL)`),
+	check("entries_published", sql`${t.status} <> 'published' OR (${t.publishedRev} IS NOT NULL AND ${t.publishedAt} IS NOT NULL AND ${t.publishedSortKey} IS NOT NULL)`),
+	check("entries_scheduled", sql`${t.status} <> 'scheduled' OR ${t.scheduledAt} IS NOT NULL`)
+]);
+/**
+* Every version of an entry, appended and never changed (ADR-021). `markdown` is the whole file,
+* frontmatter included; the derived columns can be rebuilt by `reparse`.
+*/
+const revisions = sqliteTable("revisions", {
+	id: id("rev"),
+	siteId: siteId(),
+	entryId: text("entry_id").notNull(),
+	markdown: text("markdown").notNull(),
+	/** Derived: the frontmatter as JSON. */
+	frontmatter: text("frontmatter").notNull(),
+	/** Derived: the Comark document as JSON. */
+	document: text("document").notNull(),
+	comarkVersion: text("comark_version").notNull(),
+	pipelineVersion: text("pipeline_version").notNull(),
+	wordCount: integer("word_count").notNull(),
+	/** The verdict of the contracts when the revision was written, as JSON. */
+	verdict: text("verdict").notNull(),
+	actorKind: text("actor_kind").notNull(),
+	actorUserId: text("actor_user_id").notNull(),
+	actorTokenId: text("actor_token_id"),
+	/** The client and, when it says, the model behind the write, as JSON. */
+	actorMeta: text("actor_meta"),
+	...timestamps()
+}, (t) => [
+	unique("revisions_id_site").on(t.id, t.siteId),
+	index("revisions_entry").on(t.entryId, t.createdAt),
+	foreignKey({
+		name: "revisions_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "revisions_entry",
+		columns: [t.entryId, t.siteId],
+		foreignColumns: [entries.id, entries.siteId]
+	}),
+	foreignKey({
+		name: "revisions_user",
+		columns: [t.actorUserId],
+		foreignColumns: [users.id]
+	}),
+	foreignKey({
+		name: "revisions_token",
+		columns: [t.actorTokenId, t.siteId],
+		foreignColumns: [tokens.id, tokens.siteId]
+	}),
+	check("revisions_actor_kind", sql`${t.actorKind} IN ('token', 'user', 'oauth_client')`),
+	check("revisions_json", sql`json_valid(${t.frontmatter}) AND json_valid(${t.document}) AND json_valid(${t.verdict}) AND (${t.actorMeta} IS NULL OR json_valid(${t.actorMeta}))`),
+	check("revisions_word_count", sql`${t.wordCount} >= 0`)
+]);
+/** The tags of a revision, for listing published entries by tag. Append-only, like revisions. */
+const revisionTags = sqliteTable("revision_tags", {
+	id: id("tag"),
+	siteId: siteId(),
+	revisionId: text("revision_id").notNull(),
+	tag: text("tag").notNull(),
+	...timestamps()
+}, (t) => [
+	unique("revision_tags_id_site").on(t.id, t.siteId),
+	unique("revision_tags_tag").on(t.revisionId, t.tag),
+	index("revision_tags_by_tag").on(t.siteId, t.tag),
+	foreignKey({
+		name: "revision_tags_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "revision_tags_revision",
+		columns: [t.revisionId, t.siteId],
+		foreignColumns: [revisions.id, revisions.siteId]
+	})
+]);
+/**
+* Every publish and unpublish, appended: the verdict of the publish phase and the warnings the
+* caller acknowledged (ADR-021).
+*/
+const publications = sqliteTable("publications", {
+	id: id("pub"),
+	siteId: siteId(),
+	entryId: text("entry_id").notNull(),
+	action: text("action").notNull(),
+	revisionId: text("revision_id"),
+	verdict: text("verdict"),
+	/** A JSON array: the warnings the caller acknowledged to publish. */
+	acknowledged: text("acknowledged").notNull(),
+	actorKind: text("actor_kind").notNull(),
+	actorUserId: text("actor_user_id").notNull(),
+	actorTokenId: text("actor_token_id"),
+	actorMeta: text("actor_meta"),
+	...timestamps()
+}, (t) => [
+	unique("publications_id_site").on(t.id, t.siteId),
+	index("publications_entry").on(t.entryId, t.createdAt),
+	foreignKey({
+		name: "publications_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "publications_entry",
+		columns: [t.entryId, t.siteId],
+		foreignColumns: [entries.id, entries.siteId]
+	}),
+	foreignKey({
+		name: "publications_revision",
+		columns: [t.revisionId, t.siteId],
+		foreignColumns: [revisions.id, revisions.siteId]
+	}),
+	foreignKey({
+		name: "publications_user",
+		columns: [t.actorUserId],
+		foreignColumns: [users.id]
+	}),
+	foreignKey({
+		name: "publications_token",
+		columns: [t.actorTokenId, t.siteId],
+		foreignColumns: [tokens.id, tokens.siteId]
+	}),
+	check("publications_action", sql`${t.action} IN ('publish', 'unpublish')`),
+	check("publications_shape", sql`(${t.action} = 'publish' AND ${t.revisionId} IS NOT NULL AND ${t.verdict} IS NOT NULL) OR (${t.action} = 'unpublish' AND ${t.revisionId} IS NULL AND ${t.verdict} IS NULL)`),
+	check("publications_actor_kind", sql`${t.actorKind} IN ('token', 'user', 'oauth_client')`),
+	check("publications_json", sql`json_valid(${t.acknowledged}) AND json_type(${t.acknowledged}) = 'array' AND (${t.verdict} IS NULL OR json_valid(${t.verdict})) AND (${t.actorMeta} IS NULL OR json_valid(${t.actorMeta}))`)
+]);
+/**
+* Scheduled publications (ADR-025): one per entry at most. The cron trigger publishes the entry when
+* `scheduled_at` has passed, if it is still at `version`, with the warnings that were acknowledged
+* when it was scheduled, and in the name of who scheduled it.
+*/
+const schedules = sqliteTable("schedules", {
+	id: id("sch"),
+	siteId: siteId(),
+	entryId: text("entry_id").notNull(),
+	scheduledAt: text("scheduled_at").notNull(),
+	/** The version of the entry once scheduled: a later change cancels the schedule. */
+	version: integer("version").notNull(),
+	/** A JSON array: the warnings acknowledged when the publication was scheduled. */
+	acknowledged: text("acknowledged").notNull(),
+	actorKind: text("actor_kind").notNull(),
+	actorUserId: text("actor_user_id").notNull(),
+	actorTokenId: text("actor_token_id"),
+	actorMeta: text("actor_meta"),
+	...timestamps()
+}, (t) => [
+	unique("schedules_id_site").on(t.id, t.siteId),
+	unique("schedules_entry").on(t.siteId, t.entryId),
+	index("schedules_due").on(t.scheduledAt),
+	foreignKey({
+		name: "schedules_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "schedules_entry_fk",
+		columns: [t.entryId, t.siteId],
+		foreignColumns: [entries.id, entries.siteId]
+	}),
+	foreignKey({
+		name: "schedules_user",
+		columns: [t.actorUserId],
+		foreignColumns: [users.id]
+	}),
+	foreignKey({
+		name: "schedules_token",
+		columns: [t.actorTokenId, t.siteId],
+		foreignColumns: [tokens.id, tokens.siteId]
+	}),
+	check("schedules_actor_kind", sql`${t.actorKind} IN ('token', 'user', 'oauth_client')`),
+	check("schedules_json", sql`json_valid(${t.acknowledged}) AND json_type(${t.acknowledged}) = 'array' AND (${t.actorMeta} IS NULL OR json_valid(${t.actorMeta}))`)
+]);
+/**
+* The effects of a publication (ADR-025), written in the batch that publishes or unpublishes: one
+* row per event. The Queue consumer delivers each event to every subscriber, and records it in
+* `deliveries`; `sent_at` says that the event was put on the Queue.
+*/
+const outbox = sqliteTable("outbox", {
+	id: id("evt"),
+	siteId: siteId(),
+	/** `entry.published` or `entry.unpublished`. */
+	kind: text("kind").notNull(),
+	entryId: text("entry_id").notNull(),
+	/** A JSON object: what subscribers get. */
+	payload: text("payload").notNull(),
+	sentAt: text("sent_at"),
+	...timestamps()
+}, (t) => [
+	unique("outbox_id_site").on(t.id, t.siteId),
+	index("outbox_unsent").on(t.sentAt, t.createdAt),
+	foreignKey({
+		name: "outbox_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	check("outbox_kind", sql`${t.kind} IN ('entry.published', 'entry.unpublished')`),
+	check("outbox_json", sql`json_valid(${t.payload}) AND json_type(${t.payload}) = 'object'`)
+]);
+/** Each delivery of an event to a subscriber, so that a retry never delivers it twice. */
+const deliveries = sqliteTable("deliveries", {
+	id: id("dlv"),
+	siteId: siteId(),
+	eventId: text("event_id").notNull(),
+	/** The subscriber, by its name in the config, such as `webhook:newsletter` or `indexnow`. */
+	subscriber: text("subscriber").notNull(),
+	attempts: integer("attempts").notNull(),
+	deliveredAt: text("delivered_at"),
+	lastError: text("last_error"),
+	...timestamps()
+}, (t) => [
+	unique("deliveries_id_site").on(t.id, t.siteId),
+	unique("deliveries_event_subscriber").on(t.eventId, t.subscriber),
+	foreignKey({
+		name: "deliveries_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "deliveries_event",
+		columns: [t.eventId, t.siteId],
+		foreignColumns: [outbox.id, outbox.siteId]
+	}),
+	check("deliveries_attempts", sql`${t.attempts} >= 0`)
+]);
+//#endregion
+//#region src/db/rows.ts
+/**
+* The columns the store reads and how they become the types of `ports.ts`. The JSON columns come
+* back as the store wrote them: the `CHECK`s of the schema guarantee valid JSON, and only the
+* store writes the shapes.
+*/
+/** The columns of `entries` that `StoredEntry` holds. */
+const entryFields = {
+	id: entries.id,
+	collection: entries.collection,
+	locale: entries.locale,
+	slug: entries.slug,
+	translationGroup: entries.translationGroup,
+	status: entries.status,
+	version: entries.version,
+	headRev: entries.headRev,
+	publishedRev: entries.publishedRev,
+	publishedAt: entries.publishedAt,
+	updatedAt: entries.updatedAt
+};
+/** The columns of `revisions` that `StoredRevision` holds, except its tags. */
+const revisionFields = {
+	id: revisions.id,
+	entryId: revisions.entryId,
+	markdown: revisions.markdown,
+	frontmatter: revisions.frontmatter,
+	document: revisions.document,
+	comarkVersion: revisions.comarkVersion,
+	pipelineVersion: revisions.pipelineVersion,
+	wordCount: revisions.wordCount,
+	verdict: revisions.verdict,
+	actorKind: revisions.actorKind,
+	actorUserId: revisions.actorUserId,
+	actorTokenId: revisions.actorTokenId,
+	actorMeta: revisions.actorMeta,
+	createdAt: revisions.createdAt
+};
+/**
+* The columns of `revisions` that a listing reads: the id and the frontmatter of the revision of
+* the view, and nothing else. The Markdown, the document and the verdict can weigh megabytes, so
+* a listing never selects them (`tests/db/list.workerd.test.ts` holds the statements to it).
+*/
+const revisionSummaryFields = {
+	id: revisions.id,
+	frontmatter: revisions.frontmatter
+};
+/** The columns of `publications` that `StoredPublication` holds. */
+const publicationFields = {
+	id: publications.id,
+	entryId: publications.entryId,
+	action: publications.action,
+	revisionId: publications.revisionId,
+	verdict: publications.verdict,
+	acknowledged: publications.acknowledged,
+	actorKind: publications.actorKind,
+	actorUserId: publications.actorUserId,
+	actorTokenId: publications.actorTokenId,
+	actorMeta: publications.actorMeta,
+	createdAt: publications.createdAt
+};
+/**
+* The tags of a revision as a JSON array, read in the same statement as the revision: one query
+* per page, and the same snapshot. `revision` is the revision table the statement joins.
+*/
+function tagsOf$1(revision) {
+	return sql`(select json_group_array(${revisionTags.tag}) from ${revisionTags} where ${and(eq(revisionTags.revisionId, revision.id), eq(revisionTags.siteId, revision.siteId))})`;
+}
+/** The value of `candidates` that `value` is, or a failure: the schema's `CHECK`s forbid the rest. */
+function oneOf(candidates, value, what) {
+	for (const candidate of candidates) if (candidate === value) return candidate;
+	throw new Error(`A row has ${what} ${JSON.stringify(value)}, which the schema does not allow`);
+}
+/** The status of an entry, which the schema's `CHECK` limits to these three. */
+function entryStatus(value) {
+	return oneOf([
+		"draft",
+		"scheduled",
+		"published"
+	], value, "the status");
+}
+function toEntry(row) {
+	return {
+		id: row.id,
+		collection: row.collection,
+		locale: row.locale,
+		slug: row.slug,
+		translationGroup: row.translationGroup,
+		status: entryStatus(row.status),
+		version: row.version,
+		headRevision: row.headRev,
+		publishedRevision: row.publishedRev,
+		publishedAt: row.publishedAt,
+		updatedAt: row.updatedAt
+	};
+}
+function toActor(row) {
+	const meta = row.actorMeta === null ? null : JSON.parse(row.actorMeta);
+	return {
+		kind: oneOf([
+			"token",
+			"user",
+			"oauth_client"
+		], row.actorKind, "the actor kind"),
+		userId: row.actorUserId,
+		tokenId: row.actorTokenId,
+		meta
+	};
+}
+/** The tags come back sorted, so that a revision reads the same however its tags were written. */
+function parseTags(tagsJson) {
+	return JSON.parse(tagsJson).toSorted();
+}
+function toRevision(row, tagsJson) {
+	const frontmatter = JSON.parse(row.frontmatter);
+	const document = JSON.parse(row.document);
+	const verdict = JSON.parse(row.verdict);
+	return {
+		id: row.id,
+		entryId: row.entryId,
+		markdown: row.markdown,
+		frontmatter,
+		document,
+		comarkVersion: row.comarkVersion,
+		pipelineVersion: row.pipelineVersion,
+		wordCount: row.wordCount,
+		verdict,
+		tags: parseTags(tagsJson),
+		actor: toActor(row),
+		createdAt: row.createdAt
+	};
+}
+function toRevisionSummary(row, tagsJson) {
+	const frontmatter = JSON.parse(row.frontmatter);
+	return {
+		id: row.id,
+		frontmatter,
+		tags: parseTags(tagsJson)
+	};
+}
+function toPublication(row) {
+	const verdict = row.verdict === null ? null : JSON.parse(row.verdict);
+	const acknowledged = JSON.parse(row.acknowledged);
+	return {
+		id: row.id,
+		entryId: row.entryId,
+		action: oneOf(["publish", "unpublish"], row.action, "the action"),
+		revisionId: row.revisionId,
+		verdict,
+		acknowledged,
+		actor: toActor(row),
+		createdAt: row.createdAt
+	};
+}
+//#endregion
+//#region src/db/reads.ts
+/**
+* The reads of the store. Every query carries the `site_id` of the site it was asked for, so a
+* natural key, an id or a translation group of another site finds nothing.
+*/
+/**
+* Whether an entry is published, as the partial index of published listings says it
+* (`entries_published` covers `status = 'published'`). It is a literal and not a bound value:
+* the index serves a query that says what the index says, and SQLite can tell that of a `?` only
+* by looking at the value bound to it when it plans, which is for the engine to do or not.
+*/
+const publishedOnly = sql`${entries.status} = 'published'`;
+/** How an entry reaches the revision of a view: the head revision, or the published one. */
+function revisionOf$1(view) {
+	const revisionId = view === "head" ? entries.headRev : entries.publishedRev;
+	return and(eq(revisions.id, revisionId), eq(revisions.siteId, entries.siteId));
+}
+/** What picks the entries of a view: the caller's conditions, and in the published view only published ones. */
+function viewWhere(view, conditions) {
+	return and(...conditions, view === "published" ? publishedOnly : void 0);
+}
+/**
+* The entries of a site with the whole revision of a view, for the reads of one entry. The caller
+* adds the conditions that pick the entries and what limits them.
+*/
+function viewQuery(db, view, conditions) {
+	return db.select({
+		entry: entryFields,
+		revision: revisionFields,
+		tags: tagsOf$1(revisions)
+	}).from(entries).innerJoin(revisions, revisionOf$1(view)).where(viewWhere(view, conditions));
+}
+function toEntryView(row) {
+	return {
+		entry: toEntry(row.entry),
+		revision: toRevision(row.revision, row.tags)
+	};
+}
+/**
+* The entries of a site with a summary of the revision of a view, for listings: the entry, and of
+* the revision only its id, its frontmatter and its tags. The sort key of the published view
+* comes along for the cursor.
+*/
+function summaryQuery(db, view, conditions) {
+	return db.select({
+		entry: entryFields,
+		revision: revisionSummaryFields,
+		tags: tagsOf$1(revisions),
+		sortKey: entries.publishedSortKey
+	}).from(entries).innerJoin(revisions, revisionOf$1(view)).where(viewWhere(view, conditions));
+}
+function toEntrySummaryView(row) {
+	return {
+		entry: toEntry(row.entry),
+		revision: toRevisionSummary(row.revision, row.tags)
+	};
+}
+async function findEntry(db, site, ref, view) {
+	const [row] = await viewQuery(db, view, [
+		eq(entries.siteId, site),
+		eq(entries.collection, ref.collection),
+		eq(entries.locale, ref.locale),
+		eq(entries.slug, ref.slug)
+	]).limit(1);
+	return row === void 0 ? null : toEntryView(row);
+}
+async function findEntryById(db, site, id, view) {
+	const [row] = await viewQuery(db, view, [eq(entries.siteId, site), eq(entries.id, id)]).limit(1);
+	return row === void 0 ? null : toEntryView(row);
+}
+/** A revision of the site by its id, with its tags: what a publish answers with. */
+async function findRevision(db, site, revisionId) {
+	const [row] = await db.select({
+		revision: revisionFields,
+		tags: tagsOf$1(revisions)
+	}).from(revisions).where(and(eq(revisions.id, revisionId), eq(revisions.siteId, site))).limit(1);
+	return row === void 0 ? null : toRevision(row.revision, row.tags);
+}
+/** Whether the revision a view joined has the tag. */
+function hasTag(site, tag) {
+	return sql`exists (select 1 from ${revisionTags} where ${and(eq(revisionTags.revisionId, revisions.id), eq(revisionTags.siteId, site), eq(revisionTags.tag, tag))})`;
+}
+/**
+* The statement of a page of a listing: the entries newest first by the sort key of the view and
+* then by id, after the position of a cursor if there is one, and one more than the page holds,
+* which only tells whether there is a next page.
+*
+* It is shaped for the indexes of `entries`, so that a page costs its own rows and not a sort of
+* the collection (`tests/db/list-plans.workerd.test.ts` reads the plans). The head view reads
+* `entries_head`, or `entries_head_locale` when it names a locale. The published view of a locale
+* reads the partial `entries_published`, whose status is the literal the index says. The cursor
+* is a row value, `(sort key, id) < (?, ?)`, which the index seeks to; the same condition written
+* with `OR` is read from the first row of the collection. The published view with no locale
+* named is the exception: the index has the locale before the sort key, so SQLite sorts the
+* published entries of the collection.
+*/
+function listEntriesQuery(db, site, query, cursor) {
+	const sortKey = query.view === "head" ? entries.updatedAt : entries.publishedSortKey;
+	return summaryQuery(db, query.view, [
+		eq(entries.siteId, site),
+		eq(entries.collection, query.collection),
+		query.locale === void 0 ? void 0 : eq(entries.locale, query.locale),
+		query.view === "head" && query.status !== void 0 ? eq(entries.status, query.status) : void 0,
+		query.tag === void 0 ? void 0 : hasTag(site, query.tag),
+		cursor === null ? void 0 : sql`(${sortKey}, ${entries.id}) < (${cursor.key}, ${cursor.id})`
+	]).orderBy(desc(sortKey), desc(entries.id)).limit(query.limit + 1);
+}
+async function listEntries$2(db, site, query) {
+	if (!Number.isInteger(query.limit) || query.limit < 1) throw new HollwareError("invalid_input", `The limit ${query.limit} is not a whole number of at least 1.`, "Ask for at least one entry per page.");
+	const cursor = query.cursor === void 0 ? null : decodeCursor(query.cursor, query.view);
+	if (query.view === "published" && query.status !== void 0 && query.status !== "published") return {
+		entries: [],
+		nextCursor: null
+	};
+	const rows = await listEntriesQuery(db, site, query, cursor);
+	const page = rows.slice(0, query.limit);
+	const last = page.at(-1);
+	if (last === void 0 || rows.length === page.length) return {
+		entries: page.map(toEntrySummaryView),
+		nextCursor: null
+	};
+	const key = query.view === "head" ? last.entry.updatedAt : last.sortKey;
+	if (key === null) throw new Error(`The published entry ${last.entry.id} has no published_sort_key`);
+	return {
+		entries: page.map(toEntrySummaryView),
+		nextCursor: encodeCursor(query.view, {
+			key,
+			id: last.entry.id
+		})
+	};
+}
+/**
+* The statement of the entries of a translation group: the unique key of the group ends in the
+* locale, so the index gives them in order of locale with no sort.
+*/
+function listTranslationsQuery(db, site, collection, translationGroup, view) {
+	return summaryQuery(db, view, [
+		eq(entries.siteId, site),
+		eq(entries.collection, collection),
+		eq(entries.translationGroup, translationGroup)
+	]).orderBy(entries.locale);
+}
+async function listTranslations(db, site, collection, translationGroup, view) {
+	return (await listTranslationsQuery(db, site, collection, translationGroup, view)).map(toEntrySummaryView);
+}
+/**
+* The latest publish or unpublish of an entry. Rows are never deleted, so the insertion order
+* (`rowid`) breaks a tie between two written in the same millisecond.
+*/
+async function lastPublication(db, site, entryId) {
+	const [row] = await db.select(publicationFields).from(publications).where(and(eq(publications.siteId, site), eq(publications.entryId, entryId))).orderBy(desc(publications.createdAt), sql`${publications}.rowid desc`).limit(1);
+	return row === void 0 ? null : toPublication(row);
+}
+const factFields = {
+	id: entries.id,
+	collection: entries.collection,
+	locale: entries.locale,
+	slug: entries.slug,
+	status: entries.status,
+	translationGroup: entries.translationGroup
+};
+function refKey(ref) {
+	return JSON.stringify([
+		ref.collection,
+		ref.locale,
+		ref.slug
+	]);
+}
+function refMatches(ref) {
+	return and(eq(entries.collection, ref.collection), eq(entries.locale, ref.locale), eq(entries.slug, ref.slug));
+}
+/** What cross-entry contracts read, scoped to one site. */
+function lookup(db, site) {
+	return {
+		/**
+		* One query per chunk of refs, in one batch: each ref binds three values and the site one
+		* more, under D1's limit of bound values. A ref asked twice is asked once.
+		*/
+		async lookupMany(refs) {
+			const [first, ...rest] = chunk([...new Map(refs.map((ref) => [refKey(ref), ref])).values()], rowsPerStatement(1, 3)).map((group) => db.select(factFields).from(entries).where(and(eq(entries.siteId, site), or(...group.map(refMatches)))));
+			if (first === void 0) return [];
+			const found = /* @__PURE__ */ new Map();
+			for (const row of (await db.batch([first, ...rest])).flat()) found.set(refKey(row), {
+				id: row.id,
+				status: entryStatus(row.status),
+				translationGroup: row.translationGroup
+			});
+			return refs.map((ref) => found.get(refKey(ref)) ?? null);
+		},
+		async translations(collection, translationGroup) {
+			return (await db.select(factFields).from(entries).where(and(eq(entries.siteId, site), eq(entries.collection, collection), eq(entries.translationGroup, translationGroup))).orderBy(entries.locale)).map((row) => ({
+				collection: row.collection,
+				locale: row.locale,
+				slug: row.slug,
+				id: row.id,
+				status: entryStatus(row.status),
+				translationGroup: row.translationGroup
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/db/statements.ts
+function actorColumns(actor) {
+	return {
+		actorKind: actor.kind,
+		actorUserId: actor.userId,
+		actorTokenId: actor.tokenId,
+		actorMeta: actor.meta === null ? null : JSON.stringify(actor.meta)
+	};
+}
+/** The tags of a revision as written: each once, sorted, so that a revision always reads the same. */
+function distinctTags(tags) {
+	return [...new Set(tags)].toSorted();
+}
+function revisionRow(input) {
+	const { revision } = input;
+	return {
+		id: input.id,
+		siteId: input.site,
+		entryId: input.entryId,
+		markdown: revision.markdown,
+		frontmatter: JSON.stringify(revision.frontmatter),
+		document: JSON.stringify(revision.document),
+		comarkVersion: revision.comarkVersion,
+		pipelineVersion: revision.pipelineVersion,
+		wordCount: revision.wordCount,
+		verdict: JSON.stringify(revision.verdict),
+		...actorColumns(revision.actor),
+		createdAt: input.now,
+		updatedAt: input.now
+	};
+}
+function publicationRow(input) {
+	return {
+		id: newId("pub"),
+		siteId: input.site,
+		entryId: input.entryId,
+		action: input.publish === null ? "unpublish" : "publish",
+		revisionId: input.publish?.revisionId ?? null,
+		verdict: input.publish === null ? null : JSON.stringify(input.publish.verdict),
+		acknowledged: JSON.stringify(input.publish?.acknowledged ?? []),
+		...actorColumns(input.actor),
+		createdAt: input.now,
+		updatedAt: input.now
+	};
+}
+/**
+* The values of a row in the order of the table's columns, for `insert into t select …`: the
+* insert lists every column of the table, so the select has to give them all, and a column that
+* the row lacks fails here instead of shifting the ones after it. A value may be a column or any
+* SQL, for what only the database knows.
+*/
+function valuesOf(table, row) {
+	const values = Object.keys(getTableColumns(table)).map((field) => {
+		const value = row[field];
+		if (value === void 0) throw new Error(`The row has no value for the column ${field}`);
+		return sql`${value}`;
+	});
+	return sql.join(values, sql`, `);
+}
+/** Inserts the revision of an entry only if the entry is still at `version`. */
+function insertRevisionAtVersion(db, row, version) {
+	return db.insert(revisions).select(sql`select ${valuesOf(revisions, row)} from ${entries} where ${and(eq(entries.id, row.entryId), eq(entries.siteId, row.siteId), eq(entries.version, version))}`);
+}
+/**
+* Inserts the tags of a revision, in as many statements as D1's limit of bound values needs, and
+* only where the revision is there: a tag whose revision was never inserted would fail the
+* foreign key and turn a conflict into a database error. Each tag binds its id and its text;
+* the site, the revision and the time are bound once, and the existence check binds two more.
+* The tags are a `VALUES` list: D1 allows a compound `SELECT` only five terms long, so a
+* `UNION ALL` of tags would fail from the sixth.
+*/
+function insertTags(db, input) {
+	const perStatement = rowsPerStatement(6, 2);
+	return chunk(input.tags, perStatement).map((tags) => {
+		const rows = tags.map((tag) => sql`(${newId("tag")}, ${tag})`);
+		return db.insert(revisionTags).select(sql`with "t" ("id", "tag") as (values ${sql.join(rows, sql`, `)}) select "t"."id", ${input.site}, ${input.revisionId}, "t"."tag", ${input.now}, ${input.now} from "t" where exists (select 1 from ${revisions} where ${and(eq(revisions.id, input.revisionId), eq(revisions.siteId, input.site))})`);
+	});
+}
+/**
+* Appends a publication that publishes the head revision of an entry that is still at `version`.
+* The revision is whatever `head_rev` is when the statement runs.
+*/
+function insertPublishAtVersion(db, row, version) {
+	return db.insert(publications).select(sql`select ${valuesOf(publications, {
+		...row,
+		revisionId: entries.headRev
+	})} from ${entries} where ${and(eq(entries.id, row.entryId), eq(entries.siteId, row.siteId), eq(entries.version, version))}`);
+}
+/** Appends an unpublish, only if the entry is published when the statement runs. */
+function insertUnpublishIfPublished(db, row) {
+	return db.insert(publications).select(sql`select ${valuesOf(publications, row)} from ${entries} where ${and(eq(entries.id, row.entryId), eq(entries.siteId, row.siteId), eq(entries.status, "published"))}`);
+}
+//#endregion
+//#region src/db/schedules.ts
+/**
+* Scheduled publications (ADR-025). An entry waits in status `scheduled` with its `scheduled_at`,
+* and its row of `schedules` says what was acknowledged and by whom, for the cron trigger that
+* publishes it once the time has passed.
+*/
+/** Statements that drop the schedule of an entry, in the batch of a write that ends it. */
+function dropSchedule(db, site, entryId) {
+	return db.delete(schedules).where(and(eq(schedules.siteId, site), eq(schedules.entryId, entryId)));
+}
+async function schedule(db, clock, site, write) {
+	const now = clock.now().toISOString();
+	const row = {
+		id: newId("sch"),
+		siteId: site,
+		entryId: write.entryId,
+		scheduledAt: write.scheduledAt,
+		version: write.expectedVersion + 1,
+		acknowledged: JSON.stringify(write.acknowledged),
+		...actorColumns(write.actor),
+		createdAt: now,
+		updatedAt: now
+	};
+	const atVersion = and(eq(entries.id, write.entryId), eq(entries.siteId, site), eq(entries.version, write.expectedVersion), sql`${entries.status} <> 'published'`);
+	const results = await db.batch([
+		db.delete(schedules).where(and(eq(schedules.siteId, site), eq(schedules.entryId, write.entryId), sql`exists (select 1 from ${entries} where ${atVersion})`)),
+		db.insert(schedules).select(sql`select ${valuesOf(schedules, row)} from ${entries} where ${atVersion}`),
+		db.update(entries).set({
+			status: "scheduled",
+			scheduledAt: write.scheduledAt,
+			version: sql`${entries.version} + 1`,
+			updatedAt: now
+		}).where(atVersion).returning({ id: entries.id })
+	]);
+	const view = await findEntryById(db, site, write.entryId, "head");
+	if (view === null) return { outcome: "not_found" };
+	if (results[2].length === 0) return {
+		outcome: "conflict",
+		currentVersion: view.entry.version,
+		headRevision: view.entry.headRevision
+	};
+	return {
+		outcome: "scheduled",
+		view
+	};
+}
+/** The schedules of a site whose time has come, oldest first. */
+async function dueSchedules(db, site, now) {
+	return (await db.select().from(schedules).where(and(eq(schedules.siteId, site), lte(schedules.scheduledAt, now))).orderBy(schedules.scheduledAt).limit(50)).map((row) => ({
+		entryId: row.entryId,
+		scheduledAt: row.scheduledAt,
+		version: row.version,
+		acknowledged: parseAcknowledged(row.acknowledged),
+		actor: {
+			kind: "token",
+			userId: row.actorUserId,
+			tokenId: row.actorTokenId,
+			meta: row.actorMeta === null ? null : parseMeta(row.actorMeta)
+		}
+	}));
+}
+/** Takes an entry out of `scheduled`, back to a draft, and drops its schedule. */
+async function cancelSchedule(db, clock, site, entryId) {
+	await db.batch([dropSchedule(db, site, entryId), db.update(entries).set({
+		status: "draft",
+		scheduledAt: null,
+		version: sql`${entries.version} + 1`,
+		updatedAt: clock.now().toISOString()
+	}).where(and(eq(entries.id, entryId), eq(entries.siteId, site), eq(entries.status, "scheduled")))]);
+}
+function parseAcknowledged(text) {
+	const value = JSON.parse(text);
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => typeof item === "object" && item !== null && "contract" in item && "path" in item && typeof item.contract === "string" && typeof item.path === "string" ? [{
+		contract: item.contract,
+		path: item.path
+	}] : []);
+}
+function parseMeta(text) {
+	const value = JSON.parse(text);
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : null;
+}
+//#endregion
+//#region src/db/errors.ts
+/**
+* What D1 says when a statement breaks a unique key: `D1_ERROR: UNIQUE constraint failed:
+* entries.site_id, …: SQLITE_CONSTRAINT`, with the same text again in the `cause`. Inside a batch
+* the error arrives as it is, and the batch has rolled back.
+*/
+function isUniqueViolation(error) {
+	let current = error;
+	for (let depth = 0; depth < 4 && current instanceof Error; depth += 1) {
+		if (current.message.includes("UNIQUE constraint failed")) return true;
+		current = current.cause;
+	}
+	return false;
+}
+//#endregion
+//#region src/db/size.ts
+/**
+* D1 refuses rows over 2 MB, and Miniflare does not enforce it, so the store counts the bytes of
+* a row before writing it and refuses a row over `MAX_ROW_BYTES` (`limits.ts`).
+*/
+const encoder$1 = new TextEncoder();
+/** The bytes of `text` in UTF-8, which is how D1 stores it. */
+function utf8Bytes(text) {
+	return encoder$1.encode(text).byteLength;
+}
+/** What SQLite keeps for an integer, at most. */
+const INTEGER_BYTES = 8;
+/** The bytes of every column of a row: text in UTF-8, an integer as 8 bytes, a null as none. */
+function rowBytes(row) {
+	let bytes = 0;
+	for (const value of Object.values(row)) if (typeof value === "string") bytes += utf8Bytes(value);
+	else if (value !== null) bytes += INTEGER_BYTES;
+	return bytes;
+}
+/** The refusal for a row over the limit, or `null` when it fits. */
+function tooLarge(row) {
+	const bytes = rowBytes(row);
+	return bytes > 19e5 ? {
+		outcome: "too_large",
+		bytes,
+		limit: MAX_ROW_BYTES
+	} : null;
+}
+//#endregion
+//#region src/db/writes.ts
+/**
+* Waits for a write batch. A batch that broke a unique key of `entries` has rolled back, and the
+* answer is `taken` by the entry that holds the key, found by `holder`. A unique violation nobody
+* holds the key for, and any other error, is not an outcome: it is thrown as it came.
+*/
+async function attempt(batch, holder) {
+	try {
+		return { written: await batch };
+	} catch (error) {
+		const taken = isUniqueViolation(error) ? await holder() : null;
+		if (taken === null) throw error;
+		return { taken };
+	}
+}
+/** The entry that holds the slug or the translation that a new entry asks for; the slug first. */
+async function holderOfNewEntry(db, site, entry) {
+	const rows = await db.select({
+		id: entries.id,
+		slug: entries.slug
+	}).from(entries).where(and(eq(entries.siteId, site), eq(entries.collection, entry.collection), eq(entries.locale, entry.locale), or(eq(entries.slug, entry.slug), entry.translationGroup === null ? void 0 : eq(entries.translationGroup, entry.translationGroup))));
+	const bySlug = rows.find((row) => row.slug === entry.slug);
+	if (bySlug !== void 0) return {
+		outcome: "taken",
+		field: "slug",
+		by: bySlug.id
+	};
+	const [byGroup] = rows;
+	return byGroup === void 0 ? null : {
+		outcome: "taken",
+		field: "translationGroup",
+		by: byGroup.id
+	};
+}
+/** The other entry of the collection and locale of `entryId` that is in `translationGroup`. */
+async function holderOfTranslation(db, site, entryId, translationGroup) {
+	if (translationGroup === null) return null;
+	const other = alias(entries, "other");
+	const [row] = await db.select({ id: other.id }).from(entries).innerJoin(other, and(eq(other.siteId, entries.siteId), eq(other.collection, entries.collection), eq(other.locale, entries.locale), eq(other.translationGroup, translationGroup), ne(other.id, entries.id))).where(and(eq(entries.siteId, site), eq(entries.id, entryId))).limit(1);
+	return row === void 0 ? null : {
+		outcome: "taken",
+		field: "translationGroup",
+		by: row.id
+	};
+}
+/** Why an update touched nothing: the entry moved on (`conflict`) or it is not there. */
+async function whyNothingChanged(db, site, entryId) {
+	const [row] = await db.select({
+		version: entries.version,
+		headRev: entries.headRev
+	}).from(entries).where(and(eq(entries.siteId, site), eq(entries.id, entryId))).limit(1);
+	return row === void 0 ? { outcome: "not_found" } : {
+		outcome: "conflict",
+		currentVersion: row.version,
+		headRevision: row.headRev
+	};
+}
+/** The revision as a read of it would give it back, for the answer of a write that made it. */
+function storedRevision(input) {
+	const { revision } = input;
+	return {
+		id: input.id,
+		entryId: input.entryId,
+		markdown: revision.markdown,
+		frontmatter: revision.frontmatter,
+		document: revision.document,
+		comarkVersion: revision.comarkVersion,
+		pipelineVersion: revision.pipelineVersion,
+		wordCount: revision.wordCount,
+		verdict: revision.verdict,
+		tags: input.tags,
+		actor: revision.actor,
+		createdAt: input.now
+	};
+}
+async function createEntry(db, clock, site, entry) {
+	const now = clock.now().toISOString();
+	const entryId = newId("ent");
+	const revisionId = newId("rev");
+	const row = revisionRow({
+		id: revisionId,
+		site,
+		entryId,
+		now,
+		revision: entry.revision
+	});
+	const refusal = tooLarge(row);
+	if (refusal !== null) return refusal;
+	const tags = distinctTags(entry.revision.tags);
+	const result = await attempt(db.batch([
+		db.insert(entries).values({
+			id: entryId,
+			siteId: site,
+			collection: entry.collection,
+			locale: entry.locale,
+			slug: entry.slug,
+			translationGroup: entry.translationGroup,
+			status: "draft",
+			version: 1,
+			headRev: revisionId,
+			publishedRev: null,
+			publishedAt: null,
+			publishedSortKey: null,
+			scheduledAt: null,
+			createdAt: now,
+			updatedAt: now
+		}),
+		db.insert(revisions).values(row),
+		...insertTags(db, {
+			site,
+			revisionId,
+			tags,
+			now
+		})
+	]), () => holderOfNewEntry(db, site, entry));
+	if ("taken" in result) return result.taken;
+	return {
+		outcome: "saved",
+		view: {
+			entry: {
+				id: entryId,
+				collection: entry.collection,
+				locale: entry.locale,
+				slug: entry.slug,
+				translationGroup: entry.translationGroup,
+				status: "draft",
+				version: 1,
+				headRevision: revisionId,
+				publishedRevision: null,
+				publishedAt: null,
+				updatedAt: now
+			},
+			revision: storedRevision({
+				id: revisionId,
+				entryId,
+				now,
+				revision: entry.revision,
+				tags
+			})
+		}
+	};
+}
+async function appendRevision(db, clock, site, write) {
+	const now = clock.now().toISOString();
+	const revisionId = newId("rev");
+	const row = revisionRow({
+		id: revisionId,
+		site,
+		entryId: write.entryId,
+		now,
+		revision: write.revision
+	});
+	const refusal = tooLarge(row);
+	if (refusal !== null) return refusal;
+	const tags = distinctTags(write.revision.tags);
+	const result = await attempt(db.batch([
+		insertRevisionAtVersion(db, row, write.expectedVersion),
+		...insertTags(db, {
+			site,
+			revisionId,
+			tags,
+			now
+		}),
+		db.update(entries).set({
+			version: sql`${entries.version} + 1`,
+			headRev: revisionId,
+			translationGroup: write.translationGroup,
+			updatedAt: now
+		}).where(and(eq(entries.id, write.entryId), eq(entries.siteId, site), eq(entries.version, write.expectedVersion))).returning(entryFields)
+	]), () => holderOfTranslation(db, site, write.entryId, write.translationGroup));
+	if ("taken" in result) return result.taken;
+	const updated = result.written.at(-1);
+	const [changed] = Array.isArray(updated) ? updated : [];
+	if (changed === void 0) return whyNothingChanged(db, site, write.entryId);
+	return {
+		outcome: "saved",
+		view: {
+			entry: toEntry(changed),
+			revision: storedRevision({
+				id: revisionId,
+				entryId: write.entryId,
+				now,
+				revision: write.revision,
+				tags
+			})
+		}
+	};
+}
+async function publish$2(db, clock, site, write) {
+	const now = clock.now().toISOString();
+	const row = publicationRow({
+		site,
+		entryId: write.entryId,
+		now,
+		actor: write.actor,
+		publish: {
+			revisionId: newId("rev"),
+			verdict: write.verdict,
+			acknowledged: write.acknowledged
+		}
+	});
+	const refusal = tooLarge(row);
+	if (refusal !== null) return refusal;
+	const [changed] = (await db.batch([
+		insertPublishAtVersion(db, row, write.expectedVersion),
+		dropScheduleAtVersion(db, site, write.entryId, write.expectedVersion),
+		insertEventWhere(db, site, write.entryId, write.event ?? null, "entry.published", now, [eq(entries.version, write.expectedVersion)]),
+		db.update(entries).set({
+			status: "published",
+			scheduledAt: null,
+			publishedRev: entries.headRev,
+			publishedAt: sql`coalesce(${entries.publishedAt}, ${now})`,
+			publishedSortKey: write.sortKey,
+			version: sql`${entries.version} + 1`,
+			updatedAt: now
+		}).where(and(eq(entries.id, write.entryId), eq(entries.siteId, site), eq(entries.version, write.expectedVersion))).returning(entryFields)
+	]))[3];
+	if (changed === void 0) return whyNothingChanged(db, site, write.entryId);
+	const entry = toEntry(changed);
+	const revision = entry.publishedRevision === null ? null : await findRevision(db, site, entry.publishedRevision);
+	if (revision === null) throw new Error(`The revision that entry ${entry.id} was published at is not there`);
+	return {
+		outcome: "published",
+		view: {
+			entry,
+			revision
+		}
+	};
+}
+/** The message of the statement that aborts a group publish: SQLite fails to parse it as JSON. */
+const GROUP_MOVED = "hollware: an entry of the group is not at its version";
+/**
+* Publishes a group of entries in one batch, all or none (ADR-024). Each entry gets the two
+* statements of `publish`; a last statement fails the batch, which D1 then rolls back, when fewer
+* publications landed than the group has entries: `json()` of a text that is not JSON raises an
+* error, and it runs only then. A refusal names the entry.
+*/
+async function publishGroup$1(db, clock, site, group) {
+	const now = clock.now().toISOString();
+	const statements = [];
+	const appended = [];
+	for (const write of group) {
+		const row = publicationRow({
+			site,
+			entryId: write.entryId,
+			now,
+			actor: write.actor,
+			publish: {
+				revisionId: newId("rev"),
+				verdict: write.verdict,
+				acknowledged: write.acknowledged
+			}
+		});
+		const refusal = tooLarge(row);
+		if (refusal !== null) return {
+			...refusal,
+			entryId: write.entryId
+		};
+		appended.push(row.id);
+		statements.push(insertPublishAtVersion(db, row, write.expectedVersion), dropScheduleAtVersion(db, site, write.entryId, write.expectedVersion), insertEventWhere(db, site, write.entryId, write.event ?? null, "entry.published", now, [eq(entries.version, write.expectedVersion)]), db.update(entries).set({
+			status: "published",
+			scheduledAt: null,
+			publishedRev: entries.headRev,
+			publishedAt: sql`coalesce(${entries.publishedAt}, ${now})`,
+			publishedSortKey: write.sortKey,
+			version: sql`${entries.version} + 1`,
+			updatedAt: now
+		}).where(and(eq(entries.id, write.entryId), eq(entries.siteId, site), eq(entries.version, write.expectedVersion))));
+	}
+	const guard = db.select({ moved: sql`json(${GROUP_MOVED})` }).from(sites).where(and(eq(sites.id, site), sql`(select count(*) from ${publications} where ${and(eq(publications.siteId, site), inArray(publications.id, appended))}) < ${group.length}`));
+	try {
+		const [first, ...rest] = [...statements, guard];
+		if (first !== void 0) await db.batch([first, ...rest]);
+	} catch (error) {
+		if (!(error instanceof Error) || !/malformed JSON/i.test(`${error.message} ${String(error.cause)}`)) throw error;
+		for (const write of group) {
+			const why = await whyNothingChanged(db, site, write.entryId);
+			if (why.outcome === "not_found" || why.currentVersion !== write.expectedVersion) return {
+				...why,
+				entryId: write.entryId
+			};
+		}
+		throw new Error("A group publish failed, and every entry of the group is at its version", { cause: error });
+	}
+	const views = [];
+	for (const write of group) {
+		const view = await findEntryById(db, site, write.entryId, "published");
+		if (view === null) throw new Error(`Entry ${write.entryId} is not published after its group`);
+		views.push(view);
+	}
+	return {
+		outcome: "published",
+		views
+	};
+}
+async function unpublish$1(db, clock, site, write) {
+	const now = clock.now().toISOString();
+	const row = publicationRow({
+		site,
+		entryId: write.entryId,
+		now,
+		actor: write.actor,
+		publish: null
+	});
+	const refusal = tooLarge(row);
+	if (refusal !== null) return refusal;
+	await db.batch([
+		insertUnpublishIfPublished(db, row),
+		insertEventWhere(db, site, write.entryId, write.event ?? null, "entry.unpublished", now, [eq(entries.status, "published")]),
+		dropSchedule(db, site, write.entryId),
+		db.update(entries).set({
+			status: "draft",
+			scheduledAt: null,
+			publishedRev: null,
+			publishedSortKey: null,
+			version: sql`${entries.version} + 1`,
+			updatedAt: now
+		}).where(and(eq(entries.id, write.entryId), eq(entries.siteId, site), inArray(entries.status, ["published", "scheduled"])))
+	]);
+	const view = await findEntryById(db, site, write.entryId, "head");
+	return view === null ? { outcome: "not_found" } : {
+		outcome: "unpublished",
+		view
+	};
+}
+/** Drops the schedule of an entry in the batch that publishes it, if it is at `version`. */
+function dropScheduleAtVersion(db, site, entryId, version) {
+	return db.delete(schedules).where(and(eq(schedules.siteId, site), eq(schedules.entryId, entryId), sql`exists (select 1 from ${entries} where ${and(eq(entries.id, entryId), eq(entries.siteId, site), eq(entries.version, version))})`));
+}
+/**
+* Writes the event of a write to the outbox in its batch, only where the entry is in the state the
+* write expects, so that an event is there exactly when its write is. Nothing when there is no
+* event: a statement that selects nothing, to keep the batch the same shape.
+*/
+function insertEventWhere(db, site, entryId, event, kind, now, conditions) {
+	const row = {
+		id: event?.id ?? "evt_none",
+		siteId: site,
+		kind,
+		entryId,
+		payload: event?.payload ?? "{}",
+		sentAt: null,
+		createdAt: now,
+		updatedAt: now
+	};
+	return db.insert(outbox).select(sql`select ${valuesOf(outbox, row)} from ${entries} where ${and(eq(entries.id, entryId), eq(entries.siteId, site), sql`${event === null ? 0 : 1} = 1`, ...conditions)}`);
+}
+//#endregion
+//#region src/db/store.ts
+const systemClock$1 = { now: () => /* @__PURE__ */ new Date() };
+/**
+* The content store on D1 (`ports.ts`). `db` is a D1 database, which the writes need, or a D1
+* session, which is enough for reads: `env.DB.withSession('first-unconstrained')` is what RPC
+* reads use. Every method takes the site first and only reads and writes that site's rows.
+*/
+function createD1Store(db, options = {}) {
+	const database = connect(db);
+	const clock = options.clock ?? systemClock$1;
+	return {
+		findEntry: (site, ref, view) => findEntry(database, site, ref, view),
+		findEntryById: (site, id, view) => findEntryById(database, site, id, view),
+		listEntries: (site, query) => listEntries$2(database, site, query),
+		listTranslations: (site, collection, translationGroup, view) => listTranslations(database, site, collection, translationGroup, view),
+		lookup: (site) => lookup(database, site),
+		lastPublication: (site, entryId) => lastPublication(database, site, entryId),
+		createEntry: (site, entry) => createEntry(database, clock, site, entry),
+		appendRevision: (site, write) => appendRevision(database, clock, site, write),
+		publish: (site, write) => publish$2(database, clock, site, write),
+		publishGroup: (site, group) => publishGroup$1(database, clock, site, group),
+		schedule: (site, write) => schedule(database, clock, site, write),
+		dueSchedules: (site, now) => dueSchedules(database, site, now),
+		cancelSchedule: (site, entryId) => cancelSchedule(database, clock, site, entryId),
+		unpublish: (site, write) => unpublish$1(database, clock, site, write)
+	};
+}
+//#endregion
+//#region src/db/events.ts
+async function findEvent(db, site, id) {
+	const [row] = await db.select({
+		id: outbox.id,
+		kind: outbox.kind,
+		payload: outbox.payload
+	}).from(outbox).where(and(eq(outbox.siteId, site), eq(outbox.id, id))).limit(1);
+	return row ?? null;
+}
+/** The events that were never put on the Queue and are older than `before`, oldest first. */
+async function unsentEvents(db, site, before, limit = 100) {
+	return (await db.select({ id: outbox.id }).from(outbox).where(and(eq(outbox.siteId, site), isNull(outbox.sentAt), lte(outbox.createdAt, before))).orderBy(outbox.createdAt).limit(limit)).map((row) => row.id);
+}
+async function markSent(db, site, ids, now) {
+	if (ids.length === 0) return;
+	await db.update(outbox).set({
+		sentAt: now,
+		updatedAt: now
+	}).where(and(eq(outbox.siteId, site), inArray(outbox.id, [...ids])));
+}
+/** The subscribers that already have an event, so that a retry never delivers it twice. */
+async function deliveredTo(db, site, eventId) {
+	const rows = await db.select({
+		subscriber: deliveries.subscriber,
+		deliveredAt: deliveries.deliveredAt
+	}).from(deliveries).where(and(eq(deliveries.siteId, site), eq(deliveries.eventId, eventId)));
+	return new Set(rows.filter((row) => row.deliveredAt !== null).map((row) => row.subscriber));
+}
+/** Records one attempt to deliver an event to a subscriber, and its result. */
+async function recordAttempt(db, input) {
+	const deliveredAt = input.error === null ? input.now : null;
+	await db.insert(deliveries).values({
+		id: newId("dlv"),
+		siteId: input.site,
+		eventId: input.eventId,
+		subscriber: input.subscriber,
+		attempts: 1,
+		deliveredAt,
+		lastError: input.error,
+		createdAt: input.now,
+		updatedAt: input.now
+	}).onConflictDoUpdate({
+		target: [deliveries.eventId, deliveries.subscriber],
+		set: {
+			attempts: sqlIncrement(),
+			deliveredAt,
+			lastError: input.error,
+			updatedAt: input.now
+		}
+	});
+}
+function sqlIncrement() {
+	return sql`${deliveries.attempts} + 1`;
+}
+//#endregion
+//#region src/events/deliver.ts
+/** Where IndexNow takes the URLs that changed. */
+const INDEXNOW_ENDPOINT = "https://api.indexnow.org/indexnow";
+async function ensureOk(response, what) {
+	if (response.ok) return;
+	throw new Error(`${what} answered ${response.status}`);
+}
+/** The subscribers that the config of the site declares (ADR-025). */
+function subscribersOf(deps) {
+	const { site } = deps;
+	const subscribers = site.events.webhooks.map((webhook) => ({
+		name: `webhook:${webhook.name}`,
+		async send(payload, body) {
+			const secret = deps.secret(webhook.secret);
+			if (secret === void 0) throw new Error(`the secret ${webhook.secret} is not set`);
+			const timestamp = Math.floor(deps.clock.now().getTime() / 1e3);
+			const request = new Request(webhook.url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					[EVENT_ID_HEADER]: payload.id,
+					[TIMESTAMP_HEADER]: String(timestamp),
+					[SIGNATURE_HEADER]: await signWebhook(secret, timestamp, body)
+				},
+				body
+			});
+			await ensureOk(await deps.fetch(request), `the webhook ${webhook.name}`);
+		}
+	}));
+	const indexNow = site.events.indexNow;
+	if (indexNow !== null && site.url !== null) {
+		const host = new URL(site.url).host;
+		subscribers.push({
+			name: "indexnow",
+			async send(payload) {
+				if (payload.url === null) return;
+				const key = deps.secret(indexNow.key);
+				if (key === void 0) throw new Error(`the secret ${indexNow.key} is not set`);
+				const request = new Request(INDEXNOW_ENDPOINT, {
+					method: "POST",
+					headers: { "content-type": "application/json; charset=utf-8" },
+					body: JSON.stringify({
+						host,
+						key,
+						urlList: [payload.url]
+					})
+				});
+				await ensureOk(await deps.fetch(request), "IndexNow");
+			}
+		});
+	}
+	return subscribers;
+}
+/**
+* Delivers one event of the outbox to every subscriber that does not have it yet, and records each
+* attempt. A subscriber that fails is tried again on the next delivery of the event, and one that
+* succeeded is never sent it again: the caller retries the message while `failed` is not empty.
+* An event that is gone, or a site without subscribers, delivers nothing.
+*/
+async function deliverEvent(deps, eventId) {
+	const event = await findEvent(deps.db, deps.site.key, eventId);
+	if (event === null) return {
+		delivered: [],
+		failed: []
+	};
+	const payload = JSON.parse(event.payload);
+	const done = await deliveredTo(deps.db, deps.site.key, eventId);
+	const delivered = [];
+	const failed = [];
+	for (const subscriber of subscribersOf(deps)) {
+		if (done.has(subscriber.name)) continue;
+		let error = null;
+		try {
+			await subscriber.send(payload, event.payload);
+		} catch (cause) {
+			error = cause instanceof Error ? cause.message : String(cause);
+		}
+		await recordAttempt(deps.db, {
+			site: deps.site.key,
+			eventId,
+			subscriber: subscriber.name,
+			now: deps.clock.now().toISOString(),
+			error
+		});
+		(error === null ? delivered : failed).push(subscriber.name);
+	}
+	return {
+		delivered,
+		failed
+	};
+}
+//#endregion
+//#region src/events/run.ts
+/**
+* Puts events on the Queue and marks them sent. Without a Queue binding nothing is sent: the
+* sweep of the cron trigger delivers them instead, within a minute.
+*/
+async function enqueue(input) {
+	if (input.queue === void 0 || input.ids.length === 0) return;
+	await input.queue.sendBatch(input.ids.map((id) => ({ body: {
+		site: input.site,
+		id
+	} })));
+	await markSent(input.db, input.site, input.ids, input.clock.now().toISOString());
+}
+/**
+* What the cron trigger does with the outbox: an event that was never put on the Queue (its
+* request ended before, or the project has no Queue) is put on it, or, without a Queue, delivered
+* here. An event delivered here is marked sent only when every subscriber has it.
+*/
+async function sweepOutbox(input) {
+	const { deps, queue } = input;
+	const now = deps.clock.now().toISOString();
+	const ids = await unsentEvents(deps.db, deps.site.key, now);
+	if (queue !== void 0) {
+		await enqueue({
+			queue,
+			db: deps.db,
+			site: deps.site.key,
+			ids,
+			clock: deps.clock
+		});
+		return { swept: ids.length };
+	}
+	for (const id of ids) if ((await deliverEvent(deps, id)).failed.length === 0) await markSent(deps.db, deps.site.key, [id], now);
+	return { swept: ids.length };
+}
+function isEventMessage(body) {
+	return typeof body === "object" && body !== null && "site" in body && "id" in body && typeof body.site === "string" && typeof body.id === "string";
+}
+/**
+* The Queue consumer: delivers each event, acknowledges it once every subscriber has it, and asks
+* for a retry otherwise; after the Queue's retries it lands in the dead-letter queue. A message of
+* another site, or that is no event, is acknowledged and dropped.
+*/
+async function consumeEvents(messages, deps) {
+	for (const message of messages) {
+		const { body } = message;
+		if (!isEventMessage(body) || body.site !== deps.site.key) {
+			message.ack();
+			continue;
+		}
+		if ((await deliverEvent(deps, body.id)).failed.length === 0) message.ack();
+		else message.retry();
+	}
+}
+//#endregion
+//#region src/mcp/errors.ts
+/**
+* The error a caller gets for anything that is not a `HollwareError`. The message is fixed: what
+* went wrong goes to the log and never to the caller, whose agent could repeat it to a person or
+* to another system. The request id is how the operator finds the log line.
+*/
+function internalError$1(requestId, cause) {
+	return new HollwareError("internal", "The operation failed on the server.", `Try again. If it keeps failing, give the site operator this request id: ${requestId}.`, { cause });
+}
+/** The fix of `timeout`, by effect: a write that ran out of time may still finish. */
+const TIMEOUT_FIX = {
+	read: "Try again. If it keeps timing out, ask for less.",
+	edit: "The change may still be applied after this answer: read the entry with get_entry before you repeat the call.",
+	write: "The change may still be applied after this answer: read the entry with get_entry before you repeat the call.",
+	destructive: "The change may still be applied after this answer: read the entry with get_entry before you repeat the call."
+};
+function timeoutError(spec, timeoutMs) {
+	return new HollwareError("timeout", `${spec.name} did not finish within ${timeoutMs} ms.`, TIMEOUT_FIX[spec.effect]);
+}
+/** A value that is not an error, as text: handlers may throw anything. */
+function printable(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? typeof value;
+	} catch {
+		return typeof value;
+	}
+}
+/**
+* What the operator needs to know about an error, for the log: its stack (or its type and
+* message), then the same for each cause. It is never sent to the caller.
+*/
+function describeError(error) {
+	const lines = [];
+	let current = error;
+	for (let depth = 0; depth < 5 && current !== void 0; depth++) if (current instanceof Error) {
+		lines.push(current.stack ?? `${current.name}: ${current.message}`);
+		current = current.cause;
+	} else {
+		lines.push(printable(current));
+		current = void 0;
+	}
+	return lines.join("\ncaused by: ");
+}
+//#endregion
+//#region src/http/errors.ts
+/** A JSON error response that no cache keeps. */
+function gatewayError(status, body) {
+	return Response.json(body, {
+		status,
+		headers: { "cache-control": "no-store" }
+	});
+}
+/**
+* Everything that differs between Hono 4 and Hono 5 error handling lives in this file (spike S1).
+*
+* Hono 4: `app.onError((error, c) => Response)`, one handler for the app.
+* Hono 5: `app.onError((c, next) => Response)` registers error middleware, and the error is
+* `c.error`. A Hono 4 handler registered on Hono 5 is not rejected: it is called with the context
+* where it expects the error, throws, and the app answers a plain-text 500. So the tests read the
+* JSON body of both answers.
+*
+* - An error that a route throws is a JSON 500 with a fixed message, and the id of the request
+*   in its fix, which is how the operator finds the line of the log that has the cause. The cause
+*   goes to the log and never to the caller, whose agent could repeat it to a person or to another
+*   system. This holds for every error, a failed D1 query included: nothing turns one into a 401.
+* - A path that no route has is a JSON 404.
+*/
+function installErrorHandling(app, log) {
+	app.onError((c) => {
+		const requestId = c.get("requestId");
+		log({
+			kind: "request_error",
+			requestId,
+			method: c.req.method,
+			path: c.req.path,
+			detail: describeError(c.error)
+		});
+		return gatewayError(500, {
+			code: "internal",
+			message: "The request failed on the server.",
+			fix: `Try again. If it keeps failing, give the site operator this request id: ${requestId}.`
+		});
+	});
+	app.notFound(() => gatewayError(404, {
+		code: "not_found",
+		message: "This Hollware has no route for that path.",
+		fix: "Send MCP requests to /mcp with \"Authorization: Bearer <token>\". GET /health tells whether the Worker is up."
+	}));
+}
+//#endregion
+//#region src/http/read-api.ts
+const STATUS = {
+	invalid_input: 400,
+	unknown_collection: 404,
+	unknown_locale: 404
+};
+/** A weak ETag of a body: the first 128 bits of its SHA-256, in hex. */
+async function etagOf(body) {
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body)));
+	return `W/"${Array.from(digest.slice(0, 16), (byte) => byte.toString(16).padStart(2, "0")).join("")}"`;
+}
+/** Whether `If-None-Match` names this ETag, or is `*`. */
+function matches(header, etag) {
+	if (header === void 0) return false;
+	return header.split(",").map((tag) => tag.trim()).some((tag) => tag === "*" || tag === etag || `W/${tag}` === etag);
+}
+async function answer(c, value) {
+	const notFound = typeof value === "object" && value !== null && "outcome" in value && value.outcome === "not_found";
+	const body = JSON.stringify(value);
+	const etag = await etagOf(body);
+	const headers = {
+		etag,
+		"cache-control": "private, no-cache",
+		"content-type": "application/json"
+	};
+	if (!notFound && matches(c.req.header("if-none-match"), etag)) return new Response(null, {
+		status: 304,
+		headers
+	});
+	return new Response(body, {
+		status: notFound ? 404 : 200,
+		headers
+	});
+}
+function installReadApi(app, options) {
+	app.use("/v1/*", async (c, next) => {
+		if (c.req.method !== "GET" && c.req.method !== "HEAD") return c.json({
+			code: "invalid_input",
+			message: "The read API only reads.",
+			fix: "Use GET."
+		}, 405, { allow: "GET, HEAD" });
+		if (c.req.path === "/v1/openapi.json") return next();
+		const requestId = c.get("requestId");
+		const token = readBearerToken(c.req.raw);
+		if (token === null) {
+			options.log({
+				kind: "auth_refused",
+				requestId,
+				reason: "no_token"
+			});
+			return unauthorized();
+		}
+		const check = await checkPersonalToken(c.env.DB, token, {
+			site: options.site,
+			now: options.clock.now()
+		});
+		if (!check.ok) {
+			options.log({
+				kind: "auth_refused",
+				requestId,
+				reason: check.reason
+			});
+			return unauthorized(check.reason);
+		}
+		if (!check.principal.scopes.includes("content:read")) return insufficientScope(["content:read"]);
+		if (check.touch !== null) c.executionCtx.waitUntil(check.touch);
+		try {
+			return await next();
+		} catch (error) {
+			if (!(error instanceof HollwareError)) throw error;
+			return c.json({
+				code: error.code,
+				message: error.message,
+				fix: error.fix
+			}, STATUS[error.code] ?? 500);
+		}
+	});
+	app.get("/v1/openapi.json", (c) => c.json(openApiDocument(options.site)));
+	app.get("/v1/site", async (c) => answer(c, await options.read(c.env).describeSite(options.site)));
+	app.get("/v1/:collection", async (c) => {
+		const query = c.req.query();
+		const limit = query["limit"] === void 0 ? void 0 : Number(query["limit"]);
+		return answer(c, await options.read(c.env).listEntries(options.site, c.req.param("collection"), {
+			...query["locale"] === void 0 ? {} : { locale: query["locale"] },
+			...query["tag"] === void 0 ? {} : { tag: query["tag"] },
+			...limit === void 0 ? {} : { limit },
+			...query["cursor"] === void 0 ? {} : { cursor: query["cursor"] }
+		}));
+	});
+	app.get("/v1/:collection/translations/:group", async (c) => answer(c, await options.read(c.env).getTranslations(options.site, c.req.param("collection"), c.req.param("group"))));
+	app.get("/v1/:collection/:locale/:slug", async (c) => {
+		const formats = c.req.query("formats");
+		return answer(c, await options.read(c.env).getEntry(options.site, c.req.param("collection"), c.req.param("slug"), c.req.param("locale"), formats === void 0 ? {} : { formats: formats.split(",").flatMap((format) => format === "markdown" || format === "document" || format === "html" ? [format] : []) }));
+	});
+}
+/** The OpenAPI 3.1 document of the read API. */
+function openApiDocument(site) {
+	const ok = (description) => ({
+		description,
+		headers: { ETag: { schema: { type: "string" } } },
+		content: { "application/json": { schema: { type: "object" } } }
+	});
+	const common = {
+		"304": { description: "Not modified: the ETag of If-None-Match is current." },
+		"401": { description: "No token, or one that is unknown, expired or revoked." },
+		"403": { description: "The token lacks content:read." }
+	};
+	const param = (name, location, required) => ({
+		name,
+		in: location,
+		required,
+		schema: { type: "string" }
+	});
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: `Hollware read API (${site})`,
+			version: "1"
+		},
+		components: { securitySchemes: { token: {
+			type: "http",
+			scheme: "bearer"
+		} } },
+		security: [{ token: [] }],
+		paths: {
+			"/v1/site": { get: {
+				operationId: "describe_site",
+				responses: {
+					"200": ok("The site"),
+					...common
+				}
+			} },
+			"/v1/{collection}": { get: {
+				operationId: "list_entries",
+				parameters: [
+					param("collection", "path", true),
+					param("locale", "query", false),
+					param("tag", "query", false),
+					param("limit", "query", false),
+					param("cursor", "query", false)
+				],
+				responses: {
+					"200": ok("A page of published entries"),
+					...common
+				}
+			} },
+			"/v1/{collection}/translations/{group}": { get: {
+				operationId: "get_translations",
+				parameters: [param("collection", "path", true), param("group", "path", true)],
+				responses: {
+					"200": ok("The published entries of the group"),
+					"404": { description: "No such group" },
+					...common
+				}
+			} },
+			"/v1/{collection}/{locale}/{slug}": { get: {
+				operationId: "get_entry",
+				parameters: [
+					param("collection", "path", true),
+					param("locale", "path", true),
+					param("slug", "path", true),
+					param("formats", "query", false)
+				],
+				responses: {
+					"200": ok("A published entry"),
+					"404": { description: "No such published entry" },
+					...common
+				}
+			} }
+		}
+	};
+}
+//#endregion
+//#region src/http/gateway.ts
+/**
+* The HTTP gateway of the Worker (ADR-019): a Hono 5 app, built once, that runs in this order for
+* every request:
+*
+* 1. an id for the request, which its errors and its log lines carry;
+* 2. the Host and Origin guard (`checkHostAndOrigin`), before any route, health and unknown
+*    paths included. It fails closed: no valid `HOLLWARE_PUBLIC_URL` is a 500;
+* 3. the routes: `GET /health` answers `{ "ok": true }`, and `/mcp` answers every method, after
+*    the token check below. Any other path is a JSON 404.
+*
+* The token check is the 401 that stands in front of the MCP endpoint, which never authenticates:
+* no token, or a token that `checkPersonalToken` refuses, is `unauthorized()` and the endpoint is
+* not called. It looks the token up on the `D1Database` binding and never on a replica session,
+* so a revoked token stops at once. Its reason goes to the log and never to the answer. The write
+* of `last_used_at` is handed to `ctx.waitUntil`: Workers cancel a promise nobody waits for.
+*
+* The endpoint then gets the request as it came, with its body and its `Mcp-*` headers untouched
+* (a 2026 client's headers must agree with its body), and the primary database: an agent reads
+* what it has just written.
+*
+* Whatever a route throws ends in the error middleware (`errors.ts`) as a JSON 500 that leaks
+* nothing. A failed D1 query while the token is checked is one of those: it is never a 401.
+*/
+function createGateway(options) {
+	const { site, mcp, clock, log } = options;
+	const app = new Hono();
+	app.use("*", async (c, next) => {
+		c.set("requestId", crypto.randomUUID());
+		await next();
+	});
+	app.use("*", async (c, next) => {
+		const refusal = checkHostAndOrigin(c.req.raw, c.env.HOLLWARE_PUBLIC_URL);
+		if (refusal !== null) return refusal;
+		await next();
+	});
+	app.get("/health", () => Response.json({ ok: true }, { headers: { "cache-control": "no-store" } }));
+	app.all("/mcp", async (c) => {
+		const requestId = c.get("requestId");
+		const token = readBearerToken(c.req.raw);
+		if (token === null) {
+			log({
+				kind: "auth_refused",
+				requestId,
+				reason: "no_token"
+			});
+			return unauthorized();
+		}
+		const check = await checkPersonalToken(c.env.DB, token, {
+			site: site.key,
+			now: clock.now()
+		});
+		if (!check.ok) {
+			log({
+				kind: "auth_refused",
+				requestId,
+				reason: check.reason
+			});
+			return unauthorized(check.reason);
+		}
+		if (check.touch !== null) c.executionCtx.waitUntil(check.touch);
+		const db = c.env.DB;
+		return await mcp.fetch(c.req.raw, {
+			principal: check.principal,
+			requestId,
+			context: {
+				site,
+				store: createD1Store(db, { clock }),
+				clock,
+				notify: (ids) => {
+					c.executionCtx.waitUntil(enqueue({
+						queue: c.env.EVENTS,
+						db: connect(db),
+						site: site.key,
+						ids,
+						clock
+					}).catch((error) => {
+						log({
+							kind: "enqueue_failed",
+							requestId,
+							message: String(error)
+						});
+					}));
+				}
+			}
+		});
+	});
+	if (options.read !== void 0) installReadApi(app, {
+		read: options.read,
+		site: site.key,
+		clock,
+		log
+	});
+	installErrorHandling(app, log);
+	return async (request, env, ctx) => await app.fetch(request, env, ctx);
+}
+//#endregion
+//#region src/mcp/annotations.ts
+/**
+* The MCP hints of each effect (ADR-017 and the v0.1 plan). A `read` is read-only and
+* idempotent; an `edit` or a `write` is neither read-only nor destructive; a `destructive`
+* operation is destructive, and repeating it changes nothing more. No tool reaches outside the
+* deployment, so every tool is closed-world.
+*/
+const EFFECT_ANNOTATIONS = {
+	read: {
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	},
+	edit: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	},
+	write: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	},
+	destructive: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		idempotentHint: true,
+		openWorldHint: false
+	}
+};
+//#endregion
+//#region src/mcp/acknowledge.ts
+/** The key of the question in `inputRequests`, and of the answer in `inputResponses`. */
+const QUESTION_KEY = "acknowledge_warnings";
+const form = z.object({ acknowledge: z.boolean().describe("Publish with these warnings.") });
+function warningsOf(output) {
+	return output.verdict?.warnings ?? [];
+}
+function question(output, warnings) {
+	const subject = output.entry === void 0 ? "this entry" : `${output.entry.collection}/${output.entry.locale}/${output.entry.slug}`;
+	const count = warnings.length === 1 ? "1 warning" : `${warnings.length} warnings`;
+	const lines = warnings.map((warning, index) => {
+		const where = warning.line === void 0 ? warning.path : `${warning.path}, line ${warning.line}`;
+		return `${index + 1}. ${warning.contract} at ${where}: ${warning.message} Fix: ${warning.fix}`;
+	});
+	return [
+		`Publish ${subject} with ${count}?`,
+		"",
+		...lines
+	].join("\n");
+}
+/**
+* The question to put to the person: every warning with its fix, and one box to tick. The
+* `needs_acknowledgement` answer travels in `requestState`, because the retry is a request of its
+* own and the server keeps nothing between the two: it is what a refusal answers, and where the
+* warnings to acknowledge come from. The client sends the state back as it got it, and it could
+* write any state it likes; the state grants nothing that `acknowledgeWarnings` does not, since a
+* client sends that argument by hand.
+*/
+function askToAcknowledge(output) {
+	return inputRequired({
+		inputRequests: { [QUESTION_KEY]: inputRequired.elicit({
+			message: question(output, warningsOf(output)),
+			requestedSchema: form
+		}) },
+		requestState: JSON.stringify(output)
+	});
+}
+/** The answer that the state of a retry carries, or `undefined` if it carries none that we wrote. */
+function askedIn(state) {
+	if (typeof state !== "string") return void 0;
+	let json;
+	try {
+		json = JSON.parse(state);
+	} catch {
+		return;
+	}
+	const parsed = publish.output.safeParse(json);
+	return parsed.success && parsed.data.outcome === "needs_acknowledgement" ? parsed.data : void 0;
+}
+/**
+* The person's reply, when the call is the retry of a question we asked, and `null` when it is
+* not: a first call, or a retry that lost the state, which is treated as a first call. A decline,
+* a cancel and a form accepted with the box empty are all a refusal.
+*/
+function replyTo(mcp) {
+	if (inputResponse(mcp.mcpReq.inputResponses, QUESTION_KEY).kind !== "elicit") return null;
+	const asked = askedIn(mcp.mcpReq.requestState());
+	if (asked === void 0) return null;
+	return {
+		given: acceptedContent(mcp.mcpReq.inputResponses, QUESTION_KEY, form)?.acknowledge === true,
+		asked
+	};
+}
+/**
+* The input of the publish that follows an acceptance: the warnings the person was shown, added
+* to those the client already acknowledged, each contract and path once.
+*/
+function withAcknowledged(input, asked) {
+	const acknowledged = new Map(input.acknowledgeWarnings.map((warning) => [`${warning.contract}\n${warning.path}`, warning]));
+	for (const { contract, path } of warningsOf(asked)) acknowledged.set(`${contract}\n${path}`, {
+		contract,
+		path
+	});
+	return {
+		...input,
+		acknowledgeWarnings: [...acknowledged.values()]
+	};
+}
+//#endregion
+//#region src/mcp/envelope.ts
+/**
+* What a client says about itself. A 2026-07-28 client says it on every request, in the `_meta`
+* envelope; a 2025-11-25 client says it once, in `initialize`, and the stateless fallback that
+* serves those clients keeps nothing between requests, so for them there is nothing to read.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The longest name, version or title kept of a client: it is recorded with what it writes. */
+const MAX_CLIENT_FIELD_LENGTH = 120;
+/**
+* The client as the envelope names it: its name, and its version and title when it gives them,
+* each cut short. A client could write anything there, and what it writes is stored with every
+* revision and publication it makes. `null` when the request has no envelope.
+*/
+function declaredClient(envelope) {
+	const info = isRecord(envelope) ? envelope[CLIENT_INFO_META_KEY] : void 0;
+	if (!isRecord(info) || typeof info.name !== "string") return null;
+	const client = { name: info.name.slice(0, MAX_CLIENT_FIELD_LENGTH) };
+	if (typeof info.version === "string") client.version = info.version.slice(0, MAX_CLIENT_FIELD_LENGTH);
+	if (typeof info.title === "string") client.title = info.title.slice(0, MAX_CLIENT_FIELD_LENGTH);
+	return client;
+}
+/**
+* Whether the server may ask the client a question in a form, as a multi round-trip request: the
+* request is in the 2026 era, and the client declared the elicitation capability for forms. A
+* bare `elicitation: {}` counts as forms, as it does for the SDK, which answers `-32021` to a
+* question that the client did not declare; `{ url: {} }` alone does not. A 2025 client in the
+* stateless fallback can never be asked: that fallback has no way to send a request to a client.
+*/
+function canElicitForm(era, envelope) {
+	if (era !== "modern" || !isRecord(envelope)) return false;
+	const capabilities = envelope[CLIENT_CAPABILITIES_META_KEY];
+	const elicitation = isRecord(capabilities) ? capabilities.elicitation : void 0;
+	if (!isRecord(elicitation)) return false;
+	return elicitation.form !== void 0 || elicitation.url === void 0;
+}
+//#endregion
+//#region src/mcp/result.ts
+/**
+* Checks what a handler returned against the output schema of its spec, and keeps only the
+* fields the schema names, so a handler that hands over a row with more columns than the schema
+* has cannot leak them. The SDK checks the same schema again, but only for results that are not
+* errors; an answer that does not match is a bug of the handler, and it throws, so that the call
+* ends as `internal`.
+*/
+function readAnswer(spec, value) {
+	const parsed = spec.output.safeParse(value);
+	if (!parsed.success) {
+		const issues = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+		throw new TypeError(`${spec.name} answered something that is not an output of its spec: ${issues.join("; ")}`);
+	}
+	const { outcome } = parsed.data;
+	const isError = Object.entries(spec.outcomes).some(([name, info]) => name === outcome && info.isError);
+	return {
+		output: parsed.data,
+		outcome,
+		isError
+	};
+}
+const encoder = new TextEncoder();
+/**
+* The fix of `output_too_large`, for each operation. A read says how to ask for less. A write
+* has already run when its answer turns out too large, so it says to look at the state it left.
+*/
+const OUTPUT_TOO_LARGE_FIX = {
+	create_draft: "The operation ran and its change may have been applied: read the entry with get_entry before you repeat it.",
+	describe_site: "The description of the site does not fit in one answer. Document fewer collections, components and contracts, or shorten their descriptions.",
+	get_entry: "Ask for one format at a time with formats: markdown, document or html, instead of several together.",
+	get_translations: "The translations do not fit in one answer. Read each one with get_entry instead.",
+	list_entries: "Ask for less: pass a smaller limit, or narrow the list with locale, tag or status.",
+	publish: "The operation ran and its change may have been applied: read the entry with get_entry before you repeat it.",
+	unpublish: "The operation ran and its change may have been applied: read the entry with get_entry before you repeat it.",
+	update_draft: "The operation ran and its change may have been applied: read the entry with get_entry before you repeat it.",
+	validate: "The verdict lists more problems than fit in one answer. Fix the first ones and validate again."
+};
+/**
+* The result of a call: the answer as `structuredContent`, the same JSON as text for clients
+* that do not read structured content, and `isError` as the spec says for the outcome. An answer
+* whose JSON is over the cap, counted in UTF-8 bytes, is the error `output_too_large`: Hollware
+* never truncates content.
+*/
+function answerResult(spec, answer) {
+	const text = JSON.stringify(answer.output);
+	const bytes = encoder.encode(text).length;
+	if (bytes > 1048576) throw new HollwareError("output_too_large", `The answer of ${spec.name} is ${bytes} bytes, over the cap of ${OUTPUT_CAP_BYTES} bytes.`, OUTPUT_TOO_LARGE_FIX[spec.name]);
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		structuredContent: answer.output,
+		isError: answer.isError
+	};
+}
+/**
+* The result of a call that ended in an error: `{ code, message, fix }` as text, and no
+* structured content. The tools declare an output schema, and clients check the structured
+* content they get against it even when `isError` is set, so an error that is not an output of
+* the operation must not carry any.
+*/
+function errorResult(error) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({
+				code: error.code,
+				message: error.message,
+				fix: error.fix
+			})
+		}],
+		isError: true
+	};
+}
+//#endregion
+//#region src/mcp/scopes.ts
+/**
+* The scope challenge of a tool, which the SDK asks before it serves a call of the tool. A
+* principal that has every scope the tool needs gets nothing, and the call goes on. One that
+* lacks any of them is refused with 403 and a challenge that names every scope the tool needs,
+* the ones it has included, so that a client that can ask for more asks for all of them at once.
+* A request that comes without scopes is refused too: it never passes by lacking a principal.
+*
+* `onDenied` runs when a call is refused, for the log: the call never reaches the tool.
+*/
+function scopeChallenge(tool, onDenied) {
+	return ({ authInfo }) => {
+		const granted = new Set(authInfo?.scopes);
+		if (tool.scopes.every((scope) => granted.has(scope))) return void 0;
+		onDenied();
+		return {
+			scopes: tool.scopes,
+			errorDescription: `${tool.spec.name} requires: ${tool.scopes.join(" ")}`
+		};
+	};
+}
+//#endregion
+//#region src/mcp/timeout.ts
+/**
+* Runs `work` and gives up on it when it takes longer than `limitMs`: the answer is the error
+* that `onTimeout` makes. The work is not stopped, because a promise cannot be: an operation that
+* ran out of time may still finish, and the error says so. Whichever finishes first, the timer
+* is cleared, and a failure of the work after the timeout is already handled by the race.
+*/
+async function within(work, limitMs, onTimeout) {
+	let timer;
+	const timeout = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(onTimeout()), limitMs);
+	});
+	try {
+		return await Promise.race([work, timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/mcp/tools.ts
+/**
+* `schema` with the same validation, whose conversions to JSON Schema are done once and kept.
+* The SDK builds a server for every request, and a server converts the schemas of its tools on
+* its own, so without this every `tools/list` pays for the conversion again (about 1.4 ms for
+* the nine operations, measured in the v0.1 spike). Zod stays the only definition: it validates,
+* applies the defaults and words the errors; only the JSON Schema is cached.
+*
+* What the cache returns is shared by every request: the SDK reads it and never changes it.
+*/
+function memoizeJsonSchema(schema) {
+	const standard = schema["~standard"];
+	const cache = /* @__PURE__ */ new Map();
+	const convert = (io) => (options) => {
+		if (options.libraryOptions !== void 0) return standard.jsonSchema[io](options);
+		const key = `${io}:${options.target}`;
+		let json = cache.get(key);
+		if (json === void 0) {
+			json = standard.jsonSchema[io](options);
+			cache.set(key, json);
+		}
+		return json;
+	};
+	return { "~standard": {
+		version: standard.version,
+		vendor: standard.vendor,
+		types: standard.types,
+		validate: (value, options) => standard.validate(value, options),
+		jsonSchema: {
+			input: convert("input"),
+			output: convert("output")
+		}
+	} };
+}
+const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+/**
+* The tools of `operations`, sorted by name. The SDK lists tools in the order they are
+* registered, and `tools/list` must be the same for every client and every call, so the order
+* is decided here, by code unit and never by locale. The schemas of each tool are cached.
+*
+* An operation that asks for no scope is refused: a tool that anyone may call has to be a
+* decision someone makes, not a spec that forgot its scopes.
+*/
+function createToolTable(operations = OPERATIONS) {
+	return operations.toSorted(byName).map((spec) => {
+		const [first, ...rest] = spec.scopes;
+		if (first === void 0) throw new Error(`${spec.name} asks for no scope; every tool needs at least one`);
+		return {
+			spec,
+			input: memoizeJsonSchema(spec.input),
+			output: memoizeJsonSchema(spec.output),
+			scopes: [first, ...rest]
+		};
+	});
+}
+//#endregion
+//#region src/mcp/endpoint.ts
+/**
+* `tools/list` is the same for every client and changes only when the Worker is deployed again:
+* it depends on the operations of the code and on nothing else, not on the site, the data or the
+* caller. So any cache may keep it (`public`). Five minutes is long enough for an agent that
+* works through a conversation to stop asking, and short enough that a client that cached the
+* list just before a deploy converges on the new one before long: the list can never push a
+* change (`listChanged` is false), so this is the only way a client learns of one.
+*/
+const TOOLS_LIST_CACHE_HINT = {
+	ttlMs: 3e5,
+	cacheScope: "public"
+};
+/**
+* What the SDK is told about a principal: its scopes, which are the effective ones, and the id of
+* its token as the client. It carries no token: the gateway checked it, and nothing here needs it.
+*/
+function authInfoOf(principal) {
+	return {
+		token: "",
+		clientId: principal.kind === "token" ? principal.tokenId : principal.kind,
+		scopes: [...principal.scopes]
+	};
+}
+/**
+* Calls the handler of an operation. This is the one place where the typed pairing of specs and
+* handlers meets the dynamic protocol: the SDK parsed `input` with the input schema of `spec`,
+* which is the schema that types the handler of the same name.
+*/
+function invoke(handlers, spec, input, context) {
+	const handler = handlers[spec.name];
+	return handler(input, context);
+}
+/**
+* The MCP endpoint of Hollware: one tool for each operation, served in both protocol eras, for
+* the gateway to mount at `/mcp` after it has checked the Host, the Origin and the token.
+*
+* One SDK handler serves the whole isolate, and each request gets a server of its own, built from
+* the tool table: the SDK's model, which needs no session. The JSON Schema of every tool is
+* converted once, the first time a request needs it.
+*/
+function createMcpEndpoint(options) {
+	const timeoutMs = options.timeoutMs ?? 1e4;
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new RangeError(`timeoutMs must be a positive number of milliseconds, got ${timeoutMs}`);
+	const tools = createToolTable();
+	/** The call the gateway made for each request, found again by the factory through its authInfo. */
+	const calls = /* @__PURE__ */ new WeakMap();
+	const emit = (entry) => {
+		try {
+			options.log?.(entry);
+		} catch {}
+	};
+	/** One call of a tool: the operation, its answer as a result, and one line of log. */
+	const runTool = async (spec, input, mcp, call, era) => {
+		const started = performance.now();
+		const envelope = mcp.mcpReq.envelope;
+		const context = {
+			...call.context,
+			view: "head",
+			principal: call.principal,
+			requestId: call.requestId,
+			client: declaredClient(envelope)
+		};
+		let outcome = null;
+		let isError = false;
+		let failure = null;
+		let result;
+		/** What the log says of the answer, kept as soon as there is one. */
+		const record = (answer) => {
+			outcome = answer.outcome;
+			isError = answer.isError;
+			return answer;
+		};
+		/** Runs the handler within the time limit and checks its answer. */
+		const perform = async (operationInput) => {
+			const value = await within(invoke(options.handlers, spec, operationInput, context), timeoutMs, () => timeoutError(spec, timeoutMs));
+			return record(readAnswer(spec, value));
+		};
+		/**
+		* Publish, which may ask the person to acknowledge the warnings. The first call asks, if the
+		* client can be asked; the retry carries the reply. A refusal answers what the person was
+		* shown without calling the handler again, and never asks twice: the client would retry
+		* until it gave up.
+		*/
+		const performPublish = async () => {
+			const publishInput = publish.input.parse(input);
+			const reply = replyTo(mcp);
+			if (reply !== null && !reply.given) return answerResult(spec, record(readAnswer(spec, reply.asked)));
+			if (reply !== null) return answerResult(spec, await perform(withAcknowledged(publishInput, reply.asked)));
+			const answer = await perform(publishInput);
+			if (answer.outcome === "needs_acknowledgement" && canElicitForm(era, envelope)) {
+				const asked = publish.output.parse(answer.output);
+				if (warningsOf(asked).length > 0) return askToAcknowledge(asked);
+			}
+			return answerResult(spec, answer);
+		};
+		try {
+			result = spec.name === "publish" ? await performPublish() : answerResult(spec, await perform(input));
+		} catch (error) {
+			failure = error instanceof HollwareError ? error : internalError$1(call.requestId, error);
+			isError = true;
+			result = errorResult(failure);
+		}
+		emit({
+			kind: "call",
+			requestId: call.requestId,
+			tool: spec.name,
+			outcome,
+			errorCode: failure?.code ?? null,
+			isError,
+			durationMs: Math.round(performance.now() - started),
+			detail: failure === null || failure.cause === void 0 ? null : describeError(failure.cause)
+		});
+		return result;
+	};
+	const buildServer = (request) => {
+		const call = request.authInfo === void 0 ? void 0 : calls.get(request.authInfo);
+		if (call === void 0) throw new Error("A request reached the MCP server without the call the gateway made for it");
+		const server = new McpServer(options.serverInfo, {
+			capabilities: { tools: { listChanged: false } },
+			cacheHints: { "tools/list": TOOLS_LIST_CACHE_HINT }
+		});
+		for (const tool of tools) server.registerTool(tool.spec.name, {
+			title: tool.spec.title,
+			description: tool.spec.description,
+			inputSchema: tool.input,
+			outputSchema: tool.output,
+			annotations: EFFECT_ANNOTATIONS[tool.spec.effect],
+			scopeChallenge: scopeChallenge(tool, () => emit({
+				kind: "call",
+				requestId: call.requestId,
+				tool: tool.spec.name,
+				outcome: null,
+				errorCode: "insufficient_scope",
+				isError: true,
+				durationMs: 0,
+				detail: null
+			}))
+		}, (input, mcp) => runTool(tool.spec, input, mcp, call, request.era));
+		return server;
+	};
+	const handler = createMcpHandler(buildServer, { onerror: (error) => emit({
+		kind: "protocol_error",
+		message: error.message
+	}) });
+	return { async fetch(request, call) {
+		if (!call?.principal) throw new Error("The MCP endpoint serves a request only as the principal the gateway found");
+		const authInfo = authInfoOf(call.principal);
+		calls.set(authInfo, call);
+		return handler.fetch(request, { authInfo });
+	} };
+}
+//#endregion
+//#region src/rpc/methods.ts
+/**
+* Who calls over RPC: a Worker of the same account, which reads published content and nothing
+* else. Frozen, so that no handler can widen it for the calls that come after.
+*/
+const BINDING_PRINCIPAL = Object.freeze({
+	kind: "binding",
+	scopes: Object.freeze(["content:read"])
+});
+/**
+* The site of a call is not the site of this deployment. v0.1 serves one site, and the message
+* and the fix both say which, for a caller that only gets one of them.
+*/
+function wrongSite(served) {
+	return new HollwareError("invalid_input", `This Hollware serves the site "${served}", not the one the call names.`, `Pass "${served}", the site this deployment serves, as the site argument.`);
+}
+/**
+* The options object of a call, without the keys that hold `undefined`, so that the handler sees
+* the same input as over MCP. A key that is none of `allowed` is an error: the specs are strict
+* objects so that a misspelled field is not ignored, and a caller that writes `lcoale` would
+* otherwise get every locale. Only the keys of `HollwareRpc` get through, so an input the RPC
+* does not offer, such as the `status` of `list_entries`, can never be set.
+*/
+function readOptions(options, allowed) {
+	if (options === void 0 || options === null) return {};
+	if (typeof options !== "object" || Array.isArray(options)) throw new HollwareError("invalid_input", "The options of the call are not an object.", `Pass an object with only these options: ${allowed.join(", ")}, or none.`);
+	const entries = Object.entries(options);
+	const unknown = entries.map(([key]) => key).filter((key) => !allowed.includes(key));
+	if (unknown.length > 0) throw new HollwareError("invalid_input", `The call has options that Hollware does not know: ${unknown.join(", ")}.`, `Pass only these options: ${allowed.join(", ")}.`);
+	return Object.fromEntries(entries.filter(([, value]) => value !== void 0));
+}
+/**
+* The input of an operation, parsed by its spec: the defaults (`limit`, `formats`) apply and a
+* value that breaks the schema is `invalid_input` that says which.
+*/
+function parseInput(schema, raw) {
+	const parsed = schema.safeParse(raw);
+	if (parsed.success) return parsed.data;
+	const problems = parsed.error.issues.map((issue) => `${issue.path.map(String).join(".")}: ${issue.message}`);
+	throw new HollwareError("invalid_input", `The arguments of the call are not valid. ${problems.join("; ")}.`, "Fix the arguments named above and call again. describeSite lists the collections and locales of the site.");
+}
+/**
+* What a caller gets of a failure: an error it can read and act on, and none of the cause, which
+* an error carries when a handler wraps a failure of D1 or of its own. A `HollwareError` goes as
+* it is, rebuilt without its cause, and anything else is `internal` with the id of the call. What
+* the caller does not get goes to the log, under that id.
+*/
+function forCaller(deps, requestId, method, error) {
+	const known = error instanceof HollwareError ? error : null;
+	if (known === null || known.cause !== void 0) deps.log({
+		kind: "rpc_error",
+		requestId,
+		method,
+		errorCode: known === null ? null : known.code,
+		detail: describeError(error)
+	});
+	if (known === null) return new HollwareError("internal", "The operation failed on the server.", `Try again. If it keeps failing, give the site operator this request id: ${requestId}.`);
+	return new HollwareError(known.code, known.message, known.fix);
+}
+/**
+* One call of an operation over RPC. In this order: the site is the one of this deployment, the
+* input is built and parsed by the spec's schema, and the handler runs with
+*
+* - `view: 'published'`, so a draft is never read, and the principal `{ kind: 'binding', scopes:
+*   ['content:read'] }`, which can read and nothing else;
+* - a store over `env.DB.withSession('first-unconstrained')`: published content, from the nearest
+*   replica, where MCP reads the primary;
+* - the clock, `client: null` (a binding says nothing about itself) and a request id of its own.
+*
+* `build` makes the raw input, so a wrong site is answered before anything else is looked at and
+* a call that fails never opens a session.
+*/
+async function run(deps, env, method, site, schema, build, handler) {
+	if (site !== deps.site.key) throw wrongSite(deps.site.key);
+	const input = parseInput(schema, build());
+	const requestId = crypto.randomUUID();
+	const context = {
+		site: deps.site,
+		principal: BINDING_PRINCIPAL,
+		view: "published",
+		store: createD1Store(env.DB.withSession("first-unconstrained")),
+		clock: deps.clock,
+		client: null,
+		requestId
+	};
+	try {
+		return await handler(input, context);
+	} catch (error) {
+		throw forCaller(deps, requestId, method, error);
+	}
+}
+/**
+* The read-only RPC surface (`HollwareRpc`) over the bindings of one invocation. It is a function
+* and not the entrypoint so that it runs in any test; `entrypoint.ts` is the class that calls it.
+* It has the four methods and nothing that writes, and none of them reaches a handler other than
+* the one that reads.
+*/
+function createRpc(deps, env) {
+	return {
+		getEntry: (site, collection, slug, locale, options) => run(deps, env, "getEntry", site, getEntry.input, () => ({
+			collection,
+			locale,
+			slug,
+			...readOptions(options, ["formats"])
+		}), deps.handlers.get_entry),
+		listEntries: (site, collection, options) => run(deps, env, "listEntries", site, listEntries.input, () => ({
+			collection,
+			...readOptions(options, [
+				"locale",
+				"tag",
+				"limit",
+				"cursor"
+			])
+		}), deps.handlers.list_entries),
+		getTranslations: (site, collection, translationGroup) => run(deps, env, "getTranslations", site, getTranslations.input, () => ({
+			collection,
+			translationGroup
+		}), deps.handlers.get_translations),
+		describeSite: (site) => run(deps, env, "describeSite", site, describeSite.input, () => ({}), deps.handlers.describe_site)
+	};
+}
+//#endregion
+//#region src/rpc/entrypoint.ts
+/**
+* The class a site reaches over a service binding: the user's Worker exports it as
+* `export class Hollware extends hollware.Hollware {}`. It is made here, closed over what the
+* four methods stand on, because that is known only once the config is resolved.
+*
+* It has the four methods of `HollwareRpc` and nothing else, and none of them writes. That is the
+* security surface of the binding: a Worker with a binding can call whatever is on this
+* prototype, so a helper method added here would be public. Anything else lives in `methods.ts`,
+* where `createRpc` does the work and runs in a test without a `WorkerEntrypoint`.
+*/
+function createEntrypoint(deps) {
+	return class Hollware extends WorkerEntrypoint {
+		getEntry(...args) {
+			return createRpc(deps, this.env).getEntry(...args);
+		}
+		listEntries(...args) {
+			return createRpc(deps, this.env).listEntries(...args);
+		}
+		getTranslations(...args) {
+			return createRpc(deps, this.env).getTranslations(...args);
+		}
+		describeSite(...args) {
+			return createRpc(deps, this.env).describeSite(...args);
+		}
+	};
+}
+//#endregion
+//#region src/schedule/run.ts
+/** What the publication of a schedule may do: what `publish` needs, in the scheduler's name. */
+const SCHEDULER_SCOPES = [
+	"content:read",
+	"content:write",
+	"content:publish"
+];
+/**
+* Publishes the scheduled entries whose time has come (ADR-025), one by one, through the same
+* handler as `publish`, in the name of who scheduled each one and with the warnings acknowledged
+* then. An entry that cannot be published (it changed after it was scheduled, or the contracts now
+* block it or warn about something new) goes back to a draft, and the log says why. A failure of
+* the database leaves the schedule for the next run.
+*/
+async function runDueSchedules(input) {
+	const { site, store, handlers, clock, log } = input;
+	const due = await store.dueSchedules(site.key, clock.now().toISOString());
+	let published = 0;
+	let cancelled = 0;
+	for (const schedule of due) {
+		const requestId = `cron_${crypto.randomUUID()}`;
+		const answer = await handlers.publish({
+			id: schedule.entryId,
+			version: schedule.version,
+			acknowledgeWarnings: [...schedule.acknowledged],
+			group: []
+		}, {
+			site,
+			principal: {
+				kind: "token",
+				userId: schedule.actor.userId,
+				tokenId: schedule.actor.tokenId ?? "",
+				site: site.key,
+				scopes: SCHEDULER_SCOPES
+			},
+			view: "head",
+			store,
+			clock,
+			client: schedule.actor.meta,
+			requestId
+		});
+		if (answer.outcome === "published") published += 1;
+		else {
+			await store.cancelSchedule(site.key, schedule.entryId);
+			cancelled += 1;
+		}
+		log({
+			kind: "schedule",
+			requestId,
+			entryId: schedule.entryId,
+			scheduledAt: schedule.scheduledAt,
+			outcome: answer.outcome
+		});
+	}
+	return {
+		published,
+		cancelled
+	};
+}
+//#endregion
+//#region src/compose.ts
+const systemClock = { now: () => /* @__PURE__ */ new Date() };
+/** What the MCP endpoint calls the server, in `server/discover` and `initialize`. */
+const SERVER_INFO = {
+	name: "hollware",
+	title: "Hollware",
+	version
+};
+/** One JSON line per entry, so that Workers Logs indexes its fields. */
+function writeLog(entry) {
+	console.log(JSON.stringify(entry));
+}
+/**
+* Builds the Worker from the config and the handlers of the operations (WP9). `createHollware`
+* is this with the real handlers.
+*
+* Everything that can be built once is built here, when the user's module loads, and never again:
+*
+* - the config is resolved with `resolveConfig`, so a broken `hollware.config.ts` throws its
+*   `ConfigError` here, and the Worker fails at startup with a message that says what to change.
+*   v0.1 serves the one site of the config;
+* - the MCP endpoint, whose tool schemas are converted once, and the Hono app of the gateway,
+*   which is `fetch`: MCP at `/mcp` behind the guard and the token check, and the other routes
+*   (`http/gateway.ts`);
+* - the `Hollware` class for the user's Worker to export, the read-only RPC surface
+*   (`rpc/entrypoint.ts`).
+*
+* Both surfaces run the same handlers on a store of their own: MCP on the primary database, RPC
+* on a replica session and the published view. Every log line, those of the MCP endpoint
+* included, is one JSON line written with `console.log`.
+*/
+function createHollwareWith(config, handlers, options = {}) {
+	const [site] = resolveConfig(config).sites.values();
+	if (site === void 0) throw new Error("The resolved config has no site, which resolveConfig never lets through");
+	const clock = options.clock ?? systemClock;
+	const mcp = createMcpEndpoint({
+		handlers,
+		serverInfo: SERVER_INFO,
+		log: writeLog
+	});
+	const deliveryDeps = (env) => ({
+		db: connect(env.DB),
+		site,
+		clock,
+		fetch: (request) => fetch(request),
+		secret: (name) => {
+			const value = Reflect.get(env, name);
+			return typeof value === "string" ? value : void 0;
+		}
+	});
+	return {
+		fetch: createGateway({
+			site,
+			mcp,
+			clock,
+			log: writeLog,
+			read: (env) => createRpc({
+				site,
+				handlers,
+				clock,
+				log: writeLog
+			}, env)
+		}),
+		scheduled: async (_controller, env, ctx) => {
+			const deps = deliveryDeps(env);
+			ctx.waitUntil(runDueSchedules({
+				site,
+				store: createD1Store(env.DB, { clock }),
+				handlers,
+				clock,
+				log: writeLog
+			}).then(() => sweepOutbox({
+				queue: env.EVENTS,
+				deps
+			})).then(() => void 0, (error) => {
+				writeLog({
+					kind: "cron_failed",
+					message: String(error)
+				});
+			}));
+		},
+		queue: async (batch, env) => {
+			await consumeEvents(batch.messages, deliveryDeps(env));
+		},
+		Hollware: createEntrypoint({
+			site,
+			handlers,
+			clock,
+			log: writeLog
+		})
+	};
+}
+//#endregion
+//#region src/ops/errors.ts
+/**
+* The error of something that must never happen: a bug of Hollware, not a mistake of the caller.
+* Like the `internal` error of the adapters, its message says nothing about the cause, which goes
+* to the log through `cause`, and its fix names the request id the operator finds the log line by.
+*/
+function internalError(context, cause) {
+	return new HollwareError("internal", "The operation failed on the server.", `Try again. If it keeps failing, give the site operator this request id: ${context.requestId}.`, { cause: new Error(cause) });
+}
+/**
+* The error for an answer of the store that the call it came from can never get: an entry that
+* is created cannot conflict, a publish has no slug to take. It is a bug, not an outcome of the
+* operation, so it is not one of the outcomes of its spec.
+*/
+function unexpectedAnswer(context, call, answer) {
+	return internalError(context, `The store answered ${answer.outcome} to ${call}, which it never does.`);
+}
+//#endregion
+//#region src/ops/actor.ts
+/**
+* Who a write is made by: the token of the call, with what its client said about itself. Only a
+* personal token writes (ADR-019). The adapters check the scopes of the operation before any
+* handler runs and never route a write for another principal, so reaching one with a principal
+* that is not a token is a bug, answered as `internal` before anything is read or written.
+*/
+function actorOf(context) {
+	const { principal } = context;
+	if (principal.kind !== "token") throw internalError(context, `A write was routed for a principal of kind ${principal.kind}; only a token writes.`);
+	return {
+		kind: "token",
+		userId: principal.userId,
+		tokenId: principal.tokenId,
+		meta: context.client
+	};
+}
+//#endregion
+//#region src/ops/answers.ts
+/**
+* The summary of an entry, from a listing (`EntrySummaryView`) or from a read of one entry
+* (`EntryView`, which has all of the summary's fields and more). `hasUnpublishedChanges` says
+* whether the latest revision differs from the one that is live, so an entry that was never
+* published always has them.
+*/
+function entrySummary(view) {
+	const { entry, revision } = view;
+	return {
+		id: entry.id,
+		collection: entry.collection,
+		locale: entry.locale,
+		slug: entry.slug,
+		translationGroup: entry.translationGroup,
+		status: entry.status,
+		version: entry.version,
+		frontmatter: revision.frontmatter,
+		tags: [...revision.tags],
+		hasUnpublishedChanges: entry.publishedRevision !== entry.headRevision,
+		publishedAt: entry.publishedAt,
+		updatedAt: entry.updatedAt
+	};
+}
+/** A verdict as an output: the same facts, in arrays that the caller may own. */
+function verdictView(verdict) {
+	return {
+		ok: verdict.ok,
+		phase: verdict.phase,
+		errors: [...verdict.errors],
+		warnings: [...verdict.warnings],
+		contractsHash: verdict.contractsHash
+	};
+}
+/**
+* The verdict of a refusal: the violations of the pipeline, or of a write that the store turned
+* down, in the phase of the operation. No contract ran, and the empty hash says so: a hash names
+* the rules a verdict answers to, and this one answers to none.
+*/
+function refusalVerdict(phase, violations) {
+	return {
+		ok: false,
+		phase,
+		errors: [...violations],
+		warnings: [],
+		contractsHash: ""
+	};
+}
+/** What `conflict` carries: the version the entry is at now, and its latest revision. */
+function conflictAt(currentVersion, headRevision) {
+	return {
+		currentVersion,
+		headRevision
+	};
+}
+/**
+* The violation of a write that the store turned down because of what is stored: another entry
+* holds its slug or its translation, or its row would be over the limit of D1. These are the
+* refusals that make a write `refused`; the store never answers `taken` to a collection that has
+* no translations, since its entries have no group.
+*/
+function violationOf(refusal, collection) {
+	if (refusal.outcome === "too_large") return sizeLimitViolation(refusal.bytes, refusal.limit);
+	if (refusal.field === "slug") return uniqueSlugViolation(refusal.by);
+	const field = collection.translationGroupField;
+	if (field === null) throw new Error(`The store said that a translation group is taken in the collection ${collection.name}, which has no translations`);
+	return uniqueTranslationViolation(refusal.by, field);
+}
+/**
+* The last publication of an entry as `get_entry` shows it: the latest one when it is a publish,
+* and nothing when the entry was unpublished since, or never published.
+*/
+function publicationView(publication) {
+	if (publication === null || publication.action !== "publish") return null;
+	if (publication.revisionId === null || publication.verdict === null) throw new Error(`The publication ${publication.id} is a publish with no revision or verdict`);
+	return {
+		revision: publication.revisionId,
+		verdict: verdictView(publication.verdict),
+		acknowledged: publication.acknowledged.map(({ contract, path }) => ({
+			contract,
+			path
+		})),
+		at: publication.createdAt
+	};
+}
+//#endregion
+//#region src/ops/collections.ts
+/**
+* Which collection and locale a call names, checked against the config of the site before
+* anything else is done with it. The fixes list what the site has, so that an agent that guessed
+* a name has the right one in the answer.
+*/
+/** The longest name an error repeats: a caller could send any string. */
+const NAME_LIMIT = 60;
+/** A name the caller sent, as an error shows it: in JSON quotes, so on one line, and cut when it is long. */
+function shown(name) {
+	if (name.length <= NAME_LIMIT) return JSON.stringify(name);
+	const head = name.slice(0, NAME_LIMIT);
+	const last = head.charCodeAt(59);
+	return JSON.stringify(`${last >= 55296 && last <= 56319 ? head.slice(0, -1) : head}…`);
+}
+/** The collection of the site with that name, or `unknown_collection` listing the ones it has. */
+function requireCollection(site, name) {
+	const collection = site.collections.get(name);
+	if (collection !== void 0) return collection;
+	throw new HollwareError("unknown_collection", `The site has no collection ${shown(name)}.`, `Use one of its collections: ${[...site.collections.keys()].join(", ")}. describe_site lists them with their schemas.`);
+}
+/** Whether the site has the locale, or `unknown_locale` listing the ones it has. */
+function requireLocale(site, locale) {
+	if (site.locales.includes(locale)) return;
+	throw new HollwareError("unknown_locale", `The site has no locale ${shown(locale)}.`, `Use one of its locales: ${site.locales.join(", ")}.`);
+}
+/**
+* The collection of an entry that is stored. The caller named the entry by its id, so a
+* collection that is gone from the config is no mistake of the caller: the entry and its
+* revisions are kept, and whoever maintains the config can declare the collection again. Without
+* it nothing can be checked, so the entry cannot be written or published until then.
+*/
+function collectionOfEntry(site, entry) {
+	const collection = site.collections.get(entry.collection);
+	if (collection !== void 0) return collection;
+	throw new HollwareError("unknown_collection", `The entry ${entry.id} belongs to the collection ${shown(entry.collection)}, which the config of the site no longer declares.`, `Ask whoever maintains hollware.config.ts to declare the collection ${shown(entry.collection)} again: the entry and its revisions are kept.`);
+}
+//#endregion
+//#region src/ops/draft.ts
+/**
+* What the operations that take Markdown share: running the pipeline and the contracts of a
+* collection on it, and reading from the frontmatter that the pipeline returned the fields that
+* the store keeps beside the revision.
+*/
+/**
+* What the pipeline needs of a site and a collection: the components the collection allows, the
+* largest file it accepts, and the routes of every collection of the site, by collection name, so
+* that a link to another collection's entry is recognized.
+*/
+function optionsFor(site, collection) {
+	return {
+		components: [...collection.components.keys()],
+		maxMarkdownBytes: collection.maxMarkdownBytes,
+		routes: Object.fromEntries([...site.collections].map(([name, other]) => [name, other.routes]))
+	};
+}
+/** Runs the Markdown pipeline on a file for a collection. It never throws; see `processMarkdown`. */
+function processFor(site, collection, markdown) {
+	return processMarkdown(markdown, optionsFor(site, collection));
+}
+/**
+* Runs the contracts of a collection on a file the pipeline accepted. `write` is what a draft is
+* saved under; `publish` is what `validate` and `publish` check, with every contract of the
+* collection, against the other entries of the site as they are now.
+*/
+function judge(context, collection, target, markdown, phase, entries = context.store.lookup(context.site.key)) {
+	return runContracts({
+		site: context.site,
+		collection,
+		locale: target.locale,
+		slug: target.slug,
+		entryId: target.entryId,
+		phase,
+		markdown,
+		entries
+	});
+}
+/**
+* The key that the translations of an entry share: the value of the field that the collection
+* names, when it is a string. An empty string is no key: `get_translations` never takes one, and
+* the `translation-pair` contract reads it as a missing group, so it is stored as none, which
+* also keeps two drafts with an empty group from refusing one another.
+*/
+function translationGroupOf(collection, frontmatter) {
+	const field = collection.translationGroupField;
+	const value = field === null ? void 0 : frontmatter[field];
+	return typeof value === "string" && value !== "" ? value : null;
+}
+/** The tags of an entry: the value of the field that the collection names, when it is a list of strings. */
+function tagsOf(collection, frontmatter) {
+	const field = collection.tagsField;
+	const value = field === null ? void 0 : frontmatter[field];
+	return Array.isArray(value) && value.every((tag) => typeof tag === "string") ? value : [];
+}
+/** What orders the entry in published listings: the value of the sorting field, when it is a string. */
+function sortKeyOf(collection, frontmatter) {
+	const field = collection.sortByField;
+	const value = field === null ? void 0 : frontmatter[field];
+	return typeof value === "string" ? value : null;
+}
+/**
+* The revision to store for a file. The Markdown is exactly the file the caller sent: its bytes
+* are the source of truth, and everything else is derived from them (ADR-001).
+*/
+function revisionOf(input) {
+	const { processed } = input;
+	return {
+		markdown: input.markdown,
+		frontmatter: processed.frontmatter,
+		document: processed.document,
+		comarkVersion: processed.comarkVersion,
+		pipelineVersion: processed.pipelineVersion,
+		wordCount: processed.extracted.words,
+		verdict: input.verdict,
+		tags: tagsOf(input.collection, processed.frontmatter),
+		actor: input.actor
+	};
+}
+//#endregion
+//#region src/ops/create-draft.ts
+/**
+* Creates an entry at version 1 from a Markdown file. A file the pipeline cannot store is
+* `refused`; any other problem, a contract error included, is saved with the draft in its verdict
+* and only blocks publishing (ADR-004). The store refuses a slug or a translation that another
+* entry holds, and a row over the limit of D1, and those are `refused` too.
+*/
+const createDraft = async (input, context) => {
+	const collection = requireCollection(context.site, input.collection);
+	requireLocale(context.site, input.locale);
+	const actor = actorOf(context);
+	const processed = await processFor(context.site, collection, input.markdown);
+	if (!processed.ok) return {
+		outcome: "refused",
+		verdict: refusalVerdict("write", processed.violations)
+	};
+	const verdict = await judge(context, collection, {
+		locale: input.locale,
+		slug: input.slug,
+		entryId: null
+	}, processed.value, "write");
+	const written = await context.store.createEntry(context.site.key, {
+		collection: input.collection,
+		locale: input.locale,
+		slug: input.slug,
+		translationGroup: translationGroupOf(collection, processed.value.frontmatter),
+		revision: revisionOf({
+			markdown: input.markdown,
+			processed: processed.value,
+			collection,
+			verdict,
+			actor
+		})
+	});
+	switch (written.outcome) {
+		case "saved": return {
+			outcome: "saved",
+			entry: entrySummary(written.view),
+			verdict: verdictView(verdict)
+		};
+		case "taken":
+		case "too_large": return {
+			outcome: "refused",
+			verdict: refusalVerdict("write", [violationOf(written, collection)])
+		};
+		case "conflict":
+		case "not_found": throw unexpectedAnswer(context, "createEntry", written);
+	}
+};
+//#endregion
+//#region src/ops/describe-site.ts
+/**
+* The always-on contracts as every collection lists them, described once for the isolate:
+* `describeResolvedSite` memoizes a site's description by the array it is given, so passing this
+* same array on every call is what makes the schemas convert once and not on every request.
+*/
+const builtInContracts = describeBuiltInContracts();
+/** Describes the site the call is for: what an agent reads before it writes. */
+const describeSite$1 = async (_input, context) => ({
+	outcome: "ok",
+	site: describeResolvedSite(context.site, { builtInContracts })
+});
+//#endregion
+//#region src/ops/get-entry.ts
+/**
+* Reads an entry in the view of the call, `head` over MCP and `published` over RPC, with only the
+* formats that were asked for.
+*/
+const getEntry$1 = async (input, context) => {
+	requireCollection(context.site, input.collection);
+	requireLocale(context.site, input.locale);
+	const found = await context.store.findEntry(context.site.key, {
+		collection: input.collection,
+		locale: input.locale,
+		slug: input.slug
+	}, context.view);
+	if (found === null) return { outcome: "not_found" };
+	const { entry, revision } = found;
+	const publication = await context.store.lastPublication(context.site.key, entry.id);
+	return {
+		outcome: "ok",
+		entry: {
+			...entrySummary(found),
+			revision: revision.id,
+			verdict: verdictView(revision.verdict),
+			lastPublication: publicationView(publication),
+			...input.formats.includes("markdown") ? { markdown: revision.markdown } : {},
+			...input.formats.includes("document") ? { document: revision.document } : {},
+			...input.formats.includes("html") ? { html: await renderHtml(revision.document) } : {}
+		}
+	};
+};
+//#endregion
+//#region src/ops/get-translations.ts
+/** Reads the entries of a translation group in the view of the call, one per locale. */
+const getTranslations$1 = async (input, context) => {
+	const collection = requireCollection(context.site, input.collection);
+	if (collection.translationGroupField === null) throw new HollwareError("invalid_input", `The collection ${JSON.stringify(collection.name)} has no translations, so its entries belong to no translation group.`, "describe_site shows translationGroupField as null for this collection: read its entries with get_entry or list_entries instead.");
+	const group = await context.store.listTranslations(context.site.key, input.collection, input.translationGroup, context.view);
+	if (group.length === 0) return { outcome: "not_found" };
+	return {
+		outcome: "ok",
+		entries: group.map(entrySummary)
+	};
+};
+//#endregion
+//#region src/ops/list-entries.ts
+/** Lists a page of the entries of a collection, in the view of the call. */
+const listEntries$1 = async (input, context) => {
+	requireCollection(context.site, input.collection);
+	if (input.locale !== void 0) requireLocale(context.site, input.locale);
+	const page = await context.store.listEntries(context.site.key, {
+		collection: input.collection,
+		locale: input.locale,
+		tag: input.tag,
+		status: input.status,
+		view: context.view,
+		limit: input.limit,
+		cursor: input.cursor
+	});
+	return {
+		outcome: "ok",
+		entries: page.entries.map(entrySummary),
+		nextCursor: page.nextCursor
+	};
+};
+//#endregion
+//#region src/ops/event.ts
+/** The path of an entry: the route of its locale, with its slug in place of `:slug`. */
+function entryPath(collection, locale, slug) {
+	const route = collection.routes[locale];
+	return route === void 0 ? null : route.replace(/:slug(?![A-Za-z0-9_])/, slug);
+}
+/** The event of a publish or an unpublish, ready for the outbox. */
+function eventFor(input) {
+	const id = newId("evt");
+	const path = entryPath(input.collection, input.entry.locale, input.entry.slug);
+	const payload = {
+		id,
+		kind: input.kind,
+		site: input.site.key,
+		at: input.at,
+		entry: input.entry,
+		path,
+		url: path === null || input.site.url === null ? null : `${input.site.url}${path}`
+	};
+	return {
+		id,
+		payload: JSON.stringify(payload)
+	};
+}
+//#endregion
+//#region src/ops/publish.ts
+/** A warning by what an acknowledgement names: its contract and its path, never its line. */
+function warningKey(warning) {
+	return JSON.stringify([warning.contract, warning.path]);
+}
+/**
+* Publishes the latest revision of an entry, if it is still at the version the caller read. The
+* contracts run again, in the publish phase, because the rules and the other entries may have
+* changed since the draft was saved: an error blocks, and a warning has to be acknowledged, by
+* contract and path, before the publication is made. The publication records every warning of its
+* verdict as acknowledged (ADR-021).
+*/
+const publish$1 = async (input, context) => {
+	if (input.group.length > 0) return publishGroup(input, context);
+	const actor = actorOf(context);
+	const found = await context.store.findEntryById(context.site.key, input.id, "head");
+	if (found === null) return { outcome: "not_found" };
+	const { entry, revision } = found;
+	const collection = collectionOfEntry(context.site, entry);
+	if (entry.version !== input.version) return {
+		outcome: "conflict",
+		conflict: conflictAt(entry.version, entry.headRevision)
+	};
+	const summary = entrySummary(found);
+	const processed = await processFor(context.site, collection, revision.markdown);
+	if (!processed.ok) return {
+		outcome: "blocked",
+		entry: summary,
+		verdict: refusalVerdict("publish", processed.violations)
+	};
+	const verdict = await judge(context, collection, {
+		locale: entry.locale,
+		slug: entry.slug,
+		entryId: entry.id
+	}, processed.value, "publish");
+	if (!verdict.ok) return {
+		outcome: "blocked",
+		entry: summary,
+		verdict: verdictView(verdict)
+	};
+	const acknowledged = new Set(input.acknowledgeWarnings.map(warningKey));
+	if (verdict.warnings.some((warning) => !acknowledged.has(warningKey(warning)))) return {
+		outcome: "needs_acknowledgement",
+		entry: summary,
+		verdict: verdictView(verdict)
+	};
+	const acknowledgedWarnings = verdict.warnings.map(({ contract, path }) => ({
+		contract,
+		path
+	}));
+	if (input.publishAt !== void 0 && Date.parse(input.publishAt) > context.clock.now().getTime()) {
+		if (entry.status === "published") throw new HollwareError("invalid_input", "The entry is published, so its publication cannot be scheduled.", "Publish its changes now, without publishAt, or unpublish it first and then schedule it.");
+		const scheduled = await context.store.schedule(context.site.key, {
+			entryId: entry.id,
+			expectedVersion: input.version,
+			scheduledAt: new Date(input.publishAt).toISOString(),
+			acknowledged: acknowledgedWarnings,
+			actor
+		});
+		switch (scheduled.outcome) {
+			case "scheduled": return {
+				outcome: "scheduled",
+				entry: entrySummary(scheduled.view),
+				verdict: verdictView(verdict)
+			};
+			case "conflict": return {
+				outcome: "conflict",
+				conflict: conflictAt(scheduled.currentVersion, scheduled.headRevision)
+			};
+			case "not_found": return { outcome: "not_found" };
+			default: throw unexpectedAnswer(context, "publish", scheduled);
+		}
+	}
+	const event = eventFor({
+		kind: "entry.published",
+		site: context.site,
+		collection,
+		entry: {
+			id: entry.id,
+			collection: entry.collection,
+			locale: entry.locale,
+			slug: entry.slug,
+			translationGroup: entry.translationGroup
+		},
+		at: context.clock.now().toISOString()
+	});
+	const written = await context.store.publish(context.site.key, {
+		event,
+		entryId: entry.id,
+		expectedVersion: input.version,
+		verdict,
+		acknowledged: verdict.warnings.map(({ contract, path }) => ({
+			contract,
+			path
+		})),
+		actor,
+		sortKey: sortKeyOf(collection, processed.value.frontmatter) ?? entry.publishedAt ?? context.clock.now().toISOString()
+	});
+	switch (written.outcome) {
+		case "published":
+			context.notify?.([event.id]);
+			return {
+				outcome: "published",
+				entry: entrySummary(written.view),
+				verdict: verdictView(verdict)
+			};
+		case "conflict": return {
+			outcome: "conflict",
+			conflict: conflictAt(written.currentVersion, written.headRevision)
+		};
+		case "not_found": return { outcome: "not_found" };
+		case "too_large": return {
+			outcome: "blocked",
+			entry: summary,
+			verdict: refusalVerdict("publish", [violationOf(written, collection)])
+		};
+		case "taken": throw unexpectedAnswer(context, "publish", written);
+	}
+};
+/** The lookup of the contracts, with the entries of a group seen as published (ADR-024). */
+function asPublished(lookup, ids) {
+	return {
+		lookupMany: async (refs) => (await lookup.lookupMany(refs)).map((facts) => facts !== null && ids.has(facts.id) ? {
+			...facts,
+			status: "published"
+		} : facts),
+		translations: (collection, group) => lookup.translations(collection, group)
+	};
+}
+/**
+* Publishes an entry and the entries of its group in one step, all or none (ADR-024). Each entry
+* is checked as `publish` checks one, except that the contracts see every entry of the group as
+* published, so links between them resolve. The first entry that stops the group is named in
+* `failedEntry`. An acknowledgement, by contract and path, holds for every entry that reports
+* that warning, and each publication records its own warnings.
+*/
+async function publishGroup(input, context) {
+	if (input.publishAt !== void 0) throw new HollwareError("invalid_input", "A group cannot be scheduled: publishAt schedules one entry.", "Publish the group now, without publishAt, or schedule its entries one by one.");
+	const actor = actorOf(context);
+	const members = [{
+		id: input.id,
+		version: input.version
+	}, ...input.group].filter((member, index, all) => all.findIndex((other) => other.id === member.id) === index);
+	const lookup = asPublished(context.store.lookup(context.site.key), new Set(members.map((member) => member.id)));
+	const checked = [];
+	for (const member of members) {
+		const found = await context.store.findEntryById(context.site.key, member.id, "head");
+		if (found === null) return {
+			outcome: "not_found",
+			failedEntry: member.id
+		};
+		const { entry, revision } = found;
+		if (entry.version !== member.version) return {
+			outcome: "conflict",
+			conflict: conflictAt(entry.version, entry.headRevision),
+			failedEntry: member.id
+		};
+		const collection = collectionOfEntry(context.site, entry);
+		const summary = entrySummary(found);
+		const processed = await processFor(context.site, collection, revision.markdown);
+		if (!processed.ok) return {
+			outcome: "blocked",
+			entry: summary,
+			verdict: refusalVerdict("publish", processed.violations),
+			failedEntry: member.id
+		};
+		const verdict = await judge(context, collection, {
+			locale: entry.locale,
+			slug: entry.slug,
+			entryId: entry.id
+		}, processed.value, "publish", lookup);
+		if (!verdict.ok) return {
+			outcome: "blocked",
+			entry: summary,
+			verdict: verdictView(verdict),
+			failedEntry: member.id
+		};
+		checked.push({
+			summary,
+			collection,
+			verdict,
+			write: {
+				event: eventFor({
+					kind: "entry.published",
+					site: context.site,
+					collection,
+					entry: {
+						id: entry.id,
+						collection: entry.collection,
+						locale: entry.locale,
+						slug: entry.slug,
+						translationGroup: entry.translationGroup
+					},
+					at: context.clock.now().toISOString()
+				}),
+				entryId: entry.id,
+				expectedVersion: member.version,
+				verdict,
+				acknowledged: verdict.warnings.map(({ contract, path }) => ({
+					contract,
+					path
+				})),
+				actor,
+				sortKey: sortKeyOf(collection, processed.value.frontmatter) ?? entry.publishedAt ?? context.clock.now().toISOString()
+			}
+		});
+	}
+	const [main] = checked;
+	if (main === void 0) throw unexpectedAnswer(context, "publish", { outcome: "empty group" });
+	const warnings = new Map(checked.flatMap(({ verdict }) => verdict.warnings).map((warning) => [warningKey(warning), warning]));
+	const acknowledged = new Set(input.acknowledgeWarnings.map(warningKey));
+	if ([...warnings.keys()].some((key) => !acknowledged.has(key))) return {
+		outcome: "needs_acknowledgement",
+		entry: main.summary,
+		verdict: verdictView({
+			...main.verdict,
+			warnings: [...warnings.values()]
+		})
+	};
+	const written = await context.store.publishGroup(context.site.key, checked.map(({ write }) => write));
+	switch (written.outcome) {
+		case "published": {
+			const [view] = written.views;
+			if (view === void 0) throw unexpectedAnswer(context, "publish", written);
+			context.notify?.(checked.flatMap(({ write }) => write.event ? [write.event.id] : []));
+			return {
+				outcome: "published",
+				entry: entrySummary(view),
+				verdict: verdictView(main.verdict)
+			};
+		}
+		case "conflict": return {
+			outcome: "conflict",
+			conflict: conflictAt(written.currentVersion, written.headRevision),
+			failedEntry: written.entryId
+		};
+		case "not_found": return {
+			outcome: "not_found",
+			failedEntry: written.entryId
+		};
+		case "too_large": {
+			const failed = checked.find(({ write }) => write.entryId === written.entryId) ?? main;
+			return {
+				outcome: "blocked",
+				entry: failed.summary,
+				verdict: refusalVerdict("publish", [violationOf(written, failed.collection)]),
+				failedEntry: written.entryId
+			};
+		}
+		case "taken": throw unexpectedAnswer(context, "publish", written);
+	}
+}
+//#endregion
+//#region src/ops/unpublish.ts
+/**
+* Takes an entry off the public site and keeps it, with its revisions, as a draft. The store
+* leaves an entry that is not published as it is.
+*/
+const unpublish = async (input, context) => {
+	const actor = actorOf(context);
+	const found = await context.store.findEntryById(context.site.key, input.id, "head");
+	if (found === null) return { outcome: "not_found" };
+	const { entry } = found;
+	const event = eventFor({
+		kind: "entry.unpublished",
+		site: context.site,
+		collection: collectionOfEntry(context.site, entry),
+		entry: {
+			id: entry.id,
+			collection: entry.collection,
+			locale: entry.locale,
+			slug: entry.slug,
+			translationGroup: entry.translationGroup
+		},
+		at: context.clock.now().toISOString()
+	});
+	const written = await context.store.unpublish(context.site.key, {
+		entryId: input.id,
+		actor,
+		event
+	});
+	switch (written.outcome) {
+		case "unpublished":
+			if (entry.status === "published") context.notify?.([event.id]);
+			return {
+				outcome: "unpublished",
+				entry: entrySummary(written.view)
+			};
+		case "not_found": return { outcome: "not_found" };
+		case "conflict":
+		case "taken":
+		case "too_large": throw unexpectedAnswer(context, "unpublish", written);
+	}
+};
+//#endregion
+//#region src/ops/update-draft.ts
+/**
+* Saves a new revision of an entry, if it is still at the version the caller read. The version is
+* checked before anything else, so that a caller that is behind learns where the entry is now and
+* is not told what its file would have been. The file that the head already holds is `unchanged`:
+* no revision and no version, which is what makes importing the same files twice a no-op.
+*/
+const updateDraft = async (input, context) => {
+	const actor = actorOf(context);
+	const found = await context.store.findEntryById(context.site.key, input.id, "head");
+	if (found === null) return { outcome: "not_found" };
+	const { entry, revision } = found;
+	const collection = collectionOfEntry(context.site, entry);
+	if (entry.version !== input.version) return {
+		outcome: "conflict",
+		conflict: conflictAt(entry.version, entry.headRevision)
+	};
+	if (input.markdown === revision.markdown) return {
+		outcome: "unchanged",
+		entry: entrySummary(found),
+		verdict: verdictView(revision.verdict)
+	};
+	const processed = await processFor(context.site, collection, input.markdown);
+	if (!processed.ok) return {
+		outcome: "refused",
+		verdict: refusalVerdict("write", processed.violations)
+	};
+	const verdict = await judge(context, collection, {
+		locale: entry.locale,
+		slug: entry.slug,
+		entryId: entry.id
+	}, processed.value, "write");
+	const written = await context.store.appendRevision(context.site.key, {
+		entryId: entry.id,
+		expectedVersion: input.version,
+		translationGroup: translationGroupOf(collection, processed.value.frontmatter),
+		revision: revisionOf({
+			markdown: input.markdown,
+			processed: processed.value,
+			collection,
+			verdict,
+			actor
+		})
+	});
+	switch (written.outcome) {
+		case "saved": return {
+			outcome: "saved",
+			entry: entrySummary(written.view),
+			verdict: verdictView(verdict)
+		};
+		case "conflict": return {
+			outcome: "conflict",
+			conflict: conflictAt(written.currentVersion, written.headRevision)
+		};
+		case "not_found": return { outcome: "not_found" };
+		case "taken":
+		case "too_large": return {
+			outcome: "refused",
+			verdict: refusalVerdict("write", [violationOf(written, collection)])
+		};
+	}
+};
+//#endregion
+//#region src/ops/validate.ts
+/** Checks a file as `publish` would, and writes nothing: not even when the entry does not exist. */
+const validate = async (input, context) => {
+	const collection = requireCollection(context.site, input.collection);
+	requireLocale(context.site, input.locale);
+	const processed = await processFor(context.site, collection, input.markdown);
+	if (!processed.ok) return {
+		outcome: "ok",
+		verdict: refusalVerdict("publish", processed.violations)
+	};
+	const existing = await context.store.findEntry(context.site.key, {
+		collection: input.collection,
+		locale: input.locale,
+		slug: input.slug
+	}, "head");
+	return {
+		outcome: "ok",
+		verdict: verdictView(await judge(context, collection, {
+			locale: input.locale,
+			slug: input.slug,
+			entryId: existing?.entry.id ?? null
+		}, processed.value, "publish"))
+	};
+};
+//#endregion
+//#region src/ops/types.ts
+/** Declares the handlers; the type checks that they pair with the specs one to one. */
+function defineHandlers(handlers) {
+	return handlers;
+}
+//#endregion
+//#region src/ops/index.ts
+/**
+* The handler of every operation of v0.1, paired with its spec of `@hollware/core` by type
+* (ADR-017). Adapters check the scopes and build the `OperationContext`; a handler never sees a
+* request, and reads and writes only the site of its context.
+*/
+const handlers = defineHandlers({
+	create_draft: createDraft,
+	describe_site: describeSite$1,
+	get_entry: getEntry$1,
+	get_translations: getTranslations$1,
+	list_entries: listEntries$1,
+	publish: publish$1,
+	unpublish,
+	update_draft: updateDraft,
+	validate
+});
+//#endregion
 //#region src/index.ts
 const name = "@hollware/server";
+/**
+* Builds the Worker from the config: `const hollware = createHollware(config)`, then
+* `export default { fetch: hollware.fetch }` and `export class Hollware extends hollware.Hollware {}`.
+* The config is resolved once, here; a broken one throws its `ConfigError`.
+*/
+const createHollware = (config) => createHollwareWith(config, handlers);
 //#endregion
-export { name };
+export { MAX_BOUND_PARAMETERS, MAX_ROW_BYTES, OPERATION_TIMEOUT_MS, OUTPUT_CAP_BYTES, createHollware, defineHandlers, name };