@phtngyn/cms 0.1.0-beta.1 → 0.1.0-beta.3

package/src/{installation-DeuBiFRE.js → installation-CNfIriVm.js}

@@ -1,31 +1,31 @@
-import { c as STUDIO_API_PATH, d as STUDIO_COLLABORATION_PATH, i as CMS_LIVENESS_PATH, s as CMS_READINESS_PATH, t as CMS_AUTHENTICATION_PATH } from "./HttpPaths-BbS21Jy8.js";
-import { $ as MediaName, A as RemoveDocumentInput, B as StudioActor, C as MarkdownNode, Ct as Slug, D as PublishedDocumentPage, F as AccessDenied, G as MediaByteSize, H as StudioRequestContext, I as AuthenticationRequired, J as MediaCursor, K as MediaCleanupReport, L as DOCUMENT_ACTIONS, M as UndeleteDocumentInput, N as UnpublishDocumentInput, P as UpdateDocumentInput, Q as MediaInvalid, R as MEDIA_ACTIONS, S as DuplicateDocumentInput, T as PublishDocumentInput, U as ImageMimeType, V as StudioEntryDenied, W as MediaAsset, X as MediaId, Y as MediaFolder, Z as MediaIntegrityReport, _ as DocumentSource, _t as DocumentVersion, a as DOCUMENT_REVISION_ACTIONS, at as MediaReferenced, b as DocumentSurround, bt as RelativeDocumentPath, c as DocumentImportInput, ct as MediaUpload, et as MediaNotFound, f as DocumentMutationResult, g as DocumentRevisionAction, gt as DocumentId, h as DocumentQueryScalar, ht as DocumentHistoryCursor, it as MediaReference, j as RestoreDocumentInput, l as DocumentImportReport, mt as DocumentGeneration, n as CmsMarkdownDocument, nt as MediaPage, o as DeletedDocument, ot as MediaStatus, p as DocumentNavigationItem, pt as RequestId, q as MediaConflict, st as MediaTooLarge, tt as MediaObjectKey, vt as EditorNodeId, w as MoveDocumentInput, wt as SourcePath, x as DocumentValidationResult, xt as RevisionId, y as DocumentSummary, yt as PublicPath, z as Role } from "./models-BkMgeaOL.js";
-import { a as normalizeDocumentRelativePath, c as resolveDocumentAddress, i as localizeDocumentPath, n as referenceTarget, o as normalizePublicPath, r as DocumentCompilationFailed, s as parseDocumentAddress, t as createDocumentEngine } from "./DocumentEngine-DYObwMDY.js";
-import { A as ACTIVITY_ACTIONS, B as ActivityTargetKind, C as CollaborationTicket, D as DocumentRevision, E as DocumentHistoryInvalidCursor, F as ActivityEntry, G as DocumentVersionConflict, H as DocumentNotFound, I as ActivityEntryDraft, K as PublishedDocumentNotFound, L as ActivityId, M as ActivityContext, N as ActivityCursor, O as DocumentRevisionComparison, P as ActivityCursorInvalid, R as ActivityPage, S as CollaborationServerMessage, T as DocumentHistoryComparisonTooLarge, U as DocumentPathConflict, V as DocumentMediaUnavailable, W as DocumentValidationFailed, _ as UserNotFound, b as UserSelfRoleChangeDenied, c as StudioInternalError, d as InitializationProofInvalid, f as InitializationState, g as UserAlreadyExists, h as UserAdministrationDenied, i as StudioBadRequest, j as ActivityAction, k as DocumentRevisionPage, l as studioInternalError, m as User, n as StudioApi, o as StudioRequestConflict, p as CreateUserInput, r as StudioAuthentication, s as StudioSchemaError, t as CurrentStudioRequest, u as InitializationAlreadyCompleted, v as UserPage, w as StateVector, x as CollaborationClientMessage, y as UserSelfRemovalDenied, z as ActivityTarget } from "./StudioHttp-jR2-bc01.js";
-import { a as createEditorNodeId, c as createCmsComarkRenderData, d as toComarkDocument, i as withoutEditorMetadata, o as editorNodeId, r as identifiedAttributes, t as assertCanonicalEditorContent, u as mutableJsonObject } from "./metadata-DE1Mc2td.js";
-import { C as finiteNumberAttribute, D as projectCmsEditorComponentAttributes, S as compactJsonAttributes, T as encodeCmsEditorComponentAttributes, _ as comarkTagForEditorMark, b as encodeEditorImageAttributes, d as EditorRenderFailed, g as EDITOR_MARK_TYPES, h as comarkToEditor, u as EditorDocumentInvalid, v as isEditorMark, w as nonEmptyStringAttribute, x as normalizeEditorImageLayout, y as EDITOR_IMAGE_LAYOUT_ATTRIBUTE } from "./Configuration-DyKo0sLS.js";
-import { Cause, Clock, Context, Crypto, Data, DateTime, Deferred, Effect, Encoding, Exit, Fiber, Layer, Option, Predicate, PubSub, Pull, Queue, Redacted, Ref, Result, Schedule, Schema, Scope, Semaphore, Stream } from "effect";
+import { a as EditorNodeId, c as RevisionId, d as SourcePath, i as DocumentVersion, r as DocumentId, t as DocumentGeneration } from "./scalars-B2lgGUnj.js";
+import { i as FormResult, n as FORM_SUBMISSION_MAX_BYTES } from "./Forms-CfcI3tPU.js";
+import { a as encodeCmsEditorComponentAttributes, d as createCmsComarkRenderData, i as validateFormValues, t as documentForms } from "./Forms-Dj6NuW66.js";
+import { $ as StudioActor, A as UnpublishDocumentInput, B as SeoMediaUnavailable, D as RemoveDocumentInput, Et as RequestId, H as SeoRevision, J as AccessDenied, K as SeoVersionConflict, O as RestoreDocumentInput, Q as Role, S as PublishDocumentInput, Y as AuthenticationRequired, _t as MediaReference, a as DOCUMENT_REVISION_ACTIONS, at as MediaCleanupReport, b as MarkdownNode, bt as MediaTooLarge, ct as MediaFolder, dt as MediaInvalid, et as StudioEntryDenied, ft as MediaName, ht as MediaPage, it as MediaByteSize, j as UpdateDocumentInput, k as UndeleteDocumentInput, l as DocumentMutationResult, lt as MediaId, m as DocumentSource, mt as MediaObjectKey, n as CmsMarkdownDocument, nt as ImageMimeType, o as DeletedDocument, ot as MediaConflict, p as DocumentRevisionAction, pt as MediaNotFound, rt as MediaAsset, st as MediaCursor, tt as StudioRequestContext, ut as MediaIntegrityReport, vt as MediaReferenced, x as MoveDocumentInput, xt as MediaUpload, y as DuplicateDocumentInput, yt as MediaStatus, z as SeoConfirmationRequired } from "./models-Bah5B3bT.js";
+import { $ as DocumentRevision, A as StudioBadRequest, B as User, C as DocumentStore, D as CurrentStudioRequest, E as defaultAccessControlLayer, F as studioInternalError, G as UserSelfRemovalDenied, H as UserAlreadyExists, I as InitializationAlreadyCompleted, J as CollaborationServerMessage, K as UserSelfRoleChangeDenied, L as InitializationProofInvalid, M as StudioRequestConflict, N as StudioSchemaError, O as StudioApi, P as StudioInternalError, Q as DocumentHistoryInvalidCursor, R as InitializationState, S as DocumentPersistenceError, T as AccessControl, U as UserNotFound, V as UserAdministrationDenied, W as UserPage, X as StateVector, Y as CollaborationTicket, Z as DocumentHistoryComparisonTooLarge, _ as Documents, a as mediaObjectPrefix, at as ActivityEntry, b as cursorCodec, c as Seo, ct as ActivityPage, d as seoDeliveryLayer, dt as DocumentMediaUnavailable, et as ACTIVITY_ACTIONS, f as seoLayer, ft as DocumentNotFound, g as DocumentPreviews, gt as PublishedDocumentNotFound, h as DocumentMaintenance, ht as DocumentVersionConflict, i as MediaObjectStore, it as ActivityCursorInvalid, k as StudioAuthentication, l as SeoDelivery, lt as ActivityTarget, m as SeoStore, mt as DocumentValidationFailed, n as s3MediaObjectStoreLayer, nt as ActivityContext, o as PreviewSeo, ot as ActivityEntryDraft, p as SeoPersistenceError, pt as DocumentPathConflict, q as CollaborationClientMessage, r as MediaPersistenceError, rt as ActivityCursor, s as PublishedSeo, st as ActivityId, tt as ActivityAction, u as makeDefaultSeoOptions, ut as ActivityTargetKind, v as PublishedDocuments, w as renderEditorMarkdown, x as DocumentGenerationConflict, y as documentsLayer, z as CreateUserInput } from "./S3MediaObjects-CpPSzJto.js";
+import { a as CMS_FORM_SUBMIT_PATH, l as CMS_READINESS_PATH, o as CMS_LIVENESS_PATH, p as STUDIO_COLLABORATION_PATH, t as CMS_AUTHENTICATION_PATH, u as STUDIO_API_PATH } from "./HttpPaths-c9nLZ9H2.js";
+import { a as createEditorNodeId, o as editorNodeId, r as identifiedAttributes, t as assertCanonicalEditorContent } from "./metadata-BEZPWh-3.js";
+import { C as finiteNumberAttribute, S as compactJsonAttributes, _ as comarkTagForEditorMark, b as encodeEditorImageAttributes, g as EDITOR_MARK_TYPES, h as comarkToEditor, u as EditorDocumentInvalid, v as isEditorMark, w as nonEmptyStringAttribute, x as normalizeEditorImageLayout, y as EDITOR_IMAGE_LAYOUT_ATTRIBUTE } from "./Configuration-CDMYfTre.js";
+import { o as ContentTransferConflict } from "./ContentTransfer-C3Av9sWz.js";
+import { Cause, Clock, Context, Crypto, Data, DateTime, Deferred, Effect, Encoding, Exit, Fiber, Layer, Option, Predicate, PubSub, Pull, Queue, Redacted, Ref, Result, Schedule, Schema, Scope, Semaphore, Stream, flow } from "effect";
 import { Extension, Node, getSchema, mergeAttributes } from "@tiptap/core";
 import { prosemirrorJSONToYDoc, ySyncPluginKey, yXmlFragmentToProseMirrorRootNode } from "@tiptap/y-tiptap";
-import { NodeStream } from "@effect/platform-node-shared";
-import { HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse, Multipart } from "effect/unstable/http";
+import { FindMyWay, HttpEffect, HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse, Multipart } from "effect/unstable/http";
 import { HttpApiBuilder, HttpApiMiddleware } from "effect/unstable/httpapi";
-import * as NodeCrypto$1 from "@effect/platform-node-shared/NodeCrypto";
+import * as NodeCrypto from "@effect/platform-node-shared/NodeCrypto";
+import { createAuthMiddleware, getSessionFromCtx, isAPIError } from "better-auth/api";
 import { betterAuth } from "better-auth";
 import { createAccessControl } from "better-auth/plugins/access";
 import { admin } from "better-auth/plugins/admin";
 import { defaultStatements } from "better-auth/plugins/admin/access";
-import { APIError, createAuthMiddleware, getSessionFromCtx, isAPIError } from "better-auth/api";
 import { Hocuspocus, IncomingMessage, MessageType, shouldSkipStoreHooks } from "@hocuspocus/server";
-import { renderMarkdown } from "comark/render";
-import { diffArrays } from "diff";
 import StarterKit from "@tiptap/starter-kit";
 import * as Y from "yjs";
 import { Doc, applyUpdate, encodeStateAsUpdate, encodeStateVector } from "yjs";
-import { CopyObjectCommand, CreateBucketCommand, DeleteObjectCommand, HeadBucketCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { RateLimiter } from "effect/unstable/persistence";
 import { PgClient } from "@effect/sql-pg";
 import { isDeepStrictEqual } from "node:util";
-import { and, asc, count, desc, eq, inArray, lt, lte, ne, or, sql } from "drizzle-orm";
+import { and, asc, count, desc, eq, gt, inArray, lt, lte, ne, or, sql } from "drizzle-orm";
 import * as PgDrizzle from "drizzle-orm/effect-postgres";
 import { createInsertSchema, createSelectSchema } from "drizzle-orm/effect-schema";
 import { alias, bigint, boolean, bytea, check, foreignKey, index, integer, jsonb, pgTable, primaryKey, text, timestamp, unique, uniqueIndex, uuid } from "drizzle-orm/pg-core";
@@ -58,50 +58,6 @@ function activityEntryFromDraft(id, draft, occurredAt) {
 	});
 }
 
-//#endregion
-//#region ../server/src/internal/access-control.ts
-const VIEWER_ACTIONS = /* @__PURE__ */ new Set([
-	"document.browse",
-	"document.read",
-	"document.trash",
-	"document.history",
-	"media.read",
-	"media.search",
-	"media.integrity"
-]);
-const EDITOR_ACTIONS = /* @__PURE__ */ new Set([...DOCUMENT_ACTIONS, ...MEDIA_ACTIONS.filter((action) => action !== "media.cleanup")]);
-var AccessControl = class extends Context.Service()("@internal/server/AccessControl") {};
-const defaultAccessControlLayer = Layer.succeed(AccessControl, AccessControl.of({ require: Effect.fn("AccessControl.require")(function* (context, decision) {
-	if (isAllowed(context, decision.action)) return;
-	return yield* new AccessDenied({
-		action: decision.action,
-		actorId: context.actor.id,
-		resource: decision.resource
-	});
-}) }));
-function isAllowed(context, action) {
-	return context.actor.roles.some((role) => {
-		if (role === "administrator") return true;
-		return role === "editor" && EDITOR_ACTIONS.has(action) || role === "viewer" && VIEWER_ACTIONS.has(action);
-	});
-}
-
-//#endregion
-//#region ../server/src/internal/cursor.ts
-/** Owns the opaque base64url JSON representation shared by keyset cursors. */
-function cursorCodec(schema, makeCursor, invalid) {
-	const decodeJson = Schema.decodeUnknownResult(schema);
-	const encodeJson = Schema.encodeSync(schema);
-	return {
-		decode: (cursor) => {
-			const decoded = Encoding.decodeBase64UrlString(cursor);
-			if (Result.isFailure(decoded)) return Result.fail(invalid());
-			return decodeJson(decoded.success).pipe(Result.mapError(invalid));
-		},
-		encode: (payload) => makeCursor(Encoding.encodeBase64Url(encodeJson(payload)))
-	};
-}
-
 //#endregion
 //#region ../server/src/internal/activity/activity.ts
 var ActivityUnavailable = class extends Schema.TaggedError()("Activity.Unavailable", {
@@ -109,11 +65,11 @@ var ActivityUnavailable = class extends Schema.TaggedError()("Activity.Unavailab
 	cause: Schema.Defect()
 }) {};
 var Activity = class extends Context.Service()("@internal/server/Activity") {};
-const CursorPayload$2 = Schema.Struct({
+const CursorPayload$1 = Schema.Struct({
 	id: ActivityId,
 	occurredAt: Schema.DateTimeUtcFromString
 });
-const cursors$2 = cursorCodec(Schema.fromJsonString(CursorPayload$2), (value) => ActivityCursor.make(value), () => new ActivityCursorInvalid());
+const cursors$1 = cursorCodec(Schema.fromJsonString(CursorPayload$1), (value) => ActivityCursor.make(value), () => new ActivityCursorInvalid());
 const activityLayer = Layer.effect(Activity, Effect.gen(function* () {
 	const accessControl = yield* AccessControl;
 	const storage = yield* ActivityStore;
@@ -122,7 +78,7 @@ const activityLayer = Layer.effect(Activity, Effect.gen(function* () {
 			action: "activity.read",
 			resource: { kind: "activity" }
 		});
-		const cursor = query.cursor ? yield* Effect.fromResult(cursors$2.decode(query.cursor)) : void 0;
+		const cursor = query.cursor ? yield* Effect.fromResult(cursors$1.decode(query.cursor)) : void 0;
 		const page = yield* storage.list({
 			action: query.action,
 			actorId: query.actorId,
@@ -138,7 +94,7 @@ const activityLayer = Layer.effect(Activity, Effect.gen(function* () {
 		};
 		return page.next ? ActivityPage.make({
 			...output,
-			nextCursor: cursors$2.encode(page.next)
+			nextCursor: cursors$1.encode(page.next)
 		}) : ActivityPage.make(output);
 	});
 	return Activity.of({ list });
@@ -254,7 +210,6 @@ const ROUND = [
 	3204031479,
 	3329325298
 ];
-/** Portable synchronous SHA-256 for deterministic journal fingerprints and secret redaction. */
 function sha256Hex(value) {
 	const input = new TextEncoder().encode(value);
 	const bitLength = BigInt(input.length) * 8n;
@@ -334,14 +289,14 @@ const PendingChange = ChangeDraft.pipe(Schema.fieldsAssign({
 	updatedAt: Schema.DateTimeUtcFromString
 }));
 function changeFingerprint(change) {
-	const encoded = Schema.encodeSync(ChangeDraft)(change);
+	const encoded = Result.getOrThrow(Schema.encodeResult(ChangeDraft)(change));
 	return sha256Hex(JSON.stringify(canonicalJson(encoded)));
 }
-const isJsonObject$5 = Schema.is(Schema.JsonObject);
-const decodeJson$2 = Schema.decodeUnknownSync(Schema.Json);
+const isJsonObject$4 = Schema.is(Schema.JsonObject);
+const decodeJson$2 = flow(Schema.decodeUnknownResult(Schema.Json), Result.getOrThrow);
 function canonicalJson(value) {
 	if (Array.isArray(value)) return value.map(canonicalJson);
-	if (!isJsonObject$5(value)) return value;
+	if (!isJsonObject$4(value)) return value;
 	return Object.fromEntries(Object.keys(value).sort((left, right) => left.localeCompare(right)).map((key) => [key, canonicalJson(decodeJson$2(value[key]))]));
 }
 
@@ -349,17 +304,17 @@ function canonicalJson(value) {
 //#region ../server/src/internal/change-journal/change-journal.ts
 const ChangeBegin = Data.taggedEnum();
 function requireUnresolvedChange(result) {
-	switch (result._tag) {
-		case "Unresolved": return Effect.succeed(result.change);
-		case "Recorded": return Effect.fail(new ChangeAlreadyResolved({
-			changeId: result.entry.id,
+	return ChangeBegin.$match(result, {
+		Unresolved: ({ change }) => Effect.succeed(change),
+		Recorded: ({ entry }) => Effect.fail(new ChangeAlreadyResolved({
+			changeId: entry.id,
 			outcome: "applied"
-		}));
-		case "Cancelled": return Effect.fail(new ChangeAlreadyResolved({
-			changeId: result.changeId,
+		})),
+		Cancelled: ({ changeId }) => Effect.fail(new ChangeAlreadyResolved({
+			changeId,
 			outcome: "cancelled"
-		}));
-	}
+		}))
+	});
 }
 var ChangeJournal = class extends Context.Service()("@internal/server/ChangeJournal") {};
 const findPendingChange = Effect.fn("ChangeJournal.findPending")(function* (journal, subject) {
@@ -424,7 +379,7 @@ function initialAdministratorDraft(identity, intent) {
 		action: "user.created",
 		context: identity.context,
 		id: identity.id,
-		intent: Schema.encodeSync(InitialAdministratorIntent)(intent),
+		intent: Result.getOrThrow(Schema.encodeResult(InitialAdministratorIntent)(intent)),
 		scope: "initialization",
 		subject: userEmailSubject(intent.normalizedEmail)
 	});
@@ -566,7 +521,7 @@ function userChangeDraft(identity, intent) {
 		action: userChangeAction(intent),
 		context: identity.context,
 		id: identity.id,
-		intent: Schema.encodeSync(UserChangeIntent)(intent),
+		intent: Result.getOrThrow(Schema.encodeResult(UserChangeIntent)(intent)),
 		scope: "users",
 		subject: userEmailSubject(intent.kind === "create" ? intent.normalizedEmail : intent.email)
 	};
@@ -732,12 +687,22 @@ function appliedResolution(change, intent, userId) {
 //#region ../auth/src/internal/user.ts
 const cmsUserCreationChangeField = "cmsCreationChangeId";
 const cmsUserSessionsRevokedChangeField = "cmsSessionsRevokedChangeId";
+const BetterAuthUser = Schema.Struct({
+	banned: Schema.optionalKey(Schema.NullOr(Schema.Boolean)),
+	createdAt: Schema.Date,
+	email: Schema.String,
+	emailVerified: Schema.Boolean,
+	id: Schema.String,
+	name: Schema.String,
+	role: Schema.optionalKey(Schema.NullOr(Schema.String)),
+	updatedAt: Schema.Date
+});
 const BetterAuthUserRecoveryEvidence = Schema.Struct({
 	[cmsUserCreationChangeField]: Schema.optionalKey(Schema.UndefinedOr(Schema.NullOr(ActivityId))),
 	[cmsUserSessionsRevokedChangeField]: Schema.optionalKey(Schema.UndefinedOr(Schema.NullOr(ActivityId)))
 });
-function decodeBetterAuthUser(user) {
-	return Schema.decodeUnknownEffect(User)({
+function decodeBetterAuthUser(value) {
+	return Schema.decodeEffect(BetterAuthUser)(value).pipe(Effect.flatMap((user) => Schema.decodeUnknownEffect(User)({
 		banned: user.banned === true,
 		createdAt: user.createdAt.toISOString(),
 		email: user.email,
@@ -746,7 +711,7 @@ function decodeBetterAuthUser(user) {
 		name: user.name,
 		role: user.role,
 		updatedAt: user.updatedAt.toISOString()
-	});
+	})));
 }
 function decodeBetterAuthActor(user) {
 	return Schema.decodeEffect(StudioActor)(betterAuthActorInput(user));
@@ -783,12 +748,12 @@ function betterAuthActivityWriter(storage, crypto) {
 		return yield* storage.append(activityEntryFromDraft(id, draft, yield* DateTime.now));
 	});
 }
-function betterAuthActivityOptions(writeActivity, crypto) {
+function betterAuthActivityOptions(writeActivity, crypto, runPromise) {
 	const capturedActors = /* @__PURE__ */ new WeakMap();
-	const write = (action, actor) => Effect.runPromise(crypto.randomUUIDv4.pipe(Effect.orDie, Effect.map((requestId) => activityDraft(action, actor, requestId)), Effect.flatMap(writeActivity), Effect.asVoid, Effect.catchCause(() => Effect.logWarning("Authentication Activity could not be recorded.", { action }).pipe(Effect.ignoreCause))));
+	const write = (action, actor) => runPromise(crypto.randomUUIDv4.pipe(Effect.orDie, Effect.map((requestId) => activityDraft(action, actor, requestId)), Effect.flatMap(writeActivity), Effect.asVoid, Effect.catchCauseIf((cause) => Cause.interruptors(cause).size === 0, () => Effect.logWarning("Authentication Activity could not be recorded.", { action }).pipe(Effect.ignoreCause))));
 	const before = createAuthMiddleware((context) => {
 		if (context.path !== "/sign-out" && context.path !== "/change-password") return Promise.resolve();
-		return Effect.runPromise(Effect.tryPromise(() => getSessionFromCtx(context, { disableRefresh: true })).pipe(Effect.orElseSucceed(() => null), Effect.tap((session) => Effect.sync(() => {
+		return runPromise(Effect.tryPromise(() => getSessionFromCtx(context, { disableRefresh: true })).pipe(Effect.orElseSucceed(() => null), Effect.tap((session) => Effect.sync(() => {
 			const actor = session?.user ? decodeActor(session.user) : void 0;
 			if (actor) capturedActors.set(context.context, actor);
 		})), Effect.asVoid));
@@ -832,7 +797,149 @@ function activityDraft(action, actor, requestId) {
 }
 function decodeActor(user) {
 	const option = decodeBetterAuthActorOption(user);
-	return option._tag === "Some" ? option.value : void 0;
+	return Option.getOrUndefined(option);
+}
+
+//#endregion
+//#region ../auth/src/internal/better-auth.ts
+const cmsBetterAuthAccess = createAccessControl(defaultStatements);
+const cmsBetterAuthRoles = {
+	administrator: cmsBetterAuthAccess.newRole({
+		session: ["list", "revoke"],
+		user: [
+			"create",
+			"list",
+			"get",
+			"set-role",
+			"delete",
+			"update"
+		]
+	}),
+	editor: cmsBetterAuthAccess.newRole({
+		session: [],
+		user: []
+	}),
+	viewer: cmsBetterAuthAccess.newRole({
+		session: [],
+		user: []
+	})
+};
+const timestampFields = {
+	createdAt: "created_at",
+	updatedAt: "updated_at"
+};
+function createCmsBetterAuthOptions(options, activity) {
+	return {
+		advanced: { database: {
+			generateId: "uuid",
+			joins: true
+		} },
+		appName: "CMS Studio",
+		basePath: options.basePath ?? "/api/cms/auth",
+		baseURL: options.baseURL,
+		database: options.database,
+		emailAndPassword: {
+			disableSignUp: true,
+			enabled: true,
+			...activity?.emailAndPassword
+		},
+		hooks: activity?.hooks,
+		user: {
+			additionalFields: {
+				[cmsUserCreationChangeField]: hiddenChangeField("cms_creation_change_id"),
+				[cmsUserSessionsRevokedChangeField]: hiddenChangeField("cms_sessions_revoked_change_id")
+			},
+			modelName: "auth_users",
+			fields: {
+				...timestampFields,
+				emailVerified: "email_verified"
+			}
+		},
+		session: {
+			cookieCache: {
+				enabled: false,
+				strategy: "jwt"
+			},
+			modelName: "auth_sessions",
+			fields: {
+				...timestampFields,
+				expiresAt: "expires_at",
+				ipAddress: "ip_address",
+				userAgent: "user_agent",
+				userId: "user_id"
+			}
+		},
+		account: {
+			modelName: "auth_accounts",
+			fields: {
+				accessToken: "access_token",
+				accessTokenExpiresAt: "access_token_expires_at",
+				accountId: "account_id",
+				...timestampFields,
+				idToken: "id_token",
+				providerId: "provider_id",
+				refreshToken: "refresh_token",
+				refreshTokenExpiresAt: "refresh_token_expires_at",
+				userId: "user_id"
+			}
+		},
+		verification: {
+			modelName: "auth_verifications",
+			fields: {
+				...timestampFields,
+				expiresAt: "expires_at"
+			}
+		},
+		rateLimit: {
+			enabled: true,
+			storage: "database",
+			modelName: "auth_rate_limits",
+			fields: { lastRequest: "last_request" }
+		},
+		plugins: [admin({
+			ac: cmsBetterAuthAccess,
+			adminRoles: ["administrator"],
+			defaultRole: "editor",
+			roles: cmsBetterAuthRoles,
+			schema: {
+				session: { fields: { impersonatedBy: "impersonated_by" } },
+				user: { fields: {
+					banExpires: "ban_expires",
+					banReason: "ban_reason",
+					banned: "banned",
+					role: "role"
+				} }
+			}
+		})],
+		secret: options.secret
+	};
+}
+function createCmsBetterAuth(options, activity) {
+	return betterAuth(createCmsBetterAuthOptions(options, activity));
+}
+function hiddenChangeField(fieldName) {
+	return {
+		fieldName,
+		input: false,
+		required: false,
+		returned: false,
+		type: "string"
+	};
+}
+
+//#endregion
+//#region ../auth/src/internal/handler.ts
+function rejectExternalAdminRoutes(handler, basePath) {
+	const mountedAt = canonicalBasePath(basePath);
+	return (request) => {
+		const path = new URL(request.url).pathname;
+		const relative = mountedAt === "/" ? path : path === mountedAt ? "/" : path.startsWith(`${mountedAt}/`) ? path.slice(mountedAt.length) : path;
+		if (relative === "/admin" || relative.startsWith("/admin/")) return Promise.resolve(new Response(null, { status: 404 }));
+		return handler(request);
+	};
+}
+function canonicalBasePath(basePath) {
+	return (basePath.startsWith("/") ? basePath : `/${basePath}`).replace(/\/+$/u, "") || "/";
 }
 
 //#endregion
@@ -915,9 +1022,24 @@ function matches(code, ...candidates) {
 	return code !== void 0 && candidates.some((candidate) => candidate.code === code);
 }
 function apiErrorCode(cause) {
-	if (!(cause instanceof APIError)) return void 0;
-	const body = Schema.decodeUnknownOption(Schema.Struct({ code: Schema.String }))(cause.body);
-	return body._tag === "Some" ? body.value.code : void 0;
+	if (!(cause instanceof Error) || cause.name !== "APIError") return void 0;
+	const apiError = Schema.decodeUnknownOption(Schema.Struct({
+		body: Schema.Struct({ code: Schema.String }),
+		statusCode: Schema.Int
+	}))(cause);
+	return Option.map(apiError, ({ body }) => body.code).pipe(Option.getOrUndefined);
+}
+
+//#endregion
+//#region ../auth/src/internal/provider.ts
+function providerCall(operation, request, onError) {
+	return Effect.tryPromise({
+		catch: (cause) => onError(operation, cause),
+		try: request
+	}).pipe(Effect.withSpan(operation));
+}
+function providerAdapter(auth, operation, onError) {
+	return providerCall(operation, () => auth.$context, onError).pipe(Effect.map((context) => context.internalAdapter));
 }
 
 //#endregion
@@ -926,13 +1048,10 @@ function betterAuthIdentity(auth) {
 	const authorityHeaders = /* @__PURE__ */ new WeakMap();
 	const authenticate = Effect.fn("BetterAuth.Authentication.authenticate")(function* (headers) {
 		const providerHeaders = new globalThis.Headers(headers);
-		const session = yield* Effect.tryPromise({
-			catch: () => studioInternalError(),
-			try: () => auth.api.getSession({
-				headers: providerHeaders,
-				query: { disableCookieCache: true }
-			})
-		});
+		const session = yield* providerCall("BetterAuth.getSession", () => auth.api.getSession({
+			headers: providerHeaders,
+			query: { disableCookieCache: true }
+		}), () => studioInternalError());
 		if (!session?.user) return null;
 		const actor = yield* decodeBetterAuthActor(session.user).pipe(Effect.mapError(() => studioInternalError()));
 		const authority = issueIdentityAuthority();
@@ -1026,16 +1145,13 @@ function betterAuthIdentity(auth) {
 				const apply = (changeId) => applyOperation(auth, "BetterAuth.revokeUserSessions", command, () => auth.api.revokeUserSessions({
 					body: { userId: command.userId },
 					headers
-				})).pipe(Effect.flatMap(() => Effect.tryPromise({
-					catch: (cause) => IdentityApplyFailure.Unknown({ error: unavailable$4("BetterAuth.adminUpdateUser.sessionRevocationReceipt", cause) }),
-					try: () => auth.api.adminUpdateUser({
-						body: {
-							data: { [cmsUserSessionsRevokedChangeField]: changeId },
-							userId: command.userId
-						},
-						headers
-					})
-				})), Effect.as(user));
+				})).pipe(Effect.flatMap(() => providerCall("BetterAuth.adminUpdateUser.sessionRevocationReceipt", () => auth.api.adminUpdateUser({
+					body: {
+						data: { [cmsUserSessionsRevokedChangeField]: changeId },
+						userId: command.userId
+					},
+					headers
+				}), (operation, cause) => IdentityApplyFailure.Unknown({ error: unavailable$4(operation, cause) }))), Effect.as(user));
 				return IdentityPreparation.Prepared({
 					apply,
 					intent,
@@ -1053,22 +1169,13 @@ function betterAuthIdentity(auth) {
 	};
 }
 function prepareOperation(auth, operation, request) {
-	return Effect.tryPromise({
-		catch: (cause) => prepareError(auth.$ERROR_CODES, operation, cause),
-		try: request
-	});
+	return providerCall(operation, request, (name, cause) => prepareError(auth.$ERROR_CODES, name, cause));
 }
 function prepareUserOperation(auth, operation, userId, request) {
-	return Effect.tryPromise({
-		catch: (cause) => prepareError(auth.$ERROR_CODES, operation, cause, userId),
-		try: request
-	});
+	return providerCall(operation, request, (name, cause) => prepareError(auth.$ERROR_CODES, name, cause, userId));
 }
 function applyOperation(auth, operation, command, request) {
-	return Effect.tryPromise({
-		catch: (cause) => applyError(auth.$ERROR_CODES, operation, command, cause),
-		try: request
-	});
+	return providerCall(operation, request, (name, cause) => applyError(auth.$ERROR_CODES, name, command, cause));
 }
 function requireAuthority(authorityHeaders, authority) {
 	const headers = authorityHeaders.get(authority);
@@ -1106,13 +1213,10 @@ function betterAuthInitialIdentity(auth) {
 		});
 		const intent = initialAdministratorIntent(input);
 		return {
-			apply: Effect.tryPromise({
-				catch: (cause) => initialIdentityError(auth.$ERROR_CODES, "BetterAuth.initialization.createUser", createInput, cause),
-				try: () => auth.api.createUser({ body: {
-					data: { emailVerified: true },
-					...createInput
-				} })
-			}).pipe(Effect.flatMap((result) => decodeBetterAuthUser(result.user).pipe(Effect.mapError((cause) => InitialIdentityFailure.Unknown({ error: initializationUnavailable$1("BetterAuth.initialization.createUser", cause) }))))),
+			apply: providerCall("BetterAuth.initialization.createUser", () => auth.api.createUser({ body: {
+				data: { emailVerified: true },
+				...createInput
+			} }), (operation, cause) => initialIdentityError(auth.$ERROR_CODES, operation, createInput, cause)).pipe(Effect.flatMap((result) => decodeBetterAuthUser(result.user).pipe(Effect.mapError((cause) => InitialIdentityFailure.Unknown({ error: initializationUnavailable$1("BetterAuth.initialization.createUser", cause) }))))),
 			intent
 		};
 	} });
@@ -1121,22 +1225,13 @@ function betterAuthInitialIdentity(auth) {
 //#endregion
 //#region ../auth/src/internal/recovery.ts
 function betterAuthRecovery(auth) {
-	const userAdapter = Effect.tryPromise({
-		catch: (cause) => unavailable$4("BetterAuth.recovery.context", cause),
-		try: () => auth.$context
-	}).pipe(Effect.map((context) => context.internalAdapter));
-	const initialAdapter = Effect.tryPromise({
-		catch: (cause) => initializationUnavailable$1("BetterAuth.initialization.recovery.context", cause),
-		try: () => auth.$context
-	}).pipe(Effect.map((context) => context.internalAdapter));
+	const userAdapter = providerAdapter(auth, "BetterAuth.recovery.context", unavailable$4);
+	const initialAdapter = providerAdapter(auth, "BetterAuth.initialization.recovery.context", initializationUnavailable$1);
 	const users = IdentityRecovery.of({ observe: Effect.fn("BetterAuth.Recovery.observeUserChange")(function* (intent) {
 		const adapter = yield* userAdapter;
 		switch (intent.kind) {
 			case "create": {
-				const result = yield* Effect.tryPromise({
-					catch: (cause) => unavailable$4("BetterAuth.recovery.findUserByEmail", cause),
-					try: () => adapter.findUserByEmail(intent.normalizedEmail, { includeAccounts: true })
-				});
+				const result = yield* providerCall("BetterAuth.recovery.findUserByEmail", () => adapter.findUserByEmail(intent.normalizedEmail, { includeAccounts: true }), unavailable$4);
 				if (!result) return {
 					creationChangeId: null,
 					credentialReady: false,
@@ -1178,10 +1273,7 @@ function betterAuthRecovery(auth) {
 	return {
 		initial: InitialIdentityRecovery.of({ observe: Effect.fn("BetterAuth.Recovery.observeInitialAdministrator")(function* (intent) {
 			const adapter = yield* initialAdapter;
-			const result = yield* Effect.tryPromise({
-				catch: (cause) => initializationUnavailable$1("BetterAuth.recovery.findInitialAdministrator", cause),
-				try: () => adapter.findUserByEmail(intent.normalizedEmail, { includeAccounts: true })
-			});
+			const result = yield* providerCall("BetterAuth.recovery.findInitialAdministrator", () => adapter.findUserByEmail(intent.normalizedEmail, { includeAccounts: true }), initializationUnavailable$1);
 			if (!result) return {
 				credentialReady: false,
 				user: null
@@ -1204,1580 +1296,156 @@ function findUser(adapter, userId) {
 	return findRawUser(adapter, userId).pipe(Effect.flatMap((user) => user ? decodeUser(user, "BetterAuth.recovery.findUserById") : Effect.succeed(null)));
 }
 function findRawUser(adapter, userId) {
-	return Effect.tryPromise({
-		catch: (cause) => unavailable$4("BetterAuth.recovery.findUserById", cause),
-		try: () => adapter.findUserById(userId)
-	});
+	return providerCall("BetterAuth.recovery.findUserById", () => adapter.findUserById(userId), unavailable$4);
 }
 function findSessionFingerprints(adapter, userId) {
-	return Effect.tryPromise({
-		catch: (cause) => unavailable$4("BetterAuth.recovery.listSessions", cause),
-		try: () => adapter.listSessions(userId)
-	}).pipe(Effect.map((sessions) => sessions.map((session) => sessionFingerprint(session.id))));
+	return providerCall("BetterAuth.recovery.listSessions", () => adapter.listSessions(userId), unavailable$4).pipe(Effect.map((sessions) => sessions.map((session) => sessionFingerprint(session.id))));
 }
 
 //#endregion
-//#region ../auth/src/internal/better-auth.ts
-const cmsBetterAuthAccess = createAccessControl(defaultStatements);
-const cmsBetterAuthRoles = {
-	administrator: cmsBetterAuthAccess.newRole({
-		session: ["list", "revoke"],
-		user: [
-			"create",
-			"list",
-			"get",
-			"set-role",
-			"delete",
-			"update"
-		]
-	}),
-	editor: cmsBetterAuthAccess.newRole({
-		session: [],
-		user: []
-	}),
-	viewer: cmsBetterAuthAccess.newRole({
-		session: [],
-		user: []
-	})
-};
-const timestampFields = {
-	createdAt: "created_at",
-	updatedAt: "updated_at"
-};
-function createCmsBetterAuthOptions(options, activity) {
-	return {
-		advanced: { database: {
-			generateId: "uuid",
-			joins: true
-		} },
-		appName: "CMS Studio",
-		basePath: options.basePath ?? "/api/cms/auth",
-		baseURL: options.baseURL,
-		database: options.database,
-		emailAndPassword: {
-			disableSignUp: true,
-			enabled: true,
-			...activity?.emailAndPassword
-		},
-		hooks: activity?.hooks,
-		user: {
-			additionalFields: {
-				[cmsUserCreationChangeField]: hiddenChangeField("cms_creation_change_id"),
-				[cmsUserSessionsRevokedChangeField]: hiddenChangeField("cms_sessions_revoked_change_id")
-			},
-			modelName: "auth_users",
-			fields: {
-				...timestampFields,
-				emailVerified: "email_verified"
-			}
-		},
-		session: {
-			cookieCache: {
-				enabled: false,
-				strategy: "jwt"
-			},
-			modelName: "auth_sessions",
-			fields: {
-				...timestampFields,
-				expiresAt: "expires_at",
-				ipAddress: "ip_address",
-				userAgent: "user_agent",
-				userId: "user_id"
-			}
-		},
-		account: {
-			modelName: "auth_accounts",
-			fields: {
-				accessToken: "access_token",
-				accessTokenExpiresAt: "access_token_expires_at",
-				accountId: "account_id",
-				...timestampFields,
-				idToken: "id_token",
-				providerId: "provider_id",
-				refreshToken: "refresh_token",
-				refreshTokenExpiresAt: "refresh_token_expires_at",
-				userId: "user_id"
-			}
-		},
-		verification: {
-			modelName: "auth_verifications",
-			fields: {
-				...timestampFields,
-				expiresAt: "expires_at"
-			}
-		},
-		rateLimit: {
-			enabled: true,
-			storage: "database",
-			modelName: "auth_rate_limits",
-			fields: { lastRequest: "last_request" }
-		},
-		plugins: [admin({
-			ac: cmsBetterAuthAccess,
-			adminRoles: ["administrator"],
-			defaultRole: "editor",
-			roles: cmsBetterAuthRoles,
-			schema: {
-				session: { fields: { impersonatedBy: "impersonated_by" } },
-				user: { fields: {
-					banExpires: "ban_expires",
-					banReason: "ban_reason",
-					banned: "banned",
-					role: "role"
-				} }
-			}
-		})],
-		secret: options.secret
-	};
-}
-function createCmsBetterAuth(options, activity) {
-	return betterAuth(createCmsBetterAuthOptions(options, activity));
-}
+//#region ../auth/src/BetterAuth.ts
 function betterAuthLayer(options) {
+	if (options.basePath !== void 0 && options.basePath !== "/api/cms/auth") throw new Error(`Authentication basePath must be ${CMS_AUTHENTICATION_PATH}.`);
 	return Layer.effectContext(Effect.gen(function* () {
 		const crypto = yield* Crypto.Crypto;
 		const storage = yield* ActivityStore;
-		const auth = createCmsBetterAuth(options, betterAuthActivityOptions(betterAuthActivityWriter(storage, crypto), crypto));
+		const runPromise = Effect.runPromiseWith(yield* Effect.context());
+		const auth = createCmsBetterAuth(options, betterAuthActivityOptions(betterAuthActivityWriter(storage, crypto), crypto, runPromise));
 		const identity = betterAuthIdentity(auth);
 		const recovery = betterAuthRecovery(auth);
 		const initialization = betterAuthInitialIdentity(auth);
 		const basePath = options.basePath ?? "/api/cms/auth";
-		const handler = AuthenticationHandler.of({ handle: rejectExternalAdminRoutes(auth.handler, basePath) });
-		return Context.empty().pipe(Context.add(Authentication, identity.authentication), Context.add(IdentityAdministration, identity.administration), Context.add(IdentityRecovery, recovery.users), Context.add(InitialIdentity, initialization), Context.add(InitialIdentityRecovery, recovery.initial), Context.add(AuthenticationHandler, handler));
-	}));
-}
-function rejectExternalAdminRoutes(handler, basePath) {
-	const mountedAt = canonicalBasePath(basePath);
-	return (request) => {
-		const path = new URL(request.url).pathname;
-		const relative = mountedAt === "/" ? path : path === mountedAt ? "/" : path.startsWith(`${mountedAt}/`) ? path.slice(mountedAt.length) : path;
-		if (relative === "/admin" || relative.startsWith("/admin/")) return Promise.resolve(new Response(null, { status: 404 }));
-		return handler(request);
-	};
-}
-function canonicalBasePath(basePath) {
-	return (basePath.startsWith("/") ? basePath : `/${basePath}`).replace(/\/+$/u, "") || "/";
-}
-function hiddenChangeField(fieldName) {
-	return {
-		fieldName,
-		input: false,
-		required: false,
-		returned: false,
-		type: "string"
-	};
-}
-
-//#endregion
-//#region ../server/src/adapter/Readiness.ts
-var ReadinessFailed = class extends Schema.TaggedError()("Cms.ReadinessFailed", { cause: Schema.Defect() }) {};
-var Readiness = class extends Context.Service()("@internal/server/Readiness") {};
-
-//#endregion
-//#region ../server/src/internal/working-documents/working-document-model.ts
-const WorkingDocumentGenerationId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("WorkingDocumentGenerationId"));
-const WorkingDocumentUpdateSequence = Schema.Int.check(Schema.isGreaterThan(0)).pipe(Schema.brand("WorkingDocumentUpdateSequence"));
-const WorkingDocumentHighWatermark = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("WorkingDocumentHighWatermark"));
-var WorkingDocumentPersistenceError = class extends Schema.TaggedError()("WorkingDocuments.PersistenceError", {
-	operation: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-var WorkingDocumentSuperseded = class extends Schema.TaggedError()("WorkingDocuments.Superseded", {
-	documentId: DocumentId,
-	expectedGeneration: WorkingDocumentGenerationId,
-	actualGeneration: Schema.optionalKey(WorkingDocumentGenerationId)
-}) {};
-var WorkingDocumentConflict = class extends Schema.TaggedError()("WorkingDocuments.Conflict", {
-	documentId: DocumentId,
-	operation: Schema.NonEmptyString,
-	message: Schema.NonEmptyString
-}) {};
-
-//#endregion
-//#region ../server/src/internal/working-documents/working-document.ts
-/** Durable identity for one exact recoverable Working Document generation. */
-const WorkingDocumentRef = Schema.Struct({
-	documentId: DocumentId,
-	generationId: WorkingDocumentGenerationId
-});
-var WorkingDocumentInvalid = class extends Schema.TaggedError()("WorkingDocuments.Invalid", {
-	documentId: DocumentId,
-	message: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-var WorkingDocumentUnavailable = class extends Schema.TaggedError()("WorkingDocuments.Unavailable", {
-	operation: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-/** An authored or working baseline committed, but the publish workflow still needs recovery. */
-var WorkingDocumentCheckpointed = class extends Schema.TaggedError()("WorkingDocuments.Checkpointed", {
-	checkpointVersion: DocumentVersion,
-	documentId: DocumentId,
-	result: Schema.optionalKey(DocumentMutationResult),
-	stateVector: Schema.Uint8Array,
-	cause: Schema.Defect()
-}) {};
-/** Signals that one exact Working Document generation changed or became invalid. */
-const WorkingDocumentChange = Schema.Struct({
-	kind: Schema.Literals(["updated", "invalidated"]),
-	ref: WorkingDocumentRef
-});
-var WorkingDocuments = class extends Context.Service()("@internal/server/WorkingDocuments") {};
-
-//#endregion
-//#region ../document/src/internal/editor/render.ts
-const renderEditorMarkdown = Effect.fn("EditorDocument.renderMarkdown")((document) => {
-	return Effect.tryPromise({
-		try: () => renderMarkdown(toComarkDocument(withoutEditorMetadata(document))),
-		catch: (cause) => new EditorRenderFailed({ cause })
-	});
-});
-
-//#endregion
-//#region ../document/src/internal/document-engine/relocate-links.ts
-/** Rewrites only semantic page links, preserving bindings and unrelated content. */
-function rewriteDocumentRoutes(document, destinations, components = []) {
-	let changed = false;
-	function link(value) {
-		const target = referenceTarget("a", /* @__PURE__ */ new Map([["href", value]]), document.path, void 0);
-		if (target?.kind !== "document" || !Predicate.isString(value)) return value;
-		const destination = destinations.get(target.path);
-		const sourceMoved = destinations.has(document.path);
-		if (!destination && (!sourceMoved || value.startsWith("/"))) return value;
-		const suffix = value.match(/[?#].*$/u)?.[0] ?? "";
-		const next = `${destination ?? target.path}${suffix}`;
-		if (next !== value) changed = true;
-		return next;
-	}
-	function properties(fields, values) {
-		const result = mutableJsonObject(values);
-		for (const field of fields) {
-			const value = values[field.name] === void 0 ? field.defaultValue : values[field.name];
-			if (field.input === "link") {
-				const next = link(value);
-				if (next !== void 0 && next !== value) result[field.name] = next;
-			} else if (field.fields) {
-				const next = Array.isArray(value) ? value.map((item) => Schema.is(Schema.JsonObject)(item) ? properties(field.fields ?? [], item) : item) : Schema.is(Schema.JsonObject)(value) ? properties(field.fields, value) : value;
-				if (next !== void 0 && JSON.stringify(next) !== JSON.stringify(value)) result[field.name] = next;
-			}
-		}
-		return result;
-	}
-	function visit(node, renderData) {
-		if (Predicate.isString(node) || node[0] === null) return node;
-		const [tag, attributes, ...children] = node;
-		const projection = projectCmsEditorComponentAttributes(attributes, renderData);
-		let props = properties(components.find((component) => component.name.toLowerCase() === tag.toLowerCase())?.authoring.props ?? [], projection.props);
-		if (tag === "a") {
-			const href = link(projection.props.href);
-			if (href !== void 0) props = Object.assign({}, props, { href });
-		}
-		return [
-			tag,
-			JSON.stringify(props) === JSON.stringify(projection.props) ? attributes : encodeCmsEditorComponentAttributes(props, projection.bindings),
-			...children.map((child) => visit(child, projection.renderData))
-		];
-	}
-	const nodes = document.body.nodes.map((node) => visit(node, createCmsComarkRenderData(document.body)));
-	return changed ? Object.assign({}, document.body, { nodes }) : void 0;
-}
-
-//#endregion
-//#region ../document/src/DocumentPlanning.ts
-/** Derives one canonical Source path and public path without performing persistence. */
-function planDocumentCreation(configuration, input) {
-	return Result.gen(function* () {
-		const collection = configuration.types.find((candidate) => candidate.collection === input.collection);
-		if (!collection) return yield* invalid$2(`Document collection "${input.collection}" does not exist.`, "collection");
-		if (!collection.canCreate) return yield* invalid$2(`Document collection "${input.collection}" does not allow creation.`, "collection");
-		const title = input.title.trim();
-		if (!title) return yield* invalid$2("A document title is required.", "title");
-		const locale = yield* resolveLocale(configuration, input.locale);
-		const address = yield* parseDocumentAddress(collection.addressPattern).pipe(Result.mapError(addressInvalid));
-		const relativePath = yield* resolveRelativePath(collection, input.location);
-		const data = Object.fromEntries(address.tokens.flatMap((token) => {
-			if (token.name === "slug" && relativePath) return [[token.name, relativePath.split("/").at(-1) ?? relativePath]];
-			return [];
-		}));
-		const relativeKey = yield* normalizePublicPath(relativePath).pipe(Result.mapError(addressInvalid));
-		const key = yield* resolveDocumentAddress(address, relativeKey, data).pipe(Result.mapError(addressInvalid));
-		const sourcePath = documentSourcePath(collection, relativePath, locale);
-		const path = localizeDocumentPath(key, locale, configuration.locales);
-		return Object.assign({
-			collection,
-			data,
-			key,
-			path,
-			sourcePath,
-			title
-		}, locale === void 0 ? void 0 : { locale });
-	});
-}
-/** Creates the canonical initial editor source, including configured field defaults. */
-const createInitialDocumentSource = Effect.fn("DocumentPlanning.createInitialSource")(function* (plan) {
-	const body = CmsMarkdownDocument.make({
-		frontmatter: initialFrontmatter(plan),
-		meta: {},
-		nodes: [[
-			"h1",
-			{},
-			plan.title
-		]]
-	});
-	return {
-		body,
-		markdown: yield* renderEditorMarkdown(body)
-	};
-});
-/** Derives the canonical destination Source path while preserving the Document's collection and locale. */
-function planDocumentMove(configuration, document, location) {
-	return Result.gen(function* () {
-		const collection = configuration.types.find((candidate) => candidate.collection === document.collection);
-		if (!collection) return yield* invalid$2(`Document collection "${document.collection}" does not exist.`, "documentId");
-		return documentSourcePath(collection, yield* resolveRelativePath(collection, location), document.locale);
-	});
-}
-/** Derives a collection-relative hierarchy path from a canonical document summary. */
-function documentRelativePath(collection, entry) {
-	let sourcePath = entry.sourcePath;
-	if (entry.document.locale && sourcePath.startsWith(`${entry.document.locale}/`)) sourcePath = sourcePath.slice(entry.document.locale.length + 1);
-	if (collection.directory !== "." && sourcePath.startsWith(`${collection.directory}/`)) sourcePath = sourcePath.slice(collection.directory.length + 1);
-	sourcePath = sourcePath.replace(/\.(?:md|mdc)$/iu, "");
-	return sourcePath.toLocaleLowerCase() === "index" ? void 0 : sourcePath.replace(/\/index$/iu, "");
-}
-function documentSourcePath(collection, relativePath, locale) {
-	const sourceName = relativePath ? `${relativePath}.md` : "index.md";
-	return SourcePath.make([
-		locale,
-		collection.directory === "." ? void 0 : collection.directory,
-		sourceName
-	].filter((value) => value !== void 0).join("/"));
-}
-function initialFrontmatter(plan) {
-	let frontmatter = {
-		...plan.data,
-		title: plan.title
-	};
-	for (const field of plan.collection.authoringFields) if (field.defaultValue !== void 0 && nestedValue$1(frontmatter, field.path) === void 0) frontmatter = setNestedValue(frontmatter, field.path.split("."), field.defaultValue);
-	return frontmatter;
-}
-function nestedValue$1(value, path) {
-	return path.split(".").reduce((current, segment) => isJsonObject$4(current) ? current[segment] : void 0, value);
-}
-function setNestedValue(target, path, value) {
-	const [segment, ...rest] = path;
-	if (!segment) return target;
-	if (rest.length === 0) return Object.assign({}, target, { [segment]: value });
-	const current = target[segment];
-	return Object.assign({}, target, { [segment]: setNestedValue(isJsonObject$4(current) ? current : {}, rest, value) });
-}
-const isJsonObject$4 = Schema.is(Schema.JsonObject);
-function resolveLocale(configuration, requested) {
-	const locales = configuration.locales;
-	if (!locales) return requested === void 0 ? Result.succeed(void 0) : invalid$2(`Document locale "${requested}" is not configured.`, "locale");
-	const locale = requested ?? locales.defaultLocale;
-	return locales.locales.includes(locale) ? Result.succeed(locale) : invalid$2(`Document locale "${locale}" does not exist.`, "locale");
-}
-function resolveRelativePath(collection, location) {
-	if (location.kind === "home") return collection.addressPattern === "/:path*" ? Result.succeed("") : invalid$2("Only a root catch-all collection can use the home location.", "location");
-	if (location.parent !== void 0 && !collection.hierarchy) return invalid$2(`Document collection "${collection.collection}" does not allow hierarchy.`, "location.parent");
-	return normalizeDocumentRelativePath([location.parent, location.slug].filter((value) => value !== void 0).join("/")).pipe(Result.mapError((error) => addressInvalid({
-		...error,
-		field: "location"
-	})));
-}
-function addressInvalid(error) {
-	return new DocumentValidationFailed({ issues: [validationIssue(error.message, error.field)] });
-}
-function invalid$2(message, field) {
-	return Result.fail(new DocumentValidationFailed({ issues: [validationIssue(message, field)] }));
-}
-function validationIssue(message, field) {
-	return field === void 0 ? {
-		code: "document.invalid",
-		message,
-		severity: "error"
-	} : {
-		code: "document.invalid",
-		field,
-		message,
-		severity: "error"
-	};
-}
-/** Updates route-owned frontmatter when relocating a page in a slug-addressed collection. */
-const relocateDocumentMarkdown = Effect.fn("DocumentPlanning.relocateMarkdown")(function* (configuration, document, location, markdown) {
-	const collection = configuration.types.find((type) => type.collection === document.collection);
-	if (!collection || !collection.addressPattern.includes(":slug") || location.kind === "home") return markdown;
-	return yield* renderEditorMarkdown({
-		...document.body,
-		frontmatter: {
-			...document.body.frontmatter,
-			slug: location.slug
-		}
-	});
-});
-
-//#endregion
-//#region ../server/src/internal/documents/document-state.ts
-const isDocumentCompilationFailed = Schema.is(DocumentCompilationFailed);
-function makeDocumentState(authored, published, snapshot) {
-	const activeById = /* @__PURE__ */ new Map();
-	for (const source of snapshot.active) {
-		if (activeById.has(source.documentId)) throw new Error(`Document "${source.documentId}" appears more than once in the repository snapshot.`);
-		activeById.set(source.documentId, source);
-	}
-	const authoredById = /* @__PURE__ */ new Map();
-	for (const document of authored.documents) {
-		if (authoredById.has(document.id)) throw new Error(`Compiled document "${document.id}" appears more than once in the authored catalog.`);
-		if (!activeById.has(document.id)) throw new Error(`Compiled document "${document.id}" is missing from the repository snapshot.`);
-		authoredById.set(document.id, document);
-	}
-	for (const documentId of activeById.keys()) if (!authoredById.has(documentId)) throw new Error(`Compiled document "${documentId}" is missing from the repository snapshot.`);
-	return {
-		activeById,
-		authored,
-		authoredById,
-		published,
-		snapshot
-	};
-}
-const compileDocumentState = Effect.fn("DocumentState.compile")(function* (engine, snapshot, previous) {
-	return makeDocumentState(yield* engine.compileAll({
-		previous: previous?.authored,
-		sources: authoredSources(snapshot)
-	}), yield* engine.compileAll({
-		previous: previous?.published,
-		sources: publishedSources(snapshot)
-	}), snapshot);
-});
-function authoredSources(snapshot) {
-	return snapshot.active.map((source) => ({
-		documentId: source.documentId,
-		draft: source.publishedVersion !== source.version,
-		markdown: source.markdown,
-		sourcePath: source.sourcePath
-	}));
-}
-function publishedSources(snapshot) {
-	return snapshot.published.map((source) => ({
-		documentId: source.documentId,
-		draft: false,
-		markdown: source.markdown,
-		sourcePath: source.sourcePath
-	}));
-}
-const compileValidCatalog = Effect.fn("DocumentState.compileValid")(function* (engine, sources, previous) {
-	const result = yield* Effect.result(engine.compileAll({
-		previous,
-		sources
-	}));
-	if (Result.isFailure(result)) return yield* new DocumentValidationFailed({ issues: compilationIssues(result.failure) });
-	const errors = result.success.issues.filter((issue) => issue.severity === "error");
-	if (errors.length > 0) return yield* new DocumentValidationFailed({ issues: errors });
-	return result.success;
-});
-const validateDocumentSources = Effect.fn("DocumentState.validate")(function* (engine, sources, sourcePath, previous) {
-	const result = yield* Effect.result(engine.compileAll({
-		previous,
-		sources
-	}));
-	if (Result.isFailure(result)) return DocumentValidationResult.make({
-		issues: compilationIssues(result.failure),
-		valid: false
-	});
-	const catalog = result.success;
-	const document = catalog.documents.find((candidate) => candidate.source.path === sourcePath);
-	const issues = catalog.issues;
-	const validation = {
-		issues,
-		valid: document !== void 0 && !issues.some((issue) => issue.severity === "error")
-	};
-	return DocumentValidationResult.make(Object.assign(validation, document === void 0 ? void 0 : { document }));
-});
-function authoringEntries(state, query) {
-	return state.snapshot.active.flatMap((source) => {
-		const document = state.authoredById.get(source.documentId);
-		if (!document) throw new Error(`Compiled document "${source.documentId}" is missing from the repository snapshot.`);
-		if (query.collection !== void 0 && document.collection !== query.collection) return [];
-		if (query.locale !== void 0 && document.locale !== query.locale) return [];
-		return [DocumentSummary.make({
-			...browseMetadata(state, source),
-			document,
-			sourcePath: source.sourcePath,
-			version: source.version
-		})];
-	});
-}
-function deletedEntries(state) {
-	return state.snapshot.deleted.map((source) => DeletedDocument.make({
-		...source.title ? { title: source.title } : void 0,
-		...source.path ? { path: source.path } : void 0,
-		...source.trashBatchId ? { trashBatchId: source.trashBatchId } : void 0,
-		documentId: source.documentId,
-		deletedAt: source.deletedAt,
-		sourcePath: source.sourcePath,
-		version: source.version
-	}));
-}
-function entryById(state, documentId) {
-	const source = state.activeById.get(documentId);
-	const document = state.authoredById.get(documentId);
-	return source && document ? DocumentSummary.make({
-		...browseMetadata(state, source),
-		document,
-		sourcePath: source.sourcePath,
-		version: source.version
-	}) : void 0;
-}
-function compilationIssues(error) {
-	if (isDocumentCompilationFailed(error)) return error.issues;
-	return [{
-		code: "markdown.parse",
-		message: errorMessage(error.cause),
-		severity: "error",
-		sourcePath: error.sourcePath
-	}];
-}
-function errorMessage(cause) {
-	return cause instanceof Error && cause.message ? cause.message : "Markdown could not be parsed.";
-}
-function browseMetadata(state, source) {
-	const live = state.published.documents.find((document) => document.id === source.documentId);
-	const metadata = {};
-	if (source.createdBy) metadata.createdBy = source.createdBy;
-	if (source.editedBy) metadata.editedBy = source.editedBy;
-	if (source.editedAt) metadata.editedAt = source.editedAt;
-	if (source.publishedVersion) metadata.publishedVersion = source.publishedVersion;
-	if (live) metadata.publishedPath = live.path;
-	return metadata;
-}
-
-//#endregion
-//#region ../server/src/internal/documents/document-tree-mutation.ts
-/** Selects by route boundaries, never by title or a raw prefix such as /about matching /about-us. */
-function subtreeIds(state, documentId) {
-	const parent = state.authoredById.get(documentId);
-	if (!parent) return [documentId];
-	return state.authored.documents.filter((page) => page.id === parent.id || parent.key !== "/" && page.collection === parent.collection && page.locale === parent.locale && page.key.startsWith(`${parent.key}/`)).map((page) => page.id);
-}
-const prepareTreeMutation = Effect.fn("Documents.prepareTreeMutation")(function* (dependencies, state, command) {
-	const { configuration, engine } = dependencies;
-	const input = command.input;
-	const root = command.action === "document.undelete" ? state.snapshot.deleted.find((source) => source.documentId === input.documentId) : state.activeById.get(input.documentId);
-	if (!root) return yield* new DocumentNotFound({ documentId: input.documentId });
-	if (root.version !== input.expectedVersion) return yield* new DocumentVersionConflict({
-		documentId: root.documentId,
-		actualVersion: root.version,
-		expectedVersion: input.expectedVersion
-	});
-	let sources;
-	if (command.action === "document.undelete") {
-		const deleted = state.snapshot.deleted.find((source) => source.documentId === root.documentId);
-		const prefix = root.sourcePath.replace(/(?:\/index)?\.(?:md|mdc)$/iu, "");
-		sources = state.snapshot.deleted.filter((source) => source.documentId === root.documentId || deleted && deleted.trashBatchId && source.trashBatchId === deleted.trashBatchId && source.sourcePath.startsWith(`${prefix}/`));
-	} else {
-		const ids = new Set(command.action === "document.duplicate" && !command.input.includeChildren ? [root.documentId] : subtreeIds(state, root.documentId));
-		sources = state.snapshot.active.filter((source) => ids.has(source.documentId));
-	}
-	sources = [root, ...sources.filter((source) => source.documentId !== root.documentId)];
-	const plans = [];
-	const parent = state.authoredById.get(root.documentId);
-	for (const source of sources) {
-		if (command.action === "document.remove" || command.action === "document.undelete") {
-			const page = state.authoredById.get(source.documentId);
-			plans.push({
-				...command.action === "document.remove" ? {
-					trashBatchId: root.version,
-					title: page?.title,
-					path: page?.path
-				} : void 0,
-				action: command.action,
-				documentId: source.documentId,
-				expectedVersion: source.version,
-				markdown: source.markdown,
-				sourcePath: source.sourcePath
-			});
-			continue;
-		}
-		const page = state.authoredById.get(source.documentId);
-		const collection = configuration.types.find((type) => type.collection === page?.collection);
-		if (!page || !parent || !collection) return yield* new DocumentNotFound({ documentId: source.documentId });
-		if (command.action === "document.duplicate" && !collection.canCreate) return yield* invalid$1("This collection does not allow new pages.");
-		const destination = command.input.location;
-		if (parent.key === "/" && command.action === "document.move") return yield* invalid$1("The home page cannot be moved.");
-		const rootRelative = documentRelativePath(collection, {
-			document: parent,
-			sourcePath: root.sourcePath
-		}) ?? "";
-		const nextRelative = destination.kind === "home" ? "" : [destination.parent, destination.slug].filter(Boolean).join("/");
-		if (rootRelative && (nextRelative === rootRelative || nextRelative.startsWith(`${rootRelative}/`))) return yield* invalid$1("Choose a destination outside this page and its subpages.");
-		const relative = documentRelativePath(collection, {
-			document: page,
-			sourcePath: source.sourcePath
-		}) ?? "";
-		const segments = `${nextRelative}${source.documentId === root.documentId ? "" : relative.slice(rootRelative.length)}`.split("/").filter(Boolean);
-		const slug = segments.pop();
-		const location = slug ? Object.assign({
-			kind: "entry",
-			slug: yield* decodeSlug(slug)
-		}, segments.length ? { parent: yield* decodeParent(segments.join("/")) } : void 0) : { kind: "home" };
-		const sourcePath = yield* Effect.fromResult(planDocumentMove(configuration, page, location));
-		const markdown = yield* relocateDocumentMarkdown(configuration, page, location, source.markdown).pipe(Effect.mapError(() => invalid$1("The page could not be copied to its new URL.")));
-		if (command.action === "document.duplicate") {
-			const documentId = yield* command.nextDocumentId;
-			plans.push({
-				action: "document.create",
-				documentId,
-				markdown,
-				sourcePath
-			});
-		} else plans.push({
-			action: "document.move",
-			documentId: source.documentId,
-			expectedVersion: source.version,
-			markdown,
-			sourcePath,
-			publishedVersion: source.publishedVersion
-		});
-	}
-	const changed = new Set(plans.map((plan) => plan.documentId));
-	const nextSources = authoredSources(state.snapshot).filter((source) => !changed.has(source.documentId));
-	if (command.action !== "document.remove") for (const plan of plans) {
-		if (nextSources.some((source) => source.sourcePath === plan.sourcePath)) return yield* new DocumentPathConflict({ sourcePath: plan.sourcePath });
-		nextSources.push({
-			documentId: plan.documentId,
-			draft: true,
-			markdown: plan.markdown,
-			sourcePath: plan.sourcePath
-		});
-	}
-	if (command.action === "document.move" || command.action === "document.duplicate") {
-		const preliminary = yield* engine.compileAll({
-			sources: nextSources,
-			previous: state.authored
-		});
-		const destinations = /* @__PURE__ */ new Map();
-		for (let index = 0; index < sources.length; index++) {
-			const original = sources[index];
-			const plan = plans[index];
-			const oldPage = original && state.authoredById.get(original.documentId);
-			const newPage = plan && preliminary.documents.find((document) => document.id === plan.documentId);
-			if (oldPage && newPage) destinations.set(oldPage.path, newPage.path);
-		}
-		const originals = command.action === "document.move" ? state.snapshot.active : sources;
-		for (const source of originals) {
-			const page = state.authoredById.get(source.documentId);
-			if (!page) continue;
-			const body = rewriteDocumentRoutes(page, destinations, dependencies.components);
-			if (!body) continue;
-			const index = command.action === "document.duplicate" ? sources.findIndex((item) => item.documentId === source.documentId) : plans.findIndex((plan) => plan.documentId === source.documentId);
-			const existing = index >= 0 ? plans[index] : void 0;
-			const projected = existing && preliminary.documents.find((document) => document.id === existing.documentId);
-			const markdown = yield* renderEditorMarkdown(Object.assign({}, body, { frontmatter: projected?.body.frontmatter ?? body.frontmatter })).pipe(Effect.mapError(() => invalid$1("Page links could not be updated.")));
-			if (existing) plans[index] = {
-				...existing,
-				markdown
-			};
-			else plans.push({
-				action: "document.update",
-				documentId: source.documentId,
-				expectedVersion: source.version,
-				sourcePath: source.sourcePath,
-				markdown,
-				publishedVersion: source.publishedVersion
-			});
-		}
-		for (const plan of plans) {
-			const index = nextSources.findIndex((source) => source.documentId === plan.documentId);
-			const updated = {
-				documentId: plan.documentId,
-				sourcePath: plan.sourcePath,
-				markdown: plan.markdown,
-				draft: true
-			};
-			if (index >= 0) nextSources[index] = updated;
-			else nextSources.push(updated);
-		}
-	}
-	const first = plans[0];
-	if (!first) return yield* Effect.die(/* @__PURE__ */ new Error("Empty subtree mutation."));
-	return {
-		authored: yield* compileValidCatalog(engine, nextSources, state.authored),
-		published: command.action === "document.remove" ? yield* compileValidCatalog(engine, publishedSources(state.snapshot).filter((source) => !changed.has(source.documentId)), state.published) : state.published,
-		commitPlan: first,
-		additionalPlans: plans.slice(1)
-	};
-});
-const decodeSlug = (value) => Schema.decodeEffect(Slug)(value).pipe(Effect.mapError(() => invalid$1("Invalid URL ending.")));
-const decodeParent = (value) => Schema.decodeEffect(RelativeDocumentPath)(value).pipe(Effect.mapError(() => invalid$1("Invalid parent URL.")));
-function invalid$1(message) {
-	return new DocumentValidationFailed({ issues: [{
-		code: "document.invalid",
-		severity: "error",
-		message
-	}] });
-}
-
-//#endregion
-//#region ../server/src/internal/documents/document-lifecycle.ts
-const PreparedDocumentMutation = Data.taggedEnum();
-const prepareDocumentMutation = Effect.fn("DocumentLifecycle.prepare")(function* (dependencies, state, command) {
-	const { engine, repository } = dependencies;
-	if (command.action === "document.move" || command.action === "document.remove" || command.action === "document.undelete" || command.action === "document.duplicate") return PreparedDocumentMutation.Commit(yield* prepareTreeMutation(dependencies, state, command));
-	const authored = authoredSources(state.snapshot);
-	const published = publishedSources(state.snapshot);
-	switch (command.action) {
-		case "document.create": {
-			yield* ensurePathAvailable(state, command.sourcePath);
-			const nextAuthored = [...authored, {
-				documentId: command.documentId,
-				draft: true,
-				markdown: command.markdown,
-				sourcePath: command.sourcePath
-			}];
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
-				published: state.published,
-				commitPlan: {
-					action: command.action,
-					documentId: command.documentId,
-					markdown: command.markdown,
-					sourcePath: command.sourcePath
-				}
-			});
-		}
-		case "document.update": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			const nextAuthored = replaceSource(authored, {
-				documentId: current.documentId,
-				draft: true,
-				markdown: command.input.markdown,
-				sourcePath: current.sourcePath
-			});
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
-				published: state.published,
-				commitPlan: {
-					action: command.action,
-					documentId: current.documentId,
-					expectedVersion: command.input.expectedVersion,
-					markdown: command.input.markdown,
-					publishedVersion: current.publishedVersion,
-					sourcePath: current.sourcePath
-				}
-			});
-		}
-		case "document.restore": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			const historical = yield* repository.revision(current.documentId, command.input.revisionId);
-			const nextAuthored = replaceSource(authored, {
-				documentId: current.documentId,
-				draft: true,
-				markdown: historical.markdown,
-				sourcePath: current.sourcePath
-			});
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
-				published: state.published,
-				commitPlan: {
-					action: command.action,
-					documentId: current.documentId,
-					expectedVersion: command.input.expectedVersion,
-					markdown: historical.markdown,
-					publishedVersion: current.publishedVersion,
-					revisionId: command.input.revisionId,
-					sourcePath: current.sourcePath
-				}
-			});
-		}
-		case "document.unpublish": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, replaceSource(authored, {
-					documentId: current.documentId,
-					draft: true,
-					markdown: current.markdown,
-					sourcePath: current.sourcePath
-				}), state.authored),
-				published: yield* compileValidCatalog(engine, withoutDocument(published, current.documentId), state.published),
-				commitPlan: {
-					action: command.action,
-					documentId: current.documentId,
-					expectedVersion: current.version,
-					markdown: current.markdown,
-					sourcePath: current.sourcePath,
-					revisionId: current.revisionId
-				}
-			});
-		}
-		case "document.publish": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			if (current.publishedVersion === current.version) {
-				const entry = entryById(state, current.documentId);
-				const result = {
-					action: "document.publish",
-					affectedDocumentIds: [current.documentId],
-					documentId: current.documentId,
-					generation: state.snapshot.generation,
-					revisionId: current.revisionId,
-					sourcePath: current.sourcePath,
-					version: current.version
-				};
-				return PreparedDocumentMutation.Unchanged({ result: DocumentMutationResult.make(Object.assign(result, entry === void 0 ? void 0 : { entry })) });
-			}
-			const source = {
-				documentId: current.documentId,
-				draft: false,
-				markdown: current.markdown,
-				sourcePath: current.sourcePath
-			};
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, replaceSource(authored, source), state.authored),
-				published: yield* compileValidCatalog(engine, replaceSource(published, source), state.published),
-				commitPlan: {
-					action: command.action,
-					documentId: current.documentId,
-					expectedVersion: command.input.expectedVersion,
-					markdown: current.markdown,
-					revisionId: current.revisionId,
-					sourcePath: current.sourcePath
-				}
-			});
-		}
-	}
-});
-const validateDocumentUpdate = Effect.fn("DocumentLifecycle.validateUpdate")(function* (engine, state, input) {
-	const current = yield* requireActive(state, input.documentId);
-	yield* requireVersion(current, input.expectedVersion);
-	const source = {
-		documentId: current.documentId,
-		draft: true,
-		markdown: input.markdown,
-		sourcePath: current.sourcePath
-	};
-	return yield* validateDocumentSources(engine, replaceSource(authoredSources(state.snapshot), source), current.sourcePath, state.authored);
-});
-function requireActive(state, documentId) {
-	const source = state.activeById.get(documentId);
-	return source ? Effect.succeed(source) : Effect.fail(new DocumentNotFound({ documentId }));
-}
-function requireVersion(source, expectedVersion) {
-	return source.version === expectedVersion ? Effect.void : Effect.fail(new DocumentVersionConflict({
-		actualVersion: source.version,
-		documentId: source.documentId,
-		expectedVersion
+		const handler = AuthenticationHandler.of({ handle: rejectExternalAdminRoutes(auth.handler, basePath) });
+		return Context.empty().pipe(Context.add(Authentication, identity.authentication), Context.add(IdentityAdministration, identity.administration), Context.add(IdentityRecovery, recovery.users), Context.add(InitialIdentity, initialization), Context.add(InitialIdentityRecovery, recovery.initial), Context.add(AuthenticationHandler, handler));
 	}));
 }
-function ensurePathAvailable(state, sourcePath, exceptDocumentId) {
-	return state.snapshot.active.some((source) => source.sourcePath === sourcePath && source.documentId !== exceptDocumentId) ? Effect.fail(new DocumentPathConflict({ sourcePath })) : Effect.void;
-}
-function replaceSource(sources, source) {
-	return [...sources.filter((candidate) => candidate.documentId !== source.documentId), source];
-}
-function withoutDocument(sources, documentId) {
-	return sources.filter((source) => source.documentId !== documentId);
-}
-
-//#endregion
-//#region ../server/src/internal/documents/document-media-references.ts
-/** Projects the durable authored/published media-reference union without reparsing documents. */
-function projectMediaReferences(authored, published, documentId) {
-	const references = [...referencesFromCatalog(authored, documentId), ...referencesFromCatalog(published, documentId)];
-	return [...new Map(references.map((reference) => [referenceIdentity(reference), reference])).values()];
-}
-function referencesFromCatalog(catalog, documentId) {
-	return catalog.references.all.filter((reference) => reference.target.kind === "media" && (documentId === void 0 || reference.source.documentId === documentId)).map(toMediaReference);
-}
-function toMediaReference(reference) {
-	if (reference.target.kind !== "media") throw new Error("Expected a media reference.");
-	return MediaReference.make({
-		documentId: reference.source.documentId,
-		nodePath: reference.nodePath,
-		objectKey: MediaObjectKey.make(reference.target.key),
-		path: reference.source.path,
-		sourcePath: reference.source.sourcePath
-	});
-}
-function referenceIdentity(reference) {
-	return `${reference.documentId}:${reference.sourcePath}:${reference.nodePath.join(".")}:${reference.objectKey}`;
-}
 
 //#endregion
-//#region ../server/src/internal/documents/document-import.ts
-/** Imports configured or migrated Sources through the normal Document lifecycle. */
-const importDocumentSources = Effect.fn("Documents.importSources")(function* (dependencies, input, activity) {
-	const report = {
-		created: 0,
-		preserved: 0,
-		published: 0,
-		unchanged: 0,
-		updated: 0
-	};
-	for (const source of input.sources) {
-		const plan = planDocumentImport(yield* dependencies.current(source.sourcePath), source, input.mode);
-		switch (plan.kind) {
-			case "create": {
-				const created = yield* dependencies.runMutation({
-					action: "document.create",
-					documentId: yield* dependencies.nextDocumentId,
-					markdown: source.markdown,
-					sourcePath: source.sourcePath
-				}, activity, input.reason);
-				report.created += 1;
-				if (plan.publish) {
-					yield* publish(dependencies, created, input, activity);
-					report.published += 1;
-				}
-				break;
-			}
-			case "preserve":
-			case "unchanged":
-				report[plan.kind === "preserve" ? "preserved" : "unchanged"] += 1;
-				break;
-			case "publish":
-				yield* publish(dependencies, plan.current, input, activity);
-				report.published += 1;
-				break;
-			case "update": {
-				const updated = yield* dependencies.runMutation({
-					action: "document.update",
-					input: {
-						documentId: plan.current.documentId,
-						expectedVersion: plan.current.version,
-						markdown: source.markdown,
-						reason: input.reason
+//#region ../platform-node/src/internal/http/form-ingress.ts
+function handleFormRequest(request, handle) {
+	return Effect.runPromise(Effect.gen(function* () {
+		const ingress = yield* Effect.gen(function* () {
+			const origin = request.headers.get("origin");
+			if (origin && origin !== new URL(request.url).origin) return Response.json({ error: "Origin rejected." }, { status: 403 });
+			if (request.method !== "POST") return new Response(null, { status: 405 });
+			if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") return new Response(null, { status: 415 });
+			const reader = request.body?.getReader();
+			if (!reader) return new Response(null, { status: 400 });
+			const chunks = [];
+			let size = 0;
+			try {
+				while (true) {
+					const chunk = yield* Effect.tryPromise(() => reader.read());
+					if (chunk.done) break;
+					size += chunk.value.byteLength;
+					if (size > 131072) {
+						yield* Effect.tryPromise(() => reader.cancel()).pipe(Effect.ignore);
+						return new Response(null, { status: 413 });
 					}
-				}, activity, input.reason);
-				report.updated += 1;
-				if (plan.publish) {
-					yield* publish(dependencies, updated, input, activity);
-					report.published += 1;
+					chunks.push(chunk.value);
 				}
-				break;
+			} finally {
+				reader.releaseLock();
 			}
-		}
-	}
-	return DocumentImportReport.make(report);
-});
-/** Plans one deterministic import without performing persistence or generating identities. */
-function planDocumentImport(current, source, mode) {
-	if (!current) return {
-		kind: "create",
-		publish: source.published
-	};
-	if (current.markdown !== source.markdown) return mode === "overwrite" ? {
-		current,
-		kind: "update",
-		publish: source.published
-	} : { kind: "preserve" };
-	if (source.published && current.publishedVersion !== current.version) return {
-		current,
-		kind: "publish"
-	};
-	return { kind: "unchanged" };
-}
-function publish(dependencies, source, input, activity) {
-	return dependencies.runMutation({
-		action: "document.publish",
-		input: {
-			documentId: source.documentId,
-			expectedVersion: source.version,
-			reason: input.reason
-		}
-	}, activity, input.reason);
+			const body = new Uint8Array(size);
+			let offset = 0;
+			for (const chunk of chunks) {
+				body.set(chunk, offset);
+				offset += chunk.byteLength;
+			}
+			return body;
+		}).pipe(Effect.orElseSucceed(() => new Response(null, { status: 400 })));
+		if (ingress instanceof Response) return ingress;
+		return yield* Effect.promise(() => handle(new Request(request.url, {
+			method: "POST",
+			headers: request.headers,
+			body: ingress,
+			signal: request.signal
+		})));
+	}).pipe(Effect.map((response) => {
+		response.headers.set("cache-control", "no-store");
+		return response;
+	})));
 }
 
 //#endregion
-//#region ../server/src/internal/documents/document-store.ts
-var DocumentStore = class extends Context.Service()("@internal/server/DocumentStore") {};
+//#region ../server/src/Readiness.ts
+var ReadinessFailed = class extends Schema.TaggedError()("Cms.ReadinessFailed", { cause: Schema.Defect() }) {};
+var Readiness = class extends Context.Service()("@internal/server/Readiness") {};
+/** A stale unresolved external change makes the installation unavailable until reconciliation resolves it. */
+const readinessLayer = Layer.effect(Readiness, Effect.gen(function* () {
+	const journal = yield* ChangeJournal;
+	const check = Effect.gen(function* () {
+		const now = yield* DateTime.now;
+		const pending = yield* journal.pending({
+			before: DateTime.subtractDuration(now, "30 seconds"),
+			limit: 1
+		}).pipe(Effect.mapError((cause) => new ReadinessFailed({ cause })));
+		const oldest = pending.changes[0];
+		if (pending.total === 0) return;
+		if (oldest === void 0) return yield* new ReadinessFailed({ cause: /* @__PURE__ */ new Error("The pending change journal returned no change.") });
+		yield* Effect.logWarning("CMS readiness found a stale pending change.", {
+			action: oldest.action,
+			ageMillis: DateTime.toEpochMillis(now) - DateTime.toEpochMillis(oldest.updatedAt),
+			changeId: oldest.id,
+			phase: "pending"
+		});
+		return yield* new ReadinessFailed({ cause: /* @__PURE__ */ new Error("A stale change remains pending.") });
+	}).pipe(Effect.withSpan("Installation.readiness"));
+	return Readiness.of({ check });
+}));
 
 //#endregion
-//#region ../server/src/internal/documents/document-failures.ts
-var DocumentPersistenceError = class extends Schema.TaggedError()("Documents.PersistenceError", {
+//#region ../server/src/internal/working-documents/working-document-model.ts
+const WorkingDocumentGenerationId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("WorkingDocumentGenerationId"));
+const WorkingDocumentUpdateSequence = Schema.Int.check(Schema.isGreaterThan(0)).pipe(Schema.brand("WorkingDocumentUpdateSequence"));
+const WorkingDocumentHighWatermark = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("WorkingDocumentHighWatermark"));
+var WorkingDocumentPersistenceError = class extends Schema.TaggedError()("WorkingDocuments.PersistenceError", {
 	operation: Schema.NonEmptyString,
 	cause: Schema.Defect()
 }) {};
-var DocumentGenerationConflict = class extends Schema.TaggedError()("Documents.GenerationConflict", {
-	expectedGeneration: DocumentGeneration,
-	actualGeneration: DocumentGeneration
+var WorkingDocumentSuperseded = class extends Schema.TaggedError()("WorkingDocuments.Superseded", {
+	documentId: DocumentId,
+	expectedGeneration: WorkingDocumentGenerationId,
+	actualGeneration: Schema.optionalKey(WorkingDocumentGenerationId)
+}) {};
+var WorkingDocumentConflict = class extends Schema.TaggedError()("WorkingDocuments.Conflict", {
+	documentId: DocumentId,
+	operation: Schema.NonEmptyString,
+	message: Schema.NonEmptyString
 }) {};
 
 //#endregion
-//#region ../server/src/internal/documents/document-history.ts
-const CursorPayload$1 = Schema.Struct({
-	createdAt: Schema.DateTimeUtcFromString,
-	revisionId: RevisionId
-});
-const CursorJson$1 = Schema.fromJsonString(CursorPayload$1);
-const cursors$1 = cursorCodec(CursorJson$1, (value) => DocumentHistoryCursor.make(value), () => new DocumentHistoryInvalidCursor());
-function documentHistoryCapability(accessControl, repository) {
-	const requireHistory = (context, documentId) => accessControl.require(context, {
-		action: "document.history",
-		resource: {
-			documentId,
-			kind: "document"
-		}
-	});
-	const read = Effect.fn("Documents.history.read")(function* (context, documentId, revisionId) {
-		yield* requireHistory(context, documentId);
-		return yield* repository.revision(documentId, revisionId);
-	});
-	const list = Effect.fn("Documents.history.list")(function* (context, query) {
-		yield* requireHistory(context, query.documentId);
-		const cursor = query.cursor ? yield* Effect.fromResult(cursors$1.decode(query.cursor)) : void 0;
-		const page = yield* repository.revisions({
-			cursor,
-			documentId: query.documentId,
-			limit: query.limit ?? 25
-		});
-		const output = {
-			revisions: page.revisions.map(({ markdown: _markdown, ...revision }) => revision),
-			total: page.total
-		};
-		return page.next ? DocumentRevisionPage.make({
-			...output,
-			nextCursor: cursors$1.encode(page.next)
-		}) : DocumentRevisionPage.make(output);
-	});
-	return {
-		compare: Effect.fn("Documents.history.compare")(function* (context, input) {
-			yield* requireHistory(context, input.documentId);
-			const from = yield* repository.revision(input.documentId, input.fromRevisionId);
-			const to = yield* repository.revision(input.documentId, input.toRevisionId);
-			const changes = yield* compareLines(from.markdown, to.markdown);
-			return DocumentRevisionComparison.make({
-				changes,
-				from,
-				to
-			});
-		}),
-		list,
-		read
-	};
-}
-const MAXIMUM_COMPARISON_LINES = 1e4;
-const MAXIMUM_EDIT_LENGTH = 2e3;
-const comparisonTooLarge = () => new DocumentHistoryComparisonTooLarge({
-	maximumEditLength: MAXIMUM_EDIT_LENGTH,
-	maximumLines: MAXIMUM_COMPARISON_LINES
-});
-const compareLines = Effect.fn("Documents.history.compareLines")(function* (beforeMarkdown, afterMarkdown) {
-	const before = beforeMarkdown.split("\n");
-	const after = afterMarkdown.split("\n");
-	if (before.length > MAXIMUM_COMPARISON_LINES || after.length > MAXIMUM_COMPARISON_LINES) return yield* comparisonTooLarge();
-	const diff = diffArrays(before, after, {
-		maxEditLength: MAXIMUM_EDIT_LENGTH,
-		oneChangePerToken: true,
-		timeout: 100
-	});
-	if (!diff) return yield* comparisonTooLarge();
-	const changes = [];
-	let beforeLine = 1;
-	let afterLine = 1;
-	for (const change of diff) for (const line of change.value) if (change.removed) {
-		changes.push({
-			beforeLine,
-			kind: "removed",
-			line
-		});
-		beforeLine += 1;
-	} else if (change.added) {
-		changes.push({
-			afterLine,
-			kind: "added",
-			line
-		});
-		afterLine += 1;
-	} else {
-		changes.push({
-			afterLine,
-			beforeLine,
-			kind: "equal",
-			line
-		});
-		beforeLine += 1;
-		afterLine += 1;
-	}
-	return changes;
+//#region ../server/src/internal/working-documents/working-document.ts
+const WorkingDocumentRef = Schema.Struct({
+	documentId: DocumentId,
+	generationId: WorkingDocumentGenerationId
 });
-
-//#endregion
-//#region ../server/src/internal/documents/document-delivery.ts
-function documentDelivery(configuration, catalog) {
-	const read = Effect.fn("Documents.delivery.read")(function* (lookup) {
-		const document = findDocument(yield* catalog, lookup);
-		return Option.isSome(document) ? document.value : yield* new PublishedDocumentNotFound({ lookup });
-	});
-	const query = Effect.fn("Documents.delivery.query")(function* (input) {
-		return queryDocuments((yield* catalog).documents, input, {
-			limit: input.limit,
-			offset: input.offset ?? 0
-		});
-	});
-	const navigation = Effect.fn("Documents.delivery.navigation")(function* (input) {
-		return createNavigation((yield* catalog).documents, input, configuration);
-	});
-	const surround = Effect.fn("Documents.delivery.surround")(function* (lookup, input) {
-		const current = yield* catalog;
-		const document = findDocument(current, lookup);
-		if (Option.isNone(document)) return yield* new PublishedDocumentNotFound({ lookup });
-		const surroundQuery = Object.assign({}, { collection: input.collection ?? document.value.collection }, input.locale === void 0 && document.value.locale === void 0 ? void 0 : { locale: input.locale ?? document.value.locale }, input.where === void 0 ? void 0 : { where: input.where }, input.sort === void 0 ? void 0 : { sort: input.sort });
-		const page = queryDocuments(current.documents, surroundQuery);
-		const index = page.items.findIndex((candidate) => candidate.id === document.value.id);
-		return DocumentSurround.make({
-			previous: index > 0 ? page.items[index - 1] ?? null : null,
-			next: index >= 0 ? page.items[index + 1] ?? null : null
-		});
-	});
-	return {
-		diagnostics: catalog.pipe(Effect.map((current) => current.issues)),
-		navigation,
-		query,
-		read,
-		surround
-	};
-}
-function findDocument(catalog, lookup) {
-	switch (lookup.kind) {
-		case "id": return Option.fromNullishOr(catalog.documents.find((document) => document.id === lookup.documentId));
-		case "path": return catalog.findByPath(lookup.path);
-		case "key": return catalog.findByKey(lookup.key, lookup.locale).pipe(Option.filter((document) => lookup.collection === void 0 || document.collection === lookup.collection));
-	}
-}
-function queryDocuments(documents, query, page) {
-	const filtered = documents.filter((document) => {
-		if (query.collection !== void 0 && document.collection !== query.collection) return false;
-		if (query.locale !== void 0 && document.locale !== query.locale) return false;
-		return Object.entries(query.where ?? {}).every(([field, expected]) => matchesValue(documentField(document, field), expected));
-	});
-	const sorted = query.sort && query.sort.length > 0 ? sortDocuments(filtered, query.sort) : filtered;
-	const items = page ? sorted.slice(page.offset, page.offset + page.limit) : sorted;
-	return PublishedDocumentPage.make({
-		items,
-		total: filtered.length
-	});
-}
-function createNavigation(documents, query, configuration) {
-	const locale = query.locale ?? configuration.locales?.defaultLocale;
-	const candidates = documents.filter((document) => (query.collection === void 0 || document.collection === query.collection) && (locale === void 0 || document.locale === locale) && document.data.navigation !== false);
-	const roots = [];
-	const itemsByKey = /* @__PURE__ */ new Map();
-	const orderByItem = /* @__PURE__ */ new Map();
-	for (const document of candidates) {
-		if (document.key === "/") {
-			const item = navigationItem(document);
-			roots.push(item);
-			orderByItem.set(item, Number.NEGATIVE_INFINITY);
-			continue;
-		}
-		const segments = document.key.slice(1).split("/");
-		let parent;
-		for (let index = 0; index < segments.length; index += 1) {
-			const key = PublicPath.make(`/${segments.slice(0, index + 1).join("/")}`);
-			let item = itemsByKey.get(key);
-			if (!item) {
-				item = {
-					children: [],
-					key,
-					title: titleFromSegment(segments[index] ?? "")
-				};
-				itemsByKey.set(key, item);
-				if (parent) parent.children.push(item);
-				else roots.push(item);
-			}
-			if (index === segments.length - 1) {
-				const resolved = navigationItem(document);
-				item.title = resolved.title;
-				item.path = resolved.path;
-				if (resolved.locale !== void 0) item.locale = resolved.locale;
-				else delete item.locale;
-				item.documentId = resolved.documentId;
-				orderByItem.set(item, navigationOrder(document));
-			}
-			parent = item;
-		}
-	}
-	sortNavigation(roots, orderByItem);
-	return roots.map((item) => DocumentNavigationItem.make(item));
-}
-function navigationItem(document) {
-	const navigation = document.data.navigation;
-	const configuredTitle = Schema.is(Schema.JsonObject)(navigation) ? navigation.title : void 0;
-	return Object.assign({
-		children: [],
-		documentId: document.id,
-		key: document.key,
-		path: document.path,
-		title: Schema.is(Schema.String)(configuredTitle) && configuredTitle.trim() ? configuredTitle.trim() : document.title
-	}, document.locale === void 0 ? void 0 : { locale: document.locale });
-}
-function navigationOrder(document) {
-	const navigation = document.data.navigation;
-	const order = (Schema.is(Schema.JsonObject)(navigation) ? navigation.order : void 0) ?? document.data.order;
-	return Schema.is(Schema.Finite)(order) ? order : Number.POSITIVE_INFINITY;
-}
-function sortNavigation(items, orderByItem) {
-	items.sort((left, right) => {
-		return (orderByItem.get(left) ?? Number.POSITIVE_INFINITY) - (orderByItem.get(right) ?? Number.POSITIVE_INFINITY) || left.title.localeCompare(right.title);
-	});
-	items.forEach((item) => sortNavigation(item.children, orderByItem));
-}
-function documentField(document, field) {
-	switch (field) {
-		case "collection": return document.collection;
-		case "description": return document.description;
-		case "id": return document.id;
-		case "key": return document.key;
-		case "locale": return document.locale;
-		case "path": return document.path;
-		case "source.path": return document.source.path;
-		case "title": return document.title;
-		default: return nestedValue(document.data, field.startsWith("data.") ? field.slice(5) : field);
-	}
-}
-function nestedValue(value, path) {
-	return path.split(".").reduce((current, segment) => {
-		if (!Schema.is(Schema.JsonObject)(current)) return void 0;
-		return current[segment];
-	}, value);
-}
-function matchesValue(actual, expected) {
-	const expectedValues = Array.isArray(expected) ? expected : [expected];
-	return (Array.isArray(actual) ? actual : [actual]).some((value) => Schema.is(DocumentQueryScalar)(value) && expectedValues.includes(value));
-}
-function sortDocuments(documents, sorts) {
-	return documents.toSorted((left, right) => {
-		for (const sort of sorts) {
-			const comparison = compareValues(documentField(left, sort.field), documentField(right, sort.field));
-			if (comparison !== 0) return sort.direction === "desc" ? -comparison : comparison;
-		}
-		return 0;
-	});
-}
-function compareValues(left, right) {
-	if (left === right) return 0;
-	if (left === void 0 || left === null) return 1;
-	if (right === void 0 || right === null) return -1;
-	if (Schema.is(Schema.Finite)(left) && Schema.is(Schema.Finite)(right)) return left - right;
-	const leftText = Schema.is(Schema.String)(left) ? left : JSON.stringify(left) ?? "";
-	const rightText = Schema.is(Schema.String)(right) ? right : JSON.stringify(right) ?? "";
-	return leftText.localeCompare(rightText);
-}
-function titleFromSegment(segment) {
-	return segment.replace(/[-_]+/gu, " ").replace(/^./u, (character) => character.toUpperCase());
-}
-
-//#endregion
-//#region ../server/src/internal/documents/documents.ts
-const isDocumentGenerationConflict$2 = Schema.is(DocumentGenerationConflict);
-const isDocumentMediaUnavailable$1 = Schema.is(DocumentMediaUnavailable);
-const CONTENT_MUTATION_BUFFER_CAPACITY = 16;
-var Documents = class extends Context.Service()("@internal/server/Documents") {};
-var DocumentPreviews = class extends Context.Service()("@internal/server/DocumentPreviews") {};
-var PublishedDocuments = class extends Context.Service()("@internal/server/PublishedDocuments") {};
-var DocumentMaintenance = class extends Context.Service()("@internal/server/internal/DocumentMaintenance") {};
-const makeDocuments = Effect.fn("Documents.make")(function* (configuration, options) {
-	const repository = yield* DocumentStore;
-	const accessControl = yield* AccessControl;
-	const crypto = yield* Crypto.Crypto;
-	const engine = yield* createDocumentEngine(configuration, options);
-	const state = yield* Ref.make(yield* loadSynchronizedState(repository, engine));
-	const semaphore = yield* Semaphore.make(1);
-	const mutationEvents = yield* Effect.acquireRelease(PubSub.sliding(CONTENT_MUTATION_BUFFER_CAPACITY), PubSub.shutdown);
-	const dependencies = {
-		engine,
-		configuration,
-		repository,
-		components: options.components
-	};
-	const refreshUnlocked = Effect.fn("Documents.refreshUnlocked")(function* (force = false) {
-		const current = yield* Ref.get(state);
-		const snapshot = force ? yield* loadRequired(repository) : yield* repository.load(current.snapshot.generation);
-		if (!snapshot || !generationIsAfter(snapshot.generation, current.snapshot.generation)) return current.snapshot.generation;
-		const refreshed = yield* compileDocumentState(engine, snapshot, current);
-		yield* Ref.set(state, refreshed);
-		return refreshed.snapshot.generation;
-	});
-	const executeUnlocked = Effect.fn("Documents.execute")(function* (command, activity) {
-		return yield* Effect.gen(function* () {
-			yield* refreshUnlocked();
-			const current = yield* Ref.get(state);
-			if (command.action === "document.move" || command.action === "document.remove" || command.action === "document.duplicate") {
-				const ids = command.action === "document.duplicate" && !command.input.includeChildren ? [command.input.documentId] : subtreeIds(current, command.input.documentId);
-				for (const documentId of ids) yield* accessControl.require({
-					actor: activity.actor,
-					requestId: activity.requestId
-				}, {
-					action: command.action,
-					resource: {
-						kind: "document",
-						documentId
-					}
-				});
-				if (command.action === "document.duplicate") {
-					const source = current.authoredById.get(command.input.documentId);
-					if (source) yield* accessControl.require({
-						actor: activity.actor,
-						requestId: activity.requestId
-					}, {
-						action: "document.create",
-						resource: {
-							kind: "collection",
-							collection: source.collection,
-							locale: source.locale
-						}
-					});
-				}
-			}
-			const prepared = yield* prepareDocumentMutation(dependencies, current, command);
-			if (command.action === "document.move" && prepared._tag === "Commit") {
-				for (const plan of prepared.additionalPlans ?? []) if (plan.action === "document.update") yield* accessControl.require({
-					actor: activity.actor,
-					requestId: activity.requestId
-				}, {
-					action: "document.update",
-					resource: {
-						kind: "document",
-						documentId: plan.documentId
-					}
-				});
-			}
-			if (command.action === "document.undelete" && prepared._tag === "Commit") for (const plan of [prepared.commitPlan, ...prepared.additionalPlans ?? []]) yield* accessControl.require({
-				actor: activity.actor,
-				requestId: activity.requestId
-			}, {
-				action: "document.undelete",
-				resource: {
-					kind: "document",
-					documentId: plan.documentId
-				}
-			});
-			if (prepared._tag === "Unchanged") return prepared.result;
-			const committed = yield* repository.commit({
-				activity,
-				plan: prepared.commitPlan,
-				additionalPlans: prepared.additionalPlans,
-				expectedGeneration: current.snapshot.generation,
-				mediaReferences: [prepared.commitPlan, ...prepared.additionalPlans ?? []].flatMap((plan) => projectMediaReferences(prepared.authored, prepared.published, plan.documentId))
-			});
-			const next = makeDocumentState(prepared.authored, prepared.published, committed.snapshot);
-			yield* Ref.set(state, next);
-			const entry = entryById(next, committed.mutation.documentId);
-			const result = DocumentMutationResult.make(Object.assign({}, committed.mutation, entry === void 0 ? void 0 : { entry }));
-			yield* PubSub.publish(mutationEvents, result);
-			return result;
-		}).pipe(Effect.tapError((error) => isDocumentGenerationConflict$2(error) ? refreshUnlocked(true) : Effect.void), Effect.retry({
-			schedule: Schedule.recurs(3),
-			while: isDocumentGenerationConflict$2
-		}));
-	});
-	const runMutation = Effect.fn("Documents.runMutation")(function* (command, activity, reason) {
-		const resolvedActivity = enrichActivity(activity, reason);
-		return yield* semaphore.withPermits(1)(executeUnlocked(command, resolvedActivity));
-	});
-	const authored = semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return (yield* Ref.get(state)).authored;
-	})).pipe(Effect.withSpan("Documents.authored"));
-	const browse = Effect.fn("Documents.browse")((query) => semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return authoringEntries(yield* Ref.get(state), query);
-	})));
-	const create = Effect.fn("Documents.create")(function* (input, activity) {
-		const plan = yield* Effect.fromResult(planDocumentCreation(configuration, input));
-		const source = yield* createInitialDocumentSource(plan);
-		const documentId = DocumentId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
-		return yield* runMutation({
-			action: "document.create",
-			documentId,
-			markdown: source.markdown,
-			sourcePath: plan.sourcePath
-		}, activity, input.reason);
-	});
-	const importSources = (input, activity) => importDocumentSources({
-		current: (sourcePath) => semaphore.withPermits(1)(Effect.gen(function* () {
-			yield* refreshUnlocked();
-			return (yield* Ref.get(state)).snapshot.active.find((candidate) => candidate.sourcePath === sourcePath);
-		})),
-		nextDocumentId: crypto.randomUUIDv4.pipe(Effect.orDie, Effect.map((value) => DocumentId.make(value))),
-		runMutation
-	}, input, activity);
-	const duplicate = Effect.fn("Documents.duplicate")((input, activity) => runMutation({
-		action: "document.duplicate",
-		input,
-		nextDocumentId: crypto.randomUUIDv4.pipe(Effect.orDie, Effect.map((value) => DocumentId.make(value)))
-	}, activity, input.reason));
-	const unpublish = Effect.fn("Documents.unpublish")((input, activity) => runMutation({
-		action: "document.unpublish",
-		input
-	}, activity, input.reason));
-	const move = Effect.fn("Documents.move")((input, activity) => runMutation({
-		action: "document.move",
-		input
-	}, activity, input.reason));
-	const subscribeMutations = Effect.gen(function* () {
-		const subscription = yield* PubSub.subscribe(mutationEvents);
-		const baseline = yield* semaphore.withPermits(1)(Ref.get(state).pipe(Effect.map((current) => current.snapshot.generation)));
-		return {
-			baseline,
-			mutations: Stream.fromSubscription(subscription).pipe(Stream.filter((mutation) => generationIsAfter(mutation.generation, baseline)))
-		};
-	}).pipe(Effect.withSpan("Documents.subscribeMutations"));
-	const publish = Effect.fn("Documents.publish")((input, activity) => runMutation({
-		action: "document.publish",
-		input
-	}, activity, input.reason));
-	const published = semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return (yield* Ref.get(state)).published;
-	})).pipe(Effect.withSpan("Documents.published"));
-	const read = Effect.fn("Documents.read")((documentId) => semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return (yield* Ref.get(state)).activeById.get(documentId) || (yield* new DocumentNotFound({ documentId }));
-	})));
-	const refresh = semaphore.withPermits(1)(refreshUnlocked()).pipe(Effect.withSpan("Documents.refresh"));
-	const remove = Effect.fn("Documents.remove")((input, activity) => runMutation({
-		action: "document.remove",
-		input
-	}, activity, input.reason));
-	const restore = Effect.fn("Documents.restore")((input, activity) => runMutation({
-		action: "document.restore",
-		input
-	}, activity, input.reason));
-	const trash = semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return deletedEntries(yield* Ref.get(state));
-	})).pipe(Effect.withSpan("Documents.trash"));
-	const undelete = Effect.fn("Documents.undelete")((input, activity) => runMutation({
-		action: "document.undelete",
-		input
-	}, activity, input.reason));
-	const update = Effect.fn("Documents.update")((input, activity) => runMutation({
-		action: "document.update",
-		input
-	}, activity, input.reason));
-	const validate = Effect.fn("Documents.validate")((input) => semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return yield* validateDocumentUpdate(engine, yield* Ref.get(state), input);
-	})));
-	const history = documentHistoryCapability(accessControl, repository);
-	const delivery = documentDelivery(configuration, published);
-	const document = (documentId) => ({
-		documentId,
-		kind: "document"
-	});
-	const requireThen = (context, action, resource, effect) => accessControl.require(context, {
-		action,
-		resource
-	}).pipe(Effect.andThen(effect));
-	const documents = Documents.of({
-		browse: (context, query) => requireThen(context, "document.browse", query.collection ? {
-			collection: query.collection,
-			kind: "collection",
-			locale: query.locale
-		} : { kind: "catalog" }, () => browse(query)),
-		create: (context, input) => requireThen(context, "document.create", {
-			collection: input.collection,
-			kind: "collection",
-			locale: input.locale
-		}, () => create(input, requestActivity(context, input.reason))),
-		historyCompare: history.compare,
-		historyList: history.list,
-		historyRead: history.read,
-		duplicate: (context, input) => requireThen(context, "document.duplicate", document(input.documentId), () => duplicate(input, requestActivity(context, input.reason))),
-		unpublish: (context, input) => requireThen(context, "document.unpublish", document(input.documentId), () => unpublish(input, requestActivity(context, input.reason))),
-		move: (context, input) => requireThen(context, "document.move", document(input.documentId), () => move(input, requestActivity(context, input.reason))),
-		publish: (context, input) => requireThen(context, "document.publish", document(input.documentId), () => publish(input, requestActivity(context, input.reason))),
-		read: (context, documentId) => requireThen(context, "document.read", document(documentId), () => read(documentId)),
-		remove: (context, input) => requireThen(context, "document.remove", document(input.documentId), () => remove(input, requestActivity(context, input.reason))),
-		restore: (context, input) => requireThen(context, "document.restore", document(input.documentId), () => restore(input, requestActivity(context, input.reason))),
-		trash: (context) => requireThen(context, "document.trash", { kind: "catalog" }, () => trash),
-		undelete: (context, input) => requireThen(context, "document.undelete", document(input.documentId), () => undelete(input, requestActivity(context, input.reason))),
-		update: (context, input) => requireThen(context, "document.update", document(input.documentId), () => update(input, requestActivity(context, input.reason))),
-		validate: (context, input) => requireThen(context, "document.validate", document(input.documentId), () => validate(input))
-	});
-	const draftDelivery = documentDelivery(configuration, authored);
-	const previews = DocumentPreviews.of({
-		read: (context, lookup) => requireThen(context, "document.browse", { kind: "catalog" }, () => draftDelivery.read(lookup)),
-		query: (context, query) => requireThen(context, "document.browse", { kind: "catalog" }, () => draftDelivery.query(query)),
-		navigation: (context, query) => requireThen(context, "document.browse", { kind: "catalog" }, () => draftDelivery.navigation(query)),
-		surround: (context, lookup, query) => requireThen(context, "document.browse", { kind: "catalog" }, () => draftDelivery.surround(lookup, query))
-	});
-	const publishedService = PublishedDocuments.of({
-		navigation: delivery.navigation,
-		query: delivery.query,
-		read: delivery.read,
-		surround: delivery.surround,
-		diagnostics: (context) => accessControl.require(context, {
-			action: "document.browse",
-			resource: { kind: "catalog" }
-		}).pipe(Effect.andThen(delivery.diagnostics))
-	});
-	return {
-		documents,
-		maintenance: DocumentMaintenance.of({
-			importSources,
-			mediaReferences: (documentId) => semaphore.withPermits(1)(Effect.gen(function* () {
-				yield* refreshUnlocked();
-				const current = yield* Ref.get(state);
-				return projectMediaReferences(current.authored, current.published, documentId);
-			})),
-			publish,
-			read,
-			refresh,
-			subscribeMutations,
-			validate
-		}),
-		previews,
-		publishedDocuments: publishedService
-	};
+var WorkingDocumentInvalid = class extends Schema.TaggedError()("WorkingDocuments.Invalid", {
+	documentId: DocumentId,
+	message: Schema.NonEmptyString,
+	cause: Schema.Defect()
+}) {};
+var WorkingDocumentUnavailable = class extends Schema.TaggedError()("WorkingDocuments.Unavailable", {
+	operation: Schema.NonEmptyString,
+	cause: Schema.Defect()
+}) {};
+/** An authored or working baseline committed, but the publish workflow still needs recovery. */
+var WorkingDocumentCheckpointed = class extends Schema.TaggedError()("WorkingDocuments.Checkpointed", {
+	checkpointVersion: DocumentVersion,
+	documentId: DocumentId,
+	result: Schema.optionalKey(DocumentMutationResult),
+	stateVector: Schema.Uint8Array,
+	cause: Schema.Defect()
+}) {};
+const WorkingDocumentChange = Schema.Struct({
+	kind: Schema.Literals(["updated", "invalidated"]),
+	ref: WorkingDocumentRef
 });
-function documentsLayer(configuration, options) {
-	return Layer.effectContext(makeDocuments(configuration, options).pipe(Effect.map(({ documents, maintenance, previews, publishedDocuments }) => Context.empty().pipe(Context.add(Documents, documents), Context.add(DocumentMaintenance, maintenance), Context.add(DocumentPreviews, previews), Context.add(PublishedDocuments, publishedDocuments)))));
-}
-function loadRequired(repository) {
-	return repository.load().pipe(Effect.filterOrFail((snapshot) => snapshot !== void 0, () => new DocumentPersistenceError({
-		cause: /* @__PURE__ */ new Error("DocumentStore returned no initial snapshot."),
-		operation: "DocumentStore.load"
-	})));
-}
-function loadSynchronizedState(repository, engine) {
-	return Effect.gen(function* () {
-		const snapshot = yield* loadRequired(repository);
-		const state = yield* compileDocumentState(engine, snapshot);
-		yield* repository.synchronizeMediaReferences({
-			expectedGeneration: snapshot.generation,
-			references: projectMediaReferences(state.authored, state.published)
-		});
-		return state;
-	}).pipe(Effect.retry({
-		schedule: Schedule.recurs(3),
-		while: isDocumentGenerationConflict$2
-	}), Effect.mapError((error) => isDocumentGenerationConflict$2(error) || isDocumentMediaUnavailable$1(error) ? new DocumentPersistenceError({
-		cause: error,
-		operation: "Documents.synchronizeMediaReferences"
-	}) : error));
-}
-function generationIsAfter(candidate, current) {
-	return BigInt(candidate) > BigInt(current);
-}
-function enrichActivity(activity, reason) {
-	return ActivityContext.make(Object.assign({}, activity, reason === void 0 ? void 0 : { reason }));
-}
-function requestActivity(context, reason) {
-	return ActivityContext.make(Object.assign({
-		actor: context.actor,
-		requestId: context.requestId
-	}, reason === void 0 ? void 0 : { reason }));
-}
+var WorkingDocuments = class extends Context.Service()("@internal/server/WorkingDocuments") {};
 
 //#endregion
 //#region ../document/src/internal/editor/identity-extension.ts
-/** Ensures Yjs only observes authorable nodes with final, unique identities. */
 const EditorNodeIdentity = Extension.create({
 	name: "cmsNodeIdentity",
 	priority: 1e4,
@@ -3326,7 +1994,7 @@ function unwrapFirstParagraph(nodes) {
 }
 function restoreOpaqueNode(value, nodeId) {
 	const decoded = Schema.decodeUnknownOption(MarkdownNode)(value);
-	if (decoded._tag === "None" || Predicate.isString(decoded.value)) return void 0;
+	if (Option.isNone(decoded) || Predicate.isString(decoded.value)) return void 0;
 	const node = structuredClone(decoded.value);
 	if (nodeId === void 0) return node;
 	if (node[0] === null) return [
@@ -3436,10 +2104,10 @@ const PROPERTIES_NAME = "properties";
 const PROPS_PREFIX = "props:";
 const CMS_PROPS_PREFIX = "cmsProps:";
 const editorSchema$1 = createEditorSchema();
-const decodeEditorNodeId = Schema.decodeUnknownSync(EditorNodeId);
-const decodeJson$1 = Schema.decodeUnknownSync(Schema.Json);
-const decodeJsonObject$1 = Schema.decodeUnknownSync(Schema.JsonObject);
-const decodePath = Schema.decodeUnknownSync(Schema.Array(Schema.String));
+const decodeEditorNodeId = flow(Schema.decodeUnknownResult(EditorNodeId), Result.getOrThrow);
+const decodeJson$1 = flow(Schema.decodeUnknownResult(Schema.Json), Result.getOrThrow);
+const decodeJsonObject$1 = flow(Schema.decodeUnknownResult(Schema.JsonObject), Result.getOrThrow);
+const decodePath = flow(Schema.decodeUnknownResult(Schema.Array(Schema.String)), Result.getOrThrow);
 function seedCollaborationFields(document, content) {
 	const state = extractGranularState(content);
 	replaceMap(document.getMap(FRONTMATTER_NAME), flatten(state.frontmatter));
@@ -3589,9 +2257,9 @@ const METADATA_NAME = "cms";
 const META_KEY = "meta";
 const SOURCE_PATH_KEY = "sourcePath";
 const editorSchema = createEditorSchema();
-const decodeJson = Schema.decodeUnknownSync(Schema.Json);
-const decodeJsonObject = Schema.decodeUnknownSync(Schema.JsonObject);
-const decodeSourcePath = Schema.decodeUnknownSync(SourcePath);
+const decodeJson = flow(Schema.decodeUnknownResult(Schema.Json), Result.getOrThrow);
+const decodeJsonObject = flow(Schema.decodeUnknownResult(Schema.JsonObject), Result.getOrThrow);
+const decodeSourcePath = flow(Schema.decodeUnknownResult(SourcePath), Result.getOrThrow);
 function seedCollaborationDocument(sourcePath, seed, meta) {
 	const document = prosemirrorJSONToYDoc(editorSchema, seed, BODY_NAME);
 	try {
@@ -3688,7 +2356,6 @@ function sameBytes$1(left, right) {
 
 //#endregion
 //#region ../document/src/CollaborationDocument.ts
-/** Creates the initial collaborative state from the canonical editor projection. */
 const createCollaborationDocument = Effect.fn("CollaborationDocument.create")(function* (input) {
 	const seed = yield* openEditorDocument(input.body);
 	return yield* Effect.try({
@@ -3696,7 +2363,6 @@ const createCollaborationDocument = Effect.fn("CollaborationDocument.create")(fu
 		catch: (cause) => invalidCollaboration("Could not create the collaborative editor document.", cause)
 	});
 });
-/** Renders collaborative state through the canonical editor-to-Markdown encoder. */
 const renderCollaborationDocument = Effect.fn("CollaborationDocument.render")(function* (document) {
 	const inspected = yield* inspectCollaborationDocument(document);
 	return {
@@ -3715,31 +2381,26 @@ const captureCollaborationDocument = Effect.fn("CollaborationDocument.capture")(
 		catch: (cause) => invalidCollaboration("Could not capture the collaborative editor document.", cause)
 	});
 });
-/** Restores a validated, caller-owned document from a full collaboration snapshot. */
 const restoreCollaborationDocument = Effect.fn("CollaborationDocument.restore")(function* (snapshot) {
 	return yield* validateRestoredDocument(yield* Effect.try({
 		try: () => restoreCollaborationSnapshot(snapshot),
 		catch: (cause) => invalidCollaboration("Could not restore the collaborative editor document.", cause)
 	}));
 });
-/** Restores a validated document when only its authoritative full-state update is persisted. */
 const restoreCollaborationState = Effect.fn("CollaborationDocument.restoreState")(function* (state) {
 	return yield* validateRestoredDocument(yield* Effect.try({
 		try: () => restoreCollaborationUpdate(state),
 		catch: (cause) => invalidCollaboration("Could not restore the collaborative editor document.", cause)
 	}));
 });
-/** Applies one encoded collaboration update while translating corrupt data to a typed failure. */
 const applyCollaborationUpdate = Effect.fn("CollaborationDocument.applyUpdate")((document, update) => Effect.try({
 	try: () => applyCollaborationStateUpdate(document, update),
 	catch: (cause) => invalidCollaboration("Could not apply the collaborative document update.", cause)
 }));
-/** Captures the current state vector and an optional differential update. */
 const synchronizeCollaborationState = Effect.fn("CollaborationDocument.synchronizeState")((document, stateVector) => Effect.try({
 	try: () => synchronizeCollaborationStateValue(document, stateVector),
 	catch: (cause) => invalidCollaboration("Could not synchronize the collaborative document state.", cause)
 }));
-/** Releases a collaboration document owned by a scoped workflow. */
 function destroyCollaborationDocument(document) {
 	return Effect.sync(() => document.destroy());
 }
@@ -3840,6 +2501,25 @@ function sameJson(left, right) {
 	return JSON.stringify(left) === JSON.stringify(right);
 }
 
+//#endregion
+//#region ../server/src/internal/working-documents/working-document-source.ts
+const validatedWorkingDocument = Effect.fn("WorkingDocuments.validateSource")(function* (source, validate) {
+	const validation = yield* validate(UpdateDocumentInput.make({
+		documentId: source.documentId,
+		expectedVersion: source.version,
+		markdown: source.markdown
+	}));
+	if (!validation.valid || !validation.document) return yield* new WorkingDocumentInvalid({
+		cause: validation.issues,
+		documentId: source.documentId,
+		message: "Authored document cannot initialize a Working Document."
+	});
+	return validation.document;
+});
+const newWorkingSnapshot = Effect.fn("WorkingDocuments.newSnapshot")(function* (source, document, generationId) {
+	return yield* createWorkingSnapshot(source, document, yield* generationId(source.documentId));
+});
+
 //#endregion
 //#region ../server/src/internal/working-documents/working-document-reconciliation.ts
 const isDocumentNotFound$3 = Schema.is(DocumentNotFound);
@@ -3854,18 +2534,6 @@ const startWorkingDocumentReconciliation = Effect.fn("WorkingDocuments.startReco
 		})
 	}).pipe(Effect.asVoid);
 	const currentSource = (documentId) => options.documents.read(documentId).pipe(Effect.asSome, Effect.catchIf(isDocumentNotFound$3, () => Effect.succeedNone));
-	const validatedDocument = Effect.fn("WorkingDocuments.reconcile.validateSource")(function* (source) {
-		const validation = yield* options.documents.validate(UpdateDocumentInput.make({
-			documentId: source.documentId,
-			expectedVersion: source.version,
-			markdown: source.markdown
-		}));
-		if (!validation.valid || !validation.document) return yield* invalidSource(source.documentId, validation);
-		return validation.document;
-	});
-	const newSnapshot = Effect.fn("WorkingDocuments.reconcile.newSnapshot")(function* (source, document) {
-		return yield* createWorkingSnapshot(source, document, yield* options.generationId(source.documentId));
-	});
 	const rotateDirty = Effect.fn("WorkingDocuments.reconcile.rotateDirty")(function* (snapshot) {
 		const generationId = yield* options.generationId(snapshot.documentId);
 		const seed = yield* useWorkingSnapshot(snapshot, (document) => captureCollaborationDocument(document).pipe(Effect.map((captured) => rotatedSeed(snapshot, generationId, captured))));
@@ -3901,10 +2569,10 @@ const startWorkingDocumentReconciliation = Effect.fn("WorkingDocuments.startReco
 				yield* publishChange(loaded.value);
 				return;
 			}
-			const document = yield* validatedDocument(source.value);
+			const document = yield* validatedWorkingDocument(source.value, options.documents.validate);
 			yield* options.store.replace({
 				expectedGeneration: loaded.value.generationId,
-				snapshot: yield* newSnapshot(source.value, document)
+				snapshot: yield* newWorkingSnapshot(source.value, document, options.generationId)
 			});
 			yield* publishChange(loaded.value);
 		}));
@@ -3990,13 +2658,6 @@ function rotatedSeed(snapshot, generationId, captured) {
 		state: Uint8Array.from(captured.state)
 	};
 }
-function invalidSource(documentId, validation) {
-	return Effect.fail(new WorkingDocumentInvalid({
-		cause: validation.issues,
-		documentId,
-		message: "Authored document cannot initialize a Working Document."
-	}));
-}
 function generationAtOrBefore(candidate, current) {
 	return BigInt(candidate) <= BigInt(current);
 }
@@ -4004,6 +2665,28 @@ function generationsAreAdjacent(current, candidate) {
 	return BigInt(candidate) === BigInt(current) + 1n;
 }
 
+//#endregion
+//#region ../server/src/internal/working-documents/document-locks.ts
+/** Retain a lock only while an operation is running or waiting for that document. */
+function documentSynchronization() {
+	const locks = /* @__PURE__ */ new Map();
+	return (documentId, effect) => Effect.acquireUseRelease(Effect.sync(() => {
+		let lock = locks.get(documentId);
+		if (!lock) {
+			lock = {
+				semaphore: Semaphore.makeUnsafe(1),
+				users: 0
+			};
+			locks.set(documentId, lock);
+		}
+		lock.users += 1;
+		return lock;
+	}), (lock) => lock.semaphore.withPermit(effect), (lock) => Effect.sync(() => {
+		lock.users -= 1;
+		if (lock.users === 0 && locks.get(documentId) === lock) locks.delete(documentId);
+	}));
+}
+
 //#endregion
 //#region ../server/src/internal/working-documents/working-documents.ts
 function workingDocumentsLayer(options = {}) {
@@ -4017,31 +2700,11 @@ const makeWorkingDocuments = Effect.fn("WorkingDocuments.make")(function* (optio
 	const store = yield* WorkingDocumentStore;
 	const changeSource = yield* WorkingDocumentChanges;
 	const changes = yield* Effect.acquireRelease(PubSub.bounded(64), PubSub.shutdown);
-	const locks = /* @__PURE__ */ new Map();
+	const synchronized = documentSynchronization();
 	const compactAfterUpdates = validCompactionLimit(options.compactAfterUpdates);
-	const synchronized = (documentId, effect) => Effect.suspend(() => {
-		let semaphore = locks.get(documentId);
-		if (!semaphore) {
-			semaphore = Semaphore.makeUnsafe(1);
-			locks.set(documentId, semaphore);
-		}
-		return semaphore.withPermit(effect);
-	});
 	const generationId = (documentId) => crypto.randomUUIDv4.pipe(Effect.map((uuid) => WorkingDocumentGenerationId.make(uuid)), Effect.mapError((cause) => invalid(documentId, "Could not create a working document generation.", cause)));
 	const attemptId = (documentId) => crypto.randomUUIDv4.pipe(Effect.map((uuid) => WorkingDocumentPublishAttemptId.make(uuid)), Effect.mapError((cause) => invalid(documentId, "Could not create a publish attempt.", cause)));
 	const markdownHash = (documentId, markdown) => crypto.digest("SHA-256", new TextEncoder().encode(markdown)).pipe(Effect.map(hex), Effect.mapError((cause) => invalid(documentId, "Could not fingerprint Working Document Markdown.", cause)));
-	const validatedDocument = Effect.fn("WorkingDocuments.validateSource")(function* (source) {
-		const validation = yield* maintenance.validate(UpdateDocumentInput.make({
-			documentId: source.documentId,
-			expectedVersion: source.version,
-			markdown: source.markdown
-		}));
-		if (!validation.valid || !validation.document) return yield* invalid(source.documentId, "Authored document cannot initialize a Working Document.", validation.issues);
-		return validation.document;
-	});
-	const newSnapshot = Effect.fn("WorkingDocuments.newSnapshot")(function* (source, document) {
-		return yield* createWorkingSnapshot(source, document, yield* generationId(source.documentId));
-	});
 	const compactSnapshot = Effect.fn("WorkingDocuments.compactSnapshot")(function* (snapshot) {
 		const lastUpdate = snapshot.updates.at(-1);
 		if (!lastUpdate) return false;
@@ -4121,21 +2784,21 @@ const makeWorkingDocuments = Effect.fn("WorkingDocuments.make")(function* (optio
 	const ensureOpenSnapshot = Effect.fn("WorkingDocuments.ensureOpenSnapshot")(function* (source) {
 		const loaded = yield* store.load(source.documentId);
 		if (Option.isNone(loaded)) {
-			const document = yield* validatedDocument(source);
-			const initialized = yield* store.initialize(yield* newSnapshot(source, document));
+			const document = yield* validatedWorkingDocument(source, maintenance.validate);
+			const initialized = yield* store.initialize(yield* newWorkingSnapshot(source, document, generationId));
 			if (initialized.savedVersion === source.version) return initialized;
 			if (yield* workingSnapshotIsDirty(initialized)) return initialized;
 			return yield* store.replace({
 				expectedGeneration: initialized.generationId,
-				snapshot: yield* newSnapshot(source, document)
+				snapshot: yield* newWorkingSnapshot(source, document, generationId)
 			});
 		}
 		if (loaded.value.savedVersion === source.version) return loaded.value;
 		if (yield* workingSnapshotIsDirty(loaded.value)) return loaded.value;
-		const document = yield* validatedDocument(source);
+		const document = yield* validatedWorkingDocument(source, maintenance.validate);
 		return yield* store.replace({
 			expectedGeneration: loaded.value.generationId,
-			snapshot: yield* newSnapshot(source, document)
+			snapshot: yield* newWorkingSnapshot(source, document, generationId)
 		});
 	});
 	const open = (context, documentId) => synchronized(documentId, Effect.gen(function* () {
@@ -4359,7 +3022,7 @@ function closeHocuspocus(hocuspocus, operations) {
 			const store = hocuspocus.debouncer.executeNow(`onStoreDocument-${document.name}`);
 			return store === void 0 ? [] : [store];
 		});
-		yield* Effect.promise(() => Promise.allSettled(stores));
+		const storeResults = yield* Effect.promise(() => Promise.allSettled(stores));
 		yield* Effect.promise(operations.drain);
 		const cleanupResults = yield* Effect.promise(() => Promise.allSettled(documents.map((document) => document.saveMutex.runExclusive(() => Promise.resolve()).then(() => hocuspocus.unloadDocument(document)))));
 		const destroyResult = yield* Effect.result(Effect.tryPromise({
@@ -4367,6 +3030,8 @@ function closeHocuspocus(hocuspocus, operations) {
 			catch: (cause) => gatewayError("close", cause)
 		}).pipe(Effect.asVoid));
 		const cleanupFailure = cleanupResults.find((result) => result.status === "rejected");
+		const storeFailure = storeResults.find((result) => result.status === "rejected");
+		if (storeFailure?.status === "rejected") return yield* gatewayError("close", storeFailure.reason);
 		if (cleanupFailure?.status === "rejected") return yield* gatewayError("close", cleanupFailure.reason);
 		if (Result.isFailure(destroyResult)) return yield* destroyResult.failure;
 	});
@@ -4380,7 +3045,6 @@ function gatewayError(operation, cause) {
 
 //#endregion
 //#region ../platform-node/src/internal/realtime/keyed-operations.ts
-/** Serializes each room independently and retains poisoned writes for shutdown reporting. */
 function createKeyedOperations(options) {
 	const pending = /* @__PURE__ */ new Map();
 	const failures = /* @__PURE__ */ new Map();
@@ -4474,7 +3138,6 @@ function stableStringHash(value) {
 //#region ../platform-node/src/internal/realtime/wake-dispatcher.ts
 const DEFAULT_CAPACITY = 1024;
 const DEFAULT_CONCURRENCY = 32;
-/** Bounded wake scheduling: duplicate rooms coalesce and unrelated rooms run concurrently. */
 const runStudioRealtimeWakeDispatcher = Effect.fn("StudioRealtimeWakeDispatcher.run")(function* (wakes, handle, options = {}) {
 	const queue = yield* Queue.dropping(options.capacity ?? DEFAULT_CAPACITY);
 	const queued = /* @__PURE__ */ new Set();
@@ -4687,7 +3350,7 @@ const makeStudioRealtimeRoomHost = Effect.fn("StudioRealtimeRoomHost.make")(func
 		},
 		onStateless: (payload) => runTracked(Effect.gen(function* () {
 			const decoded = yield* Effect.option(decodeClientMessage(payload.payload));
-			if (decoded._tag === "None" || decoded.value.type !== "checkpoint") return;
+			if (Option.isNone(decoded) || decoded.value.type !== "checkpoint") return;
 			const name = yield* decodeRoomName(payload.documentName).pipe(Effect.mapError((cause) => roomHostError("checkpoint", cause)));
 			const stateVector = Y.encodeStateVector(payload.document);
 			yield* Effect.tryPromise({
@@ -4820,7 +3483,9 @@ function decodeBytes(value, tokenInvalid) {
 		try: () => {
 			const normalized = value.replaceAll("-", "+").replaceAll("_", "/");
 			const binary = atob(normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "="));
-			return Uint8Array.from(binary, (character) => character.codePointAt(0) ?? 0);
+			const bytes = Uint8Array.from(binary, (character) => character.codePointAt(0) ?? 0);
+			if (encodeBytes(bytes) !== value) throw new Error("Noncanonical base64url encoding");
+			return bytes;
 		},
 		catch: tokenInvalid
 	});
@@ -4962,7 +3627,7 @@ const makeStudioRealtimeGateway = Effect.gen(function* () {
 		onStateless: (payload) => {
 			return runTracked(Effect.gen(function* () {
 				const decoded = yield* Effect.option(decodeClientMessage(payload.payload));
-				if (decoded._tag === "None") return;
+				if (Option.isNone(decoded)) return;
 				const request = decoded.value;
 				const context = authenticatedContext(payload.connection.context, payload.documentName);
 				if (request.type === "checkpoint") return;
@@ -5172,11 +3837,10 @@ function httpProtocol(protocol) {
 * StudioRealtimeRoomHost synchronizes durable Yjs state across replicas. Presence
 * and stateless broadcasts remain process-local until an ephemeral bus is added.
 */
-const studioRealtimeGatewayLayer = Layer.effect(StudioRealtimeGateway, Effect.acquireRelease(makeStudioRealtimeGateway, (gateway) => gateway.close.pipe(Effect.catchCause((cause) => Effect.logError("Studio realtime gateway shutdown failed.", cause)))));
+const studioRealtimeGatewayLayer = Layer.effect(StudioRealtimeGateway, Effect.acquireRelease(makeStudioRealtimeGateway, (gateway) => gateway.close.pipe(Effect.tapError((error) => Effect.logError("Studio realtime gateway shutdown failed.", error)), Effect.orDie)));
 
 //#endregion
 //#region ../platform-node/src/internal/realtime/websocket.ts
-/** Hides Hocuspocus connection bookkeeping from framework WebSocket adapters. */
 function studioRealtimeWebSocketBridge(gateway) {
 	const connections = /* @__PURE__ */ new WeakMap();
 	const release = (socket) => {
@@ -5201,21 +3865,25 @@ function studioRealtimeWebSocketBridge(gateway) {
 //#endregion
 //#region ../platform-node/src/internal/installation/host.ts
 var Installation = class extends Context.Service()("@internal/platform-node/Installation") {};
-function installationHttpLayer(bootstrap, application, cleanup) {
+function installationHttpLayer(bootstrap, cleanup) {
 	return Layer.effect(Installation, Effect.gen(function* () {
-		const outerContext = yield* Effect.context();
 		const cleanupContext = yield* Effect.context();
-		const memoMap = Context.getUnsafe(outerContext, Layer.CurrentMemoMap);
-		const webHandler = yield* Effect.acquireRelease(Effect.sync(() => HttpRouter.toWebHandler(application, { memoMap })), ({ dispose }) => Effect.promise(dispose));
-		return yield* makeInstallation(bootstrap, webHandler.handler, (context) => cleanup(context).pipe(Effect.provide(cleanupContext)));
+		const routerConfig = yield* HttpRouter.RouterConfig;
+		const router = yield* HttpRouter.HttpRouter;
+		const handle = HttpEffect.toWebHandlerWith(yield* Effect.context())(router.asHttpEffect(), HttpMiddleware.logger);
+		return yield* makeInstallation(bootstrap, handle, (context) => cleanup(context).pipe(Effect.provide(cleanupContext)), routerConfig);
 	}));
 }
-const makeInstallation = Effect.fn("Installation.make")(function* (bootstrap, handle, cleanup) {
+const makeInstallation = Effect.fn("Installation.make")(function* (bootstrap, handle, cleanup, routerConfig) {
 	const authentication = yield* AuthenticationHandler;
 	const crypto = yield* Crypto.Crypto;
 	const realtime = yield* StudioRealtimeGateway;
 	const roomHost = yield* StudioRealtimeRoomHost;
-	const health = (yield* Readiness).check.pipe(Effect.andThen(roomHost.check), Effect.match({
+	const readiness = yield* Readiness;
+	const protectedRoutes = FindMyWay.make(routerConfig);
+	protectedRoutes.all(CMS_FORM_SUBMIT_PATH, "form");
+	protectedRoutes.all(`${STUDIO_API_PATH}/preview/*`, "preview");
+	const health = readiness.check.pipe(Effect.andThen(roomHost.check), Effect.match({
 		onFailure: () => ({
 			live: true,
 			ready: false
@@ -5241,13 +3909,15 @@ const makeInstallation = Effect.fn("Installation.make")(function* (bootstrap, ha
 		cleanupMedia,
 		fetch: (request) => {
 			const pathname = new URL(request.url).pathname;
+			const protection = protectedRoutes.find(request.method, pathname)?.handler;
+			if (protection === "form") return handleFormRequest(request, handle);
 			if (pathname === "/api/cms/auth" || pathname.startsWith(`${"/api/cms/auth"}/`)) return authentication.handle(request);
 			if (pathname === CMS_LIVENESS_PATH) return Promise.resolve(healthResponse({
 				live: true,
 				ready: true
 			}, false));
 			if (pathname === CMS_READINESS_PATH) return runPromise(health).then((status) => healthResponse(status, true));
-			if (pathname.startsWith(`${STUDIO_API_PATH}/preview/`)) return handle(request).then((response) => {
+			if (protection === "preview") return handle(request).then((response) => {
 				response.headers.set("cache-control", "private, no-store");
 				return response;
 			});
@@ -5295,21 +3965,6 @@ const startInstallation = Effect.fn("CmsInstallation.start")(function* (options)
 	};
 });
 
-//#endregion
-//#region ../server/src/internal/media/media-object-store.ts
-var MediaObjectStore = class extends Context.Service()("@internal/server/MediaObjectStore") {};
-
-//#endregion
-//#region ../server/src/internal/media/media-failures.ts
-var MediaPersistenceError = class extends Schema.TaggedError()("Media.PersistenceError", {
-	operation: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-var MediaStorageError = class extends Schema.TaggedError()("Media.StorageError", {
-	operation: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-
 //#endregion
 //#region ../server/src/internal/media/media-change.ts
 const MediaUploadIntent = Schema.Struct({
@@ -5472,7 +4127,7 @@ function makeMediaChange(input) {
 		action: input.action,
 		context: input.change.context,
 		id: input.change.id,
-		intent: Schema.encodeSync(MediaChangeIntent)(input.intent),
+		intent: Result.getOrThrow(Schema.encodeResult(MediaChangeIntent)(input.intent)),
 		scope: "media",
 		subject: input.subject,
 		target: input.target
@@ -5481,55 +4136,43 @@ function makeMediaChange(input) {
 
 //#endregion
 //#region ../server/src/internal/media/media-reconciliation.ts
-function recoverPendingMedia(store, objectStore, operations, recoveryAge, options = {}) {
+const recoveryBatchSize = 100;
+function recoverPendingMedia(store, objectStore, operations, recoveryAge, cursor = {}) {
 	return Effect.gen(function* () {
 		const before = DateTime.subtractDuration(yield* DateTime.now, recoveryAge);
-		const maxBatches = options.maxBatches ?? Number.POSITIVE_INFINITY;
-		const recoverBatch = Effect.gen(function* () {
-			const pending = yield* store.pending({
-				before,
-				limit: 100
-			});
-			for (const record of pending) {
-				if (record.status === "deleting") {
+		const pending = yield* store.pending({
+			after: cursor.media,
+			before,
+			limit: recoveryBatchSize
+		});
+		for (const record of pending) {
+			if (record.status === "deleting") {
+				yield* objectStore.remove(record.objectKey);
+				yield* store.finishDelete(record.id);
+				continue;
+			}
+			const stored = yield* objectStore.stat(record.objectKey);
+			if (Option.isSome(stored) && stored.value.byteSize === record.byteSize && (stored.value.mimeType === void 0 || stored.value.mimeType === record.mimeType)) yield* store.activate(record.id);
+			else {
+				if (Option.isSome(stored)) {
 					yield* objectStore.remove(record.objectKey);
-					yield* store.finishDelete(record.id);
-					continue;
-				}
-				const stored = yield* objectStore.stat(record.objectKey);
-				if (Option.isSome(stored) && stored.value.byteSize === record.byteSize && (stored.value.mimeType === void 0 || stored.value.mimeType === record.mimeType)) yield* store.activate(record.id);
-				else {
-					if (Option.isSome(stored)) {
-						yield* objectStore.remove(record.objectKey);
-						const remaining = yield* objectStore.stat(record.objectKey);
-						if (Option.isSome(remaining)) continue;
-					}
-					yield* store.abandonUpload(record.id);
+					const remaining = yield* objectStore.stat(record.objectKey);
+					if (Option.isSome(remaining)) continue;
 				}
+				yield* store.abandonUpload(record.id);
 			}
-			return pending.length < 100;
-		});
-		let mediaBatch = 0;
-		let mediaComplete = false;
-		while (!mediaComplete && mediaBatch < maxBatches) {
-			mediaComplete = yield* recoverBatch;
-			mediaBatch += 1;
 		}
-		const recoverReplacementBatch = Effect.gen(function* () {
-			const replacements = yield* store.pendingReplacements({
-				before,
-				limit: 100
-			});
-			yield* Effect.forEach(replacements, (replacement) => recoverReplacement(store, objectStore, replacement).pipe(Effect.catchTag("Media.Conflict", () => Effect.void)), { discard: true });
-			return replacements.length < 100;
+		const replacements = yield* store.pendingReplacements({
+			after: cursor.replacements,
+			before,
+			limit: recoveryBatchSize
 		});
-		let replacementBatch = 0;
-		let replacementsComplete = false;
-		while (!replacementsComplete && replacementBatch < maxBatches) {
-			replacementsComplete = yield* recoverReplacementBatch;
-			replacementBatch += 1;
-		}
+		yield* Effect.forEach(replacements, (replacement) => recoverReplacement(store, objectStore, replacement).pipe(Effect.catchTag("Media.Conflict", () => Effect.void)), { discard: true });
 		yield* recoverPendingMediaCleanup(operations, objectStore, before);
+		return {
+			media: pending.length < recoveryBatchSize ? void 0 : pending.at(-1)?.id,
+			replacements: replacements.length < recoveryBatchSize ? void 0 : replacements.at(-1)?.mediaId
+		};
 	});
 }
 function recoverPendingMediaCleanup(operations, objectStore, before) {
@@ -5717,10 +4360,14 @@ const makeMediaLibrary = Effect.fn("MediaLibrary.make")(function* (options) {
 	const store = yield* MediaStore;
 	const baseUrl = options.publicBaseUrl.replace(/\/+$/gu, "");
 	const pendingRecoveryAge = options.pendingRecoveryAge ?? "5 minutes";
-	yield* recoverPendingMedia(store, objectStore, operations, pendingRecoveryAge);
+	const recoveryCursor = yield* Ref.make(yield* recoverPendingMedia(store, objectStore, operations, pendingRecoveryAge));
 	const mutations = yield* Semaphore.make(1);
 	const recoveryInterval = options.pendingRecoveryInterval ?? MEDIA_OPERATION_RECOVERY_INTERVAL;
-	if (recoveryInterval !== false) yield* mutations.withPermits(1)(recoverPendingMedia(store, objectStore, operations, pendingRecoveryAge, { maxBatches: 1 })).pipe(Effect.catch((error) => Effect.logWarning("Pending media change recovery sweep failed.", { errorTag: error._tag }))).pipe(Effect.repeat(Schedule.spaced(recoveryInterval)), Effect.delay(recoveryInterval), Effect.forkScoped({ startImmediately: true }));
+	if (recoveryInterval !== false) yield* mutations.withPermits(1)(Effect.gen(function* () {
+		const cursor = yield* Ref.get(recoveryCursor);
+		const next = yield* recoverPendingMedia(store, objectStore, operations, pendingRecoveryAge, cursor);
+		yield* Ref.set(recoveryCursor, next);
+	})).pipe(Effect.catch((error) => Effect.logWarning("Pending media change recovery sweep failed.", { errorTag: error._tag }))).pipe(Effect.repeat(Schedule.spaced(recoveryInterval)), Effect.delay(recoveryInterval), Effect.forkScoped({ startImmediately: true }));
 	const toAsset = (record) => MediaAsset.make({
 		byteSize: record.byteSize,
 		createdAt: record.createdAt,
@@ -5789,7 +4436,7 @@ const makeMediaLibrary = Effect.fn("MediaLibrary.make")(function* (options) {
 		return yield* Effect.scoped(prepareUpload(input).pipe(Effect.flatMap((prepared) => mutations.withPermits(1)(Effect.gen(function* () {
 			const id = MediaId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
 			const operationId = ActivityId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
-			const objectKey = MediaObjectKey.make(`media/${id}.${imageExtension(prepared.mimeType)}`);
+			const objectKey = MediaObjectKey.make(`${mediaObjectPrefix}${id}.${imageExtension(prepared.mimeType)}`);
 			const now = yield* DateTime.now;
 			const reserved = yield* store.reserve({
 				byteSize: input.metadata.declaredByteSize,
@@ -5837,7 +4484,7 @@ const makeMediaLibrary = Effect.fn("MediaLibrary.make")(function* (options) {
 				name: input.metadata.name,
 				objectKey: current.value.objectKey,
 				staged: false,
-				stagingObjectKey: MediaObjectKey.make(`media/replacements/${operationId}.${imageExtension(prepared.mimeType)}`),
+				stagingObjectKey: MediaObjectKey.make(`${mediaObjectPrefix}replacements/${operationId}.${imageExtension(prepared.mimeType)}`),
 				updatedAt: timestamp
 			};
 			const pendingReplacement = yield* store.beginReplace(replacement, {
@@ -5960,11 +4607,42 @@ function cleanupBeforePromotionBestEffort(cleanup) {
 		onSuccess: () => Effect.void
 	}));
 }
-function activityFailure(operation) {
-	return (cause) => new ActivityUnavailable({
-		cause,
-		operation
+function activityFailure(operation) {
+	return (cause) => new ActivityUnavailable({
+		cause,
+		operation
+	});
+}
+
+//#endregion
+//#region ../server/src/ProductModules.ts
+function productModulesLayer(options) {
+	const accessControl = defaultAccessControlLayer;
+	const seo = seoLayer(options.bootstrap.seo ?? makeDefaultSeoOptions(options.baseUrl)).pipe(Layer.provide(accessControl));
+	const authoredDocuments = documentsLayer(options.bootstrap.documents, {
+		...options.documentEngine,
+		components: options.documentEngine.components ?? [],
+		mediaBaseUrl: options.documentEngine.mediaBaseUrl ?? "https://media.invalid"
+	}).pipe(Layer.provide(accessControl));
+	const documentAccess = Layer.merge(authoredDocuments, accessControl);
+	const activity = activityLayer.pipe(Layer.provide(accessControl));
+	const workingDocuments = workingDocumentsLayer(options.workingDocuments).pipe(Layer.provide(documentAccess));
+	const seoDelivery = seoDeliveryLayer.pipe(Layer.provide(Layer.merge(documentAccess, seo)));
+	return Layer.mergeAll(activity, documentAccess, workingDocuments, seo, seoDelivery, readinessLayer);
+}
+function productModulesWithMediaLayer(options) {
+	const products = productModulesLayer({
+		...options,
+		documentEngine: {
+			...options.documentEngine,
+			mediaBaseUrl: options.documentEngine.mediaBaseUrl ?? options.mediaPublicBaseUrl
+		}
 	});
+	const media = mediaLibraryLayer({
+		maxUploadBytes: options.bootstrap.media.maxUploadBytes,
+		publicBaseUrl: options.mediaPublicBaseUrl
+	}).pipe(Layer.provide(products));
+	return Layer.merge(products, media);
 }
 
 //#endregion
@@ -5974,7 +4652,6 @@ var Initialization = class extends Context.Service()("@internal/server/Initializ
 function initializationLayer(options) {
 	return Layer.effect(Initialization, Effect.gen(function* () {
 		const journal = yield* ChangeJournal;
-		const documentOperations = yield* DocumentMaintenance;
 		const crypto = yield* Crypto.Crypto;
 		const identity = yield* InitialIdentity;
 		const recovery = yield* InitialIdentityRecovery;
@@ -6013,15 +4690,6 @@ function initializationLayer(options) {
 				intent: prepared.intent
 			});
 			if (!(yield* store.claim(durableClaim))) return yield* new InitializationAlreadyCompleted();
-			const imported = yield* documentOperations.importSources(DocumentImportInput.make({
-				mode: "preserve",
-				reason: "CMS initialization",
-				sources: options.initialSources ?? []
-			}), context).pipe(Effect.result);
-			if (Result.isFailure(imported)) {
-				yield* store.reset(changeId);
-				return yield* imported.failure;
-			}
 			const begin = yield* journal.begin(initialAdministratorDraft({
 				context,
 				id: changeId
@@ -6067,20 +4735,21 @@ const reconcileStored = Effect.fn("Initialization.reconcileStored")(function* (s
 		id: state.claim.changeId
 	}, state.claim.intent);
 	const begin = yield* journal.begin(draft).pipe(Effect.mapError((cause) => unavailable$3("Initialization.recover", cause)));
-	switch (begin._tag) {
-		case "Recorded":
-			yield* store.complete(state.claim.changeId);
-			return yield* store.read;
-		case "Cancelled":
-			yield* store.reset(state.claim.changeId);
-			return yield* store.read;
-		case "Unresolved": {
-			const resolution = yield* reconcileInitialAdministrator(journal, begin.change, recovery.observe).pipe(Effect.mapError((cause) => unavailable$3("Initialization.recover", cause)));
-			if (resolution.kind === "applied") yield* store.complete(state.claim.changeId);
-			if (resolution.kind === "cancelled") yield* store.reset(state.claim.changeId);
-			return yield* store.read;
-		}
+	if (Predicate.isTagged("Recorded")(begin)) {
+		yield* store.complete(state.claim.changeId);
+		return yield* store.read;
+	}
+	if (Predicate.isTagged("Cancelled")(begin)) {
+		yield* store.reset(state.claim.changeId);
+		return yield* store.read;
 	}
+	if (Predicate.isTagged("Unresolved")(begin)) {
+		const resolution = yield* reconcileInitialAdministrator(journal, begin.change, recovery.observe).pipe(Effect.mapError((cause) => unavailable$3("Initialization.recover", cause)));
+		if (resolution.kind === "applied") yield* store.complete(state.claim.changeId);
+		if (resolution.kind === "cancelled") yield* store.reset(state.claim.changeId);
+		return yield* store.read;
+	}
+	return yield* store.read;
 });
 function completeBestEffort(store, changeId) {
 	return store.complete(changeId).pipe(Effect.catch((error) => Effect.logWarning("Initialization completion remains recoverable.", {
@@ -6281,6 +4950,69 @@ function targetError(operation) {
 	return (error) => Schema.is(UserAlreadyExists)(error) ? unavailable$2(operation)(error) : error;
 }
 
+//#endregion
+//#region ../server/src/Forms.ts
+/** Only the currently published definition can authorize a submission. Never trust client rules. */
+const submitForm = Effect.fn("Forms.submit")(function* (input, components, handlers) {
+	const document = yield* (yield* PublishedDocuments).read({
+		kind: "id",
+		documentId: input.documentId
+	}).pipe(Effect.orElseSucceed(() => void 0));
+	if (!document) return FormResult.make({
+		status: "unavailable",
+		errors: {}
+	});
+	const form = documentForms(document, components).find((candidate) => JSON.stringify(candidate.nodePath) === JSON.stringify(input.nodePath));
+	if (!form || form.revision !== input.revision) return FormResult.make({
+		status: "stale",
+		errors: {}
+	});
+	const handler = Object.hasOwn(handlers, form.name) ? handlers[form.name] : void 0;
+	if (!handler) return FormResult.make({
+		status: "unavailable",
+		errors: {}
+	});
+	const fields = form.steps.flatMap((step) => step.fields);
+	const errors = validateFormValues(fields, input.values);
+	if (Object.keys(input.values).some((id) => !fields.some((field) => field.id === id))) errors._form = "The submission contains unknown answers.";
+	if (Object.keys(errors).length) return FormResult.make({
+		status: "invalid",
+		errors
+	});
+	const values = Object.fromEntries(fields.map((field) => [field.id, normalizedAnswer(Object.hasOwn(input.values, field.id) ? input.values[field.id] : void 0)]));
+	return yield* Effect.tryPromise(() => Promise.resolve(handler({
+		form,
+		values
+	}))).pipe(Effect.as(FormResult.make({
+		status: "accepted",
+		errors: {}
+	})), Effect.orElseSucceed(() => FormResult.make({
+		status: "failed",
+		errors: {}
+	})));
+});
+function normalizedAnswer(value) {
+	return value === void 0 || Predicate.isString(value) && !value.trim() ? null : value;
+}
+
+//#endregion
+//#region ../platform-node/src/internal/http/forms.ts
+function formsApiLayer(components, handlers) {
+	return HttpApiBuilder.group(StudioApi, "forms", (group) => Effect.gen(function* () {
+		const documents = yield* PublishedDocuments;
+		const limiter = yield* RateLimiter.RateLimiter;
+		return group.handle("submit", ({ payload }) => limiter.consume({
+			key: "cms-forms",
+			limit: 60,
+			window: "1 minute",
+			onExceeded: "fail"
+		}).pipe(Effect.andThen(submitForm(payload, components, handlers).pipe(Effect.provideService(PublishedDocuments, documents))), Effect.orElseSucceed(() => FormResult.make({
+			status: "unavailable",
+			errors: {}
+		}))));
+	})).pipe(Layer.provide(RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory))));
+}
+
 //#endregion
 //#region ../platform-node/src/internal/http/errors.ts
 const studioSchemaErrorLayer = HttpApiMiddleware.layerSchemaErrorTransform(StudioSchemaError, (error) => Effect.fail(mapStudioSchemaError(error.kind)));
@@ -6345,6 +5077,7 @@ const isAccessDenied$1 = Schema.is(AccessDenied);
 const isDocumentNotFound$1 = Schema.is(DocumentNotFound);
 const isDocumentVersionConflict = Schema.is(DocumentVersionConflict);
 const isDocumentGenerationConflict = Schema.is(DocumentGenerationConflict);
+const isContentTransferConflict = Schema.is(ContentTransferConflict);
 const isPublicMutationError = Schema.is(Schema.Union([
 	AccessDenied,
 	DocumentMediaUnavailable,
@@ -6384,6 +5117,10 @@ const documentsApiLayer = HttpApiBuilder.group(StudioApi, "documents", (handlers
 		...payload
 	}))).pipe(mapMutationError));
 }));
+const contentApiLayer = HttpApiBuilder.group(StudioApi, "content", (handlers) => Effect.gen(function* () {
+	const documents = yield* Documents;
+	return handlers.handle("snapshot", () => withStudioRequest((context) => documents.contentSnapshot(context)).pipe(preservePublicErrors(isAccessDenied$1))).handle("plan", ({ payload }) => withStudioRequest((context) => documents.contentPlan(context, payload)).pipe(preservePublicErrors((error) => isAccessDenied$1(error) || isContentTransferConflict(error)))).handle("apply", ({ payload }) => withStudioRequest((context) => documents.contentApply(context, payload)).pipe(preservePublicErrors((error) => isAccessDenied$1(error) || isContentTransferConflict(error) || Schema.is(DocumentValidationFailed)(error))));
+}));
 function mapMutationError(effect) {
 	return effect.pipe(Effect.mapError((error) => {
 		if (isPublicMutationError(error)) return error;
@@ -6462,7 +5199,7 @@ function decodeMediaUpload(payload, query, maxUploadBytes) {
 }
 function mapMultipartError(error) {
 	if (isMediaInvalid(error)) return error;
-	return error.reason._tag === "InternalError" ? studioInternalError() : invalidMultipart();
+	return Predicate.isTagged("InternalError")(error.reason) ? studioInternalError() : invalidMultipart();
 }
 function invalidMultipart() {
 	return new MediaInvalid({ message: "Upload exactly one file whose body matches its declared size." });
@@ -6474,7 +5211,16 @@ const publicError = Schema.is(Schema.Union([AccessDenied, PublishedDocumentNotFo
 const denied = Schema.is(AccessDenied);
 const previewApiLayer = HttpApiBuilder.group(StudioApi, "previewDelivery", (handlers) => Effect.gen(function* () {
 	const documents = yield* DocumentPreviews;
-	return handlers.handle("read", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.read(context, payload)), preservePublicErrors(publicError))).handle("query", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.query(context, payload)), preservePublicErrors(denied))).handle("navigation", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.navigation(context, payload)), preservePublicErrors(denied))).handle("surround", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.surround(context, payload.lookup, payload.query)), preservePublicErrors(publicError)));
+	const accessControl = yield* AccessControl;
+	const seo = yield* PreviewSeo;
+	const seoDelivery = yield* SeoDelivery;
+	return handlers.handle("read", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.read(context, payload).pipe(Effect.flatMap((document) => seoDelivery.previewDocument(document)))), preservePublicErrors(publicError))).handle("query", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.query(context, payload).pipe(Effect.flatMap((page) => Effect.forEach(page.items, (document) => seoDelivery.previewDocument(document)).pipe(Effect.map((items) => Object.assign({}, page, { items })))))), preservePublicErrors(denied))).handle("navigation", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.navigation(context, payload)), preservePublicErrors(denied))).handle("surround", ({ payload }) => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.surround(context, payload.lookup, payload.query).pipe(Effect.flatMap((surround) => Effect.all({
+		previous: surround.previous ? seoDelivery.previewDocument(surround.previous) : Effect.succeed(null),
+		next: surround.next ? seoDelivery.previewDocument(surround.next) : Effect.succeed(null)
+	})))), preservePublicErrors(publicError))).handle("seo", () => CurrentStudioRequest.pipe(Effect.flatMap((context) => accessControl.require(context, {
+		action: "document.browse",
+		resource: { kind: "catalog" }
+	}).pipe(Effect.andThen(seo.read))), preservePublicErrors(denied)));
 }));
 
 //#endregion
@@ -6482,7 +5228,15 @@ const previewApiLayer = HttpApiBuilder.group(StudioApi, "previewDelivery", (hand
 const isPublishedDocumentNotFound = Schema.is(PublishedDocumentNotFound);
 const deliveryApiLayer = Layer.merge(HttpApiBuilder.group(StudioApi, "delivery", (handlers) => Effect.gen(function* () {
 	const documents = yield* PublishedDocuments;
-	return handlers.handle("read", ({ payload }) => documents.read(payload).pipe(preservePublicErrors(isPublishedDocumentNotFound))).handle("query", ({ payload }) => documents.query(payload).pipe(mapUnexpectedError)).handle("navigation", ({ payload }) => documents.navigation(payload).pipe(mapUnexpectedError)).handle("surround", ({ payload }) => documents.surround(payload.lookup, payload.query).pipe(preservePublicErrors(isPublishedDocumentNotFound)));
+	const seo = yield* PublishedSeo;
+	const seoDelivery = yield* SeoDelivery;
+	return handlers.handle("read", ({ payload }) => documents.read(payload).pipe(Effect.flatMap(seoDelivery.publishedDocument), preservePublicErrors(isPublishedDocumentNotFound))).handle("query", ({ payload }) => documents.query(payload).pipe(Effect.flatMap((page) => Effect.forEach(page.items, seoDelivery.publishedDocument).pipe(Effect.map((items) => ({
+		items,
+		total: page.total
+	})))), mapUnexpectedError)).handle("navigation", ({ payload }) => documents.navigation(payload).pipe(mapUnexpectedError)).handle("surround", ({ payload }) => documents.surround(payload.lookup, payload.query).pipe(Effect.flatMap((surround) => Effect.all({
+		previous: surround.previous ? seoDelivery.publishedDocument(surround.previous) : Effect.succeed(null),
+		next: surround.next ? seoDelivery.publishedDocument(surround.next) : Effect.succeed(null)
+	})), preservePublicErrors(isPublishedDocumentNotFound))).handle("seo", () => seo.read.pipe(mapUnexpectedError)).handle("sitemap", () => seoDelivery.sitemap.pipe(mapUnexpectedError));
 })), HttpApiBuilder.group(StudioApi, "diagnostics", (handlers) => Effect.gen(function* () {
 	const documents = yield* PublishedDocuments;
 	return handlers.handle("documents", () => CurrentStudioRequest.pipe(Effect.flatMap((context) => documents.diagnostics(context)), preservePublicErrors(Schema.is(AccessDenied))));
@@ -6498,6 +5252,12 @@ const isHistoryPublicError = Schema.is(Schema.Union([
 	DocumentNotFound
 ]));
 const isInitializationPublicError = Schema.is(Schema.Union([InitializationAlreadyCompleted, InitializationProofInvalid]));
+const isSeoPublicError = Schema.is(Schema.Union([
+	AccessDenied,
+	SeoConfirmationRequired,
+	SeoMediaUnavailable,
+	SeoVersionConflict
+]));
 const administrationApiLayer = Layer.mergeAll(HttpApiBuilder.group(StudioApi, "initialization", (handlers) => Effect.gen(function* () {
 	const initialization = yield* Initialization;
 	return handlers.handle("status", () => initialization.status.pipe(mapUnexpectedError)).handle("claim", ({ payload }) => initialization.claim(payload).pipe(preservePublicErrors(isInitializationPublicError)));
@@ -6507,6 +5267,9 @@ const administrationApiLayer = Layer.mergeAll(HttpApiBuilder.group(StudioApi, "i
 })), HttpApiBuilder.group(StudioApi, "activity", (handlers) => Effect.gen(function* () {
 	const activity = yield* Activity;
 	return handlers.handle("list", ({ query }) => withStudioRequest((context) => activity.list(context, query)).pipe(preservePublicErrors(isActivityPublicError)));
+})), HttpApiBuilder.group(StudioApi, "seo", (handlers) => Effect.gen(function* () {
+	const seo = yield* Seo;
+	return handlers.handle("read", () => withStudioRequest((context) => seo.read(context)).pipe(preservePublicErrors(isSeoPublicError))).handle("save", ({ payload }) => withStudioRequest((context) => seo.save(context, payload)).pipe(preservePublicErrors(isSeoPublicError))).handle("publish", ({ payload }) => withStudioRequest((context) => seo.publish(context, payload)).pipe(preservePublicErrors(isSeoPublicError)));
 })));
 
 //#endregion
@@ -6532,43 +5295,14 @@ const userAdministrationHttpLayer = HttpApiBuilder.group(StudioApi, "users", (ha
 
 //#endregion
 //#region ../platform-node/src/internal/http/api.ts
-function studioApiLayer(bootstrap, authoringRevision) {
+function studioApiLayer(bootstrap, authoringRevision, components = [], formHandlers = {}) {
 	const configuration = HttpApiBuilder.group(StudioApi, "configuration", (handlers) => handlers.handle("bootstrap", () => Effect.succeed(bootstrap)));
-	return authenticatedRouterHandlers(Layer.mergeAll(configuration, documentsApiLayer, mediaApiLayer(bootstrap.media.enabled, bootstrap.media.maxUploadBytes), collaborationApiLayer(authoringRevision), deliveryApiLayer, previewApiLayer, administrationApiLayer, userAdministrationHttpLayer).pipe(Layer.provideMerge(studioSchemaErrorLayer)));
+	return authenticatedRouterHandlers(Layer.mergeAll(configuration, formsApiLayer(components, formHandlers), documentsApiLayer, contentApiLayer, mediaApiLayer(bootstrap.media.enabled, bootstrap.media.maxUploadBytes), collaborationApiLayer(authoringRevision), deliveryApiLayer, previewApiLayer, administrationApiLayer, userAdministrationHttpLayer).pipe(Layer.provideMerge(studioSchemaErrorLayer)));
 }
 function authenticatedRouterHandlers(handlers) {
 	return handlers;
 }
 
-//#endregion
-//#region ../platform-node/src/internal/installation/server-modules.ts
-function productModulesLayer(options) {
-	const accessControl = defaultAccessControlLayer;
-	const authoredDocuments = documentsLayer(options.bootstrap.documents, {
-		...options.documentEngine,
-		components: options.documentEngine.components ?? [],
-		mediaBaseUrl: options.documentEngine.mediaBaseUrl ?? "https://media.invalid"
-	}).pipe(Layer.provide(accessControl));
-	const documentAccess = Layer.merge(authoredDocuments, accessControl);
-	const activity = activityLayer.pipe(Layer.provide(accessControl));
-	const workingDocuments = workingDocumentsLayer(options.workingDocuments).pipe(Layer.provide(documentAccess));
-	return Layer.mergeAll(activity, documentAccess, workingDocuments);
-}
-function productModulesWithMediaLayer(options) {
-	const products = productModulesLayer({
-		...options,
-		documentEngine: {
-			...options.documentEngine,
-			mediaBaseUrl: options.documentEngine.mediaBaseUrl ?? options.mediaPublicBaseUrl
-		}
-	});
-	const media = mediaLibraryLayer({
-		maxUploadBytes: options.bootstrap.media.maxUploadBytes,
-		publicBaseUrl: options.mediaPublicBaseUrl
-	}).pipe(Layer.provide(products));
-	return Layer.merge(products, media);
-}
-
 //#endregion
 //#region ../platform-node/src/internal/installation/error.ts
 var CmsInstallationError = class extends Schema.TaggedError()("Cms.InstallationError", {
@@ -6585,6 +5319,7 @@ function makeInstallationLayer(validated) {
 	const options = validated.options;
 	const core = options.composition.core;
 	const productOptions = {
+		baseUrl: options.baseUrl,
 		bootstrap: options.bootstrap,
 		documentEngine: {
 			documentModel: options.documentModel,
@@ -6598,18 +5333,15 @@ function makeInstallationLayer(validated) {
 	}).pipe(Layer.provide(Layer.merge(core, media.objects)));
 	const productModules = validated.media.enabled ? enabledProductModules(validated.media.configuration) : productModulesLayer(productOptions).pipe(Layer.provide(core));
 	const authentication = studioAuthenticationLayer.pipe(Layer.provide(core));
-	const initialization = initializationLayer({
-		initialSources: options.initialSources,
-		initializationToken: options.initializationToken
-	}).pipe(Layer.provide(Layer.merge(productModules, core)));
+	const initialization = initializationLayer({ initializationToken: options.initializationToken }).pipe(Layer.provide(core));
 	const users = userAdministrationLayer.pipe(Layer.provide(core));
 	const tickets = studioRealtimeTicketsLayer(options.studioSecret).pipe(Layer.provide(core));
 	const roomHost = studioRealtimeRoomHostLayer().pipe(Layer.provide(productModules));
 	const gateway = studioRealtimeGatewayLayer.pipe(Layer.provide(Layer.mergeAll(productModules, roomHost, tickets)));
 	const httpDependencies = Layer.mergeAll(core, productModules, gateway, initialization, roomHost, users).pipe(Layer.provideMerge(authentication), Layer.provideMerge(tickets));
-	const handlers = studioApiLayer(options.bootstrap, options.authoring.revision).pipe(Layer.provide(httpDependencies));
-	const httpApi = HttpApiBuilder.layer(StudioApi).pipe(Layer.provide(handlers), Layer.provide(HttpServer.layerServices));
-	return validated.media.enabled ? installationHttpLayer(options.bootstrap, httpApi, (context) => Effect.flatMap(MediaLibrary, (library) => library.cleanup(context))).pipe(Layer.provide(httpDependencies)) : installationHttpLayer(options.bootstrap, httpApi, () => Effect.succeed(MediaCleanupReport.make({ removedObjectKeys: [] }))).pipe(Layer.provide(httpDependencies));
+	const handlers = studioApiLayer(options.bootstrap, options.authoring.revision, options.authoring.components, options.formHandlers).pipe(Layer.provide(httpDependencies));
+	const httpApi = HttpApiBuilder.layer(StudioApi).pipe(Layer.provide(handlers), Layer.provide(HttpServer.layerServices), Layer.provideMerge(HttpRouter.layer));
+	return validated.media.enabled ? installationHttpLayer(options.bootstrap, (context) => Effect.flatMap(MediaLibrary, (library) => library.cleanup(context))).pipe(Layer.provide(Layer.merge(httpDependencies, httpApi))) : installationHttpLayer(options.bootstrap, () => Effect.succeed(MediaCleanupReport.make({ removedObjectKeys: [] }))).pipe(Layer.provide(Layer.merge(httpDependencies, httpApi)));
 }
 function validateInstallationOptions(options) {
 	if (options.bootstrap.media.enabled) {
@@ -6647,7 +5379,6 @@ function mapStartupError(layer, operation) {
 
 //#endregion
 //#region ../platform-node/src/Installation.ts
-/** Starts auth, persistence, Studio realtime, delivery, health, and maintenance as one deep module. */
 const installCms$1 = Effect.fn("CmsInstallation.install")(function* (options) {
 	return yield* startInstallation({
 		cleanup: options.bootstrap.media.enabled ? options.cleanup : void 0,
@@ -6656,272 +5387,17 @@ const installCms$1 = Effect.fn("CmsInstallation.install")(function* (options) {
 });
 function createCmsInstallationLayer(options) {
 	return installationLayer({
+		baseUrl: options.baseUrl,
+		formHandlers: options.formHandlers,
 		authoring: options.authoring,
 		bootstrap: options.bootstrap,
 		composition: options.composition,
 		studioSecret: options.studioSecret,
 		documentModel: options.documentModel,
-		initialSources: options.initialSources,
 		initializationToken: options.initializationToken
 	});
 }
 
-//#endregion
-//#region ../s3/src/internal/client.ts
-var S3RequestError = class extends Schema.TaggedError()("S3.RequestError", {
-	cause: Schema.Defect(),
-	operation: Schema.NonEmptyString
-}) {};
-function openAwsS3MediaObjectClient(options) {
-	const credentials = options.credentials ? {
-		accessKeyId: options.credentials.accessKeyId,
-		secretAccessKey: Redacted.value(options.credentials.secretAccessKey),
-		sessionToken: options.credentials.sessionToken ? Redacted.value(options.credentials.sessionToken) : void 0
-	} : void 0;
-	return makeAwsS3MediaObjectClient(new S3Client({
-		credentials,
-		endpoint: options.endpoint,
-		forcePathStyle: options.forcePathStyle,
-		region: options.region
-	}));
-}
-/** Wraps the official client; exported only through the package-private path for transport-level tests. */
-function makeAwsS3MediaObjectClient(client) {
-	const request = (operation, send) => Effect.tryPromise({
-		catch: (cause) => new S3RequestError({
-			cause,
-			operation
-		}),
-		try: send
-	});
-	return {
-		close: Effect.sync(() => client.destroy()),
-		copyObject: (input) => request("MediaObjectStore.S3.copyObject", (signal) => client.send(new CopyObjectCommand({
-			Bucket: input.bucket,
-			CacheControl: input.cacheControl,
-			ContentType: input.contentType,
-			CopySource: input.copySource,
-			Key: input.key,
-			MetadataDirective: "REPLACE"
-		}), { abortSignal: signal })).pipe(Effect.asVoid),
-		createBucket: (input) => request("MediaObjectStore.S3.createBucket", (signal) => client.send(new CreateBucketCommand({
-			Bucket: input.bucket,
-			CreateBucketConfiguration: input.locationConstraint ? { LocationConstraint: input.locationConstraint } : void 0
-		}), { abortSignal: signal })).pipe(Effect.asVoid),
-		deleteObject: (input) => request("MediaObjectStore.S3.deleteObject", (signal) => client.send(new DeleteObjectCommand({
-			Bucket: input.bucket,
-			Key: input.key
-		}), { abortSignal: signal })).pipe(Effect.asVoid),
-		headBucket: (input) => request("MediaObjectStore.S3.headBucket", (signal) => client.send(new HeadBucketCommand({ Bucket: input.bucket }), { abortSignal: signal })).pipe(Effect.asVoid),
-		headObject: (input) => request("MediaObjectStore.S3.headObject", (signal) => client.send(new HeadObjectCommand({
-			Bucket: input.bucket,
-			Key: input.key
-		}), { abortSignal: signal })).pipe(Effect.map((output) => ({
-			contentLength: output.ContentLength,
-			contentType: output.ContentType
-		}))),
-		listObjects: (input) => request("MediaObjectStore.S3.listObjects", (signal) => client.send(new ListObjectsV2Command({
-			Bucket: input.bucket,
-			ContinuationToken: input.continuationToken,
-			Prefix: input.prefix
-		}), { abortSignal: signal })).pipe(Effect.map((output) => ({
-			isTruncated: output.IsTruncated === true,
-			nextContinuationToken: output.NextContinuationToken,
-			objects: (output.Contents ?? []).map((object) => ({
-				key: object.Key,
-				size: object.Size
-			}))
-		}))),
-		putObject: (input) => request("MediaObjectStore.S3.putObject", (signal) => client.send(new PutObjectCommand({
-			Body: NodeStream.toReadableNever(Stream.fromAsyncIterable(input.body, (cause) => cause)),
-			Bucket: input.bucket,
-			CacheControl: input.cacheControl,
-			ContentLength: input.contentLength,
-			ContentType: input.contentType,
-			Key: input.key
-		}), { abortSignal: signal })).pipe(Effect.asVoid)
-	};
-}
-
-//#endregion
-//#region ../s3/src/internal/media-object-store.ts
-const mediaPrefix = "media/";
-const replaceableCacheControl = "public, max-age=0, must-revalidate";
-const isWriteBodyError = Schema.is(Schema.Union([MediaInvalid, MediaStorageError]));
-/** Owns and closes the official AWS client for the lifetime of the layer. */
-function s3MediaObjectStoreLayer(options) {
-	return Layer.effect(MediaObjectStore, resolveOptions(options).pipe(Effect.flatMap((resolved) => Effect.acquireRelease(Effect.sync(() => openAwsS3MediaObjectClient(resolved)), (client) => client.close).pipe(Effect.tap((client) => provisionBucket(resolved, client)), Effect.map((client) => makeStore(resolved, client))))));
-}
-function makeStore(options, client) {
-	return {
-		list: listObjects(options.bucket, client),
-		promote: (input) => promoteObject(options.bucket, input, client),
-		put: (input) => putObject(options.bucket, input, client),
-		remove: (objectKey) => providerRequest("MediaObjectStore.S3.remove", client.deleteObject({
-			bucket: options.bucket,
-			key: objectKey
-		})),
-		stat: (objectKey) => statObject(options.bucket, objectKey, client)
-	};
-}
-function promoteObject(bucket, input, client) {
-	return statObject(bucket, input.sourceObjectKey, client).pipe(Effect.flatMap((source) => Option.isSome(source) && source.value.byteSize === input.byteSize && source.value.mimeType === input.mimeType ? Effect.void : Effect.fail(storageError("MediaObjectStore.S3.promote.source", "The staged object metadata does not match its intent."))), Effect.flatMap(() => providerRequest("MediaObjectStore.S3.promote.copy", client.copyObject({
-		bucket,
-		cacheControl: replaceableCacheControl,
-		contentType: input.mimeType,
-		copySource: copySource(bucket, input.sourceObjectKey),
-		key: input.destinationObjectKey
-	}))), Effect.flatMap(() => statObject(bucket, input.destinationObjectKey, client)), Effect.flatMap((destination) => Option.isSome(destination) && destination.value.byteSize === input.byteSize && destination.value.mimeType === input.mimeType ? Effect.succeed(destination.value) : Effect.fail(storageError("MediaObjectStore.S3.promote.verify", "The promoted object metadata does not match its intent."))));
-}
-function copySource(bucket, objectKey) {
-	return `/${encodeURIComponent(bucket)}/${objectKey.split("/").map(encodeURIComponent).join("/")}`;
-}
-function putObject(bucket, input, client) {
-	return Effect.gen(function* () {
-		const body = yield* validatedWriteBody(input);
-		const iterable = yield* Stream.toAsyncIterableEffect(body);
-		yield* client.putObject({
-			body: iterable,
-			bucket,
-			cacheControl: replaceableCacheControl,
-			contentLength: input.byteSize,
-			contentType: input.mimeType,
-			key: input.objectKey
-		}).pipe(Effect.catch((failure) => isWriteBodyError(failure.cause) ? Effect.fail(failure.cause) : Effect.fail(providerError("MediaObjectStore.S3.put", failure))));
-		return {
-			byteSize: input.byteSize,
-			mimeType: input.mimeType,
-			objectKey: input.objectKey
-		};
-	});
-}
-const validatedWriteBody = Effect.fn("MediaObjectStore.S3.validateWriteBody")(function* (input) {
-	const byteLength = yield* Ref.make(0);
-	return input.body.pipe(Stream.mapEffect((chunk) => Effect.gen(function* () {
-		if ((yield* Ref.updateAndGet(byteLength, (current) => current + chunk.byteLength)) > input.byteSize) return yield* storageError("MediaObjectStore.S3.put.body", "The object body exceeds its declared byte size.");
-		return chunk;
-	})), Stream.concat(Stream.fromEffect(Ref.get(byteLength).pipe(Effect.flatMap((actual) => actual === input.byteSize ? Effect.void : Effect.fail(storageError("MediaObjectStore.S3.put.body", "The object body does not match its declared byte size."))))).pipe(Stream.drain)));
-});
-function statObject(bucket, objectKey, client) {
-	return client.headObject({
-		bucket,
-		key: objectKey
-	}).pipe(Effect.matchEffect({
-		onFailure: (failure) => isMissingObject(failure.cause) ? Effect.succeed(Option.none()) : Effect.fail(providerError("MediaObjectStore.S3.stat", failure)),
-		onSuccess: (output) => decodeStoredObject("MediaObjectStore.S3.stat", objectKey, output.contentLength, output.contentType).pipe(Effect.asSome)
-	}));
-}
-function listObjects(bucket, client) {
-	return Stream.paginate({ seenTokens: /* @__PURE__ */ new Set() }, (state) => providerRequest("MediaObjectStore.S3.list", client.listObjects({
-		bucket,
-		continuationToken: state.continuationToken,
-		prefix: mediaPrefix
-	})).pipe(Effect.flatMap((page) => Effect.gen(function* () {
-		return [yield* Effect.forEach(page.objects, decodeListedObject), yield* nextListState(state, page)];
-	}))));
-}
-function decodeListedObject(object) {
-	if (object.key === void 0) return Effect.fail(storageError("MediaObjectStore.S3.list", "The provider returned object metadata without a key."));
-	return decodeStoredObject("MediaObjectStore.S3.list", object.key, object.size);
-}
-function nextListState(state, page) {
-	if (!page.isTruncated) return Effect.succeedNone;
-	const token = page.nextContinuationToken;
-	if (!token || token === state.continuationToken || state.seenTokens.has(token)) return Effect.fail(storageError("MediaObjectStore.S3.list", "The provider returned an invalid continuation token."));
-	return Effect.succeedSome({
-		continuationToken: token,
-		seenTokens: /* @__PURE__ */ new Set([...state.seenTokens, token])
-	});
-}
-function decodeStoredObject(operation, objectKey, byteSize, contentType) {
-	const decodedObjectKey = Schema.decodeOption(MediaObjectKey)(objectKey);
-	const decodedByteSize = Schema.decodeUnknownOption(MediaByteSize)(byteSize);
-	if (Option.isNone(decodedObjectKey) || Option.isNone(decodedByteSize)) return Effect.fail(storageError(operation, "The provider returned invalid object metadata."));
-	const decodedMimeType = Schema.decodeUnknownOption(ImageMimeType)(contentType);
-	const storedObject = {
-		byteSize: decodedByteSize.value,
-		objectKey: decodedObjectKey.value
-	};
-	return Effect.succeed(Option.isSome(decodedMimeType) ? {
-		...storedObject,
-		mimeType: decodedMimeType.value
-	} : storedObject);
-}
-function providerRequest(operation, request) {
-	return request.pipe(Effect.mapError((failure) => providerError(operation, failure)));
-}
-function provisionBucket(options, client) {
-	if (!options.provisionBucket) return Effect.void;
-	return client.headBucket({ bucket: options.bucket }).pipe(Effect.catch((failure) => isMissingBucket(failure.cause) ? createMissingBucket(options, client) : Effect.fail(providerError("MediaObjectStore.S3.bucket.head", failure))));
-}
-function createMissingBucket(options, client) {
-	return client.createBucket({
-		bucket: options.bucket,
-		locationConstraint: options.endpoint || options.region === "us-east-1" ? void 0 : options.region
-	}).pipe(Effect.catch((failure) => isBucketAlreadyOwned(failure.cause) ? providerRequest("MediaObjectStore.S3.bucket.verify", client.headBucket({ bucket: options.bucket })) : Effect.fail(providerError("MediaObjectStore.S3.bucket.create", failure))));
-}
-const ProviderFailureDetails = Schema.Struct({
-	$metadata: Schema.optionalKey(Schema.Struct({
-		attempts: Schema.optionalKey(Schema.Finite),
-		httpStatusCode: Schema.optionalKey(Schema.Finite)
-	})),
-	name: Schema.optionalKey(Schema.String)
-});
-const decodeProviderFailure = Schema.decodeUnknownOption(ProviderFailureDetails);
-function providerError(operation, failure) {
-	const details = decodeProviderFailure(failure.cause);
-	const diagnostics = [];
-	if (Option.isSome(details)) {
-		if (details.value.name) diagnostics.push(`name=${details.value.name}`);
-		if (details.value.$metadata?.httpStatusCode !== void 0) diagnostics.push(`status=${details.value.$metadata.httpStatusCode}`);
-		if (details.value.$metadata?.attempts !== void 0) diagnostics.push(`attempts=${details.value.$metadata.attempts}`);
-	}
-	return storageError(operation, `The S3 provider request failed${diagnostics.length > 0 ? ` (${diagnostics.join(", ")}).` : "."}`);
-}
-function isMissingObject(cause) {
-	const details = decodeProviderFailure(cause);
-	if (Option.isNone(details)) return false;
-	return details.value.name === "NoSuchKey" || details.value.name === "NotFound";
-}
-function isMissingBucket(cause) {
-	const details = decodeProviderFailure(cause);
-	if (Option.isNone(details)) return false;
-	return details.value.name === "NoSuchBucket" || details.value.$metadata?.httpStatusCode === 404;
-}
-function isBucketAlreadyOwned(cause) {
-	const details = decodeProviderFailure(cause);
-	return Option.isSome(details) && details.value.name === "BucketAlreadyOwnedByYou";
-}
-function resolveOptions(options) {
-	const bucket = options.bucket.trim();
-	const region = options.region.trim();
-	const endpoint = options.endpoint?.trim();
-	if (!bucket || !region || options.endpoint !== void 0 && !endpoint) return Effect.fail(storageError("MediaObjectStore.S3.configure", "The bucket, region, and configured endpoint must be non-empty."));
-	if (options.credentials) {
-		const secretAccessKey = Redacted.value(options.credentials.secretAccessKey);
-		const sessionToken = options.credentials.sessionToken && Redacted.value(options.credentials.sessionToken);
-		if (!options.credentials.accessKeyId.trim() || !secretAccessKey || sessionToken === "") return Effect.fail(storageError("MediaObjectStore.S3.configure", "The configured credentials must be non-empty."));
-	}
-	return Effect.succeed({
-		...options,
-		bucket,
-		credentials: options.credentials ? {
-			...options.credentials,
-			accessKeyId: options.credentials.accessKeyId.trim()
-		} : void 0,
-		endpoint,
-		forcePathStyle: options.forcePathStyle ?? false,
-		provisionBucket: options.provisionBucket ?? false,
-		region
-	});
-}
-function storageError(operation, message) {
-	return new MediaStorageError({
-		cause: new Error(message),
-		operation
-	});
-}
-
 //#endregion
 //#region ../sql-pg/src/internal/database/table-helpers.ts
 const transactionTimestamp = sql`transaction_timestamp()`;
@@ -6935,6 +5411,7 @@ const ACTIVITY_TARGET_KINDS = [
 	"document",
 	"media",
 	"media-library",
+	"seo",
 	"user"
 ];
 const IDENTIFIED_ACTIVITY_TARGET_KINDS = [
@@ -6961,8 +5438,8 @@ const activityEntries = pgTable("activity_entries", {
 }, (table) => [
 	check("activity_entries_action_check", isOneOf(table.action, ACTIVITY_ACTIONS)),
 	check("activity_entries_target_kind_check", isOneOf(table.targetKind, ACTIVITY_TARGET_KINDS)),
-	check("activity_entries_target_check", sql`(${table.targetKind} = 'media-library' AND ${table.targetId} IS NULL)
-        OR (${table.targetKind} <> 'media-library' AND ${table.targetId} IS NOT NULL)`),
+	check("activity_entries_target_check", sql`(${table.targetKind} in ('media-library', 'seo') AND ${table.targetId} IS NULL)
+        OR (${table.targetKind} not in ('media-library', 'seo') AND ${table.targetId} IS NOT NULL)`),
 	check("activity_entries_actor_roles_check", sql`jsonb_typeof(${table.actorRoles}) = 'array'`),
 	check("activity_entries_details_check", sql`jsonb_typeof(${table.details}) = 'object'`),
 	index("activity_entries_history").on(table.occurredAt.desc(), table.id.desc()),
@@ -7053,27 +5530,30 @@ function activityEntryValues(entry) {
 	};
 }
 function activityEntriesEqual(left, right) {
-	return isDeepStrictEqual(Schema.encodeSync(ActivityEntry)(left), Schema.encodeSync(ActivityEntry)(right));
+	return isDeepStrictEqual(Result.getOrThrow(Schema.encodeResult(ActivityEntry)(left)), Result.getOrThrow(Schema.encodeResult(ActivityEntry)(right)));
 }
 function decodeActivityTarget(kind, id) {
-	const value = kind === "document" ? {
+	if (kind === "document") return Schema.decodeUnknownEffect(ActivityTarget)({
 		documentId: id,
 		kind
-	} : kind === "media" ? {
+	});
+	if (kind === "media") return Schema.decodeUnknownEffect(ActivityTarget)({
 		kind,
 		mediaId: id
-	} : kind === "user" ? {
+	});
+	if (kind === "user") return Schema.decodeUnknownEffect(ActivityTarget)({
 		kind,
 		userId: id
-	} : { kind };
-	return Schema.decodeUnknownEffect(ActivityTarget)(value);
+	});
+	return Schema.decodeEffect(ActivityTarget)({ kind });
 }
 function activityTargetId(entry) {
 	switch (entry.target.kind) {
 		case "document": return entry.target.documentId;
 		case "media": return entry.target.mediaId;
 		case "user": return entry.target.userId;
-		case "media-library": return;
+		case "media-library":
+		case "seo": return;
 	}
 }
 function activityPage(entries, limit, total) {
@@ -7372,7 +5852,8 @@ function targetColumns(target) {
 			targetId: target.userId,
 			targetKind: target.kind
 		};
-		case "media-library": return { targetKind: target.kind };
+		case "media-library":
+		case "seo": return { targetKind: target.kind };
 	}
 }
 function decodeOptionalTarget(kind, id) {
@@ -7380,7 +5861,7 @@ function decodeOptionalTarget(kind, id) {
 	return decodeActivityTarget(kind, id).pipe(Effect.mapError(() => new ChangeMismatch({})));
 }
 function draftEqual(change, draft) {
-	return isDeepStrictEqual(Schema.encodeSync(ChangeDraft)(draftFromChange(change)), Schema.encodeSync(ChangeDraft)(draft));
+	return isDeepStrictEqual(Result.getOrThrow(Schema.encodeResult(ChangeDraft)(draftFromChange(change))), Result.getOrThrow(Schema.encodeResult(ChangeDraft)(draft)));
 }
 function draftFromChange(change) {
 	const value = {
@@ -7397,7 +5878,7 @@ function draftFromChange(change) {
 	});
 }
 function changeEqual(left, right) {
-	return isDeepStrictEqual(Schema.encodeSync(PendingChange)(left), Schema.encodeSync(PendingChange)(right));
+	return isDeepStrictEqual(Result.getOrThrow(Schema.encodeResult(PendingChange)(left)), Result.getOrThrow(Schema.encodeResult(PendingChange)(right)));
 }
 function boundedLimit(limit) {
 	return Math.min(100, Math.max(0, Math.trunc(limit)));
@@ -7505,6 +5986,26 @@ const embeddedMigrations = [
 		folderMillis: 1788866265e3,
 		hash: "24c56a37796caf8d76c0a97128a382b31e71808aa5b0ca7e5bac96795f9e16c7",
 		name: "20260908111745_classy_johnny_storm"
+	},
+	{
+		sql: [
+			"CREATE TABLE \"seo_media_references\" (\n	\"id\" uuid PRIMARY KEY DEFAULT gen_random_uuid(),\n	\"scope\" text NOT NULL,\n	\"media_id\" uuid NOT NULL,\n	CONSTRAINT \"seo_media_references_scope_media_unique\" UNIQUE(\"scope\",\"media_id\"),\n	CONSTRAINT \"seo_media_references_scope_check\" CHECK (\"scope\" in ('working', 'published'))\n);\n",
+			"\nCREATE TABLE \"seo_revisions\" (\n	\"id\" uuid PRIMARY KEY DEFAULT gen_random_uuid(),\n	\"settings\" jsonb NOT NULL,\n	\"actor_id\" text NOT NULL,\n	\"actor_email\" text NOT NULL,\n	\"actor_name\" text NOT NULL,\n	\"actor_roles\" jsonb NOT NULL,\n	\"request_id\" uuid NOT NULL,\n	\"reason\" text,\n	\"created_at\" timestamp with time zone DEFAULT transaction_timestamp() NOT NULL,\n	CONSTRAINT \"seo_revisions_actor_roles_check\" CHECK (jsonb_typeof(\"actor_roles\") = 'array'),\n	CONSTRAINT \"seo_revisions_settings_check\" CHECK (jsonb_typeof(\"settings\") = 'object')\n);\n",
+			"\nCREATE TABLE \"seo_state\" (\n	\"singleton\" boolean PRIMARY KEY DEFAULT true,\n	\"working_revision_id\" uuid NOT NULL,\n	\"published_revision_id\" uuid NOT NULL,\n	CONSTRAINT \"seo_state_singleton_check\" CHECK (\"singleton\")\n);\n",
+			"\nCREATE INDEX \"seo_media_references_media\" ON \"seo_media_references\" (\"media_id\");",
+			"\nCREATE INDEX \"seo_revisions_history\" ON \"seo_revisions\" (\"created_at\" DESC NULLS LAST,\"id\" DESC NULLS LAST);",
+			"\nALTER TABLE \"seo_media_references\" ADD CONSTRAINT \"seo_media_references_media_id_media_assets_id_fkey\" FOREIGN KEY (\"media_id\") REFERENCES \"media_assets\"(\"id\") ON DELETE RESTRICT;",
+			"\nALTER TABLE \"seo_state\" ADD CONSTRAINT \"seo_state_working_revision_fkey\" FOREIGN KEY (\"working_revision_id\") REFERENCES \"seo_revisions\"(\"id\") ON DELETE RESTRICT;",
+			"\nALTER TABLE \"seo_state\" ADD CONSTRAINT \"seo_state_published_revision_fkey\" FOREIGN KEY (\"published_revision_id\") REFERENCES \"seo_revisions\"(\"id\") ON DELETE RESTRICT;",
+			"\nALTER TABLE \"activity_entries\" DROP CONSTRAINT \"activity_entries_action_check\", ADD CONSTRAINT \"activity_entries_action_check\" CHECK (\"action\" in ('document.created', 'document.updated', 'document.moved', 'document.trashed', 'document.revision.restored', 'document.untrashed', 'document.published', 'document.unpublished', 'media.uploaded', 'media.replaced', 'media.removed', 'media.cleaned', 'seo.saved', 'seo.published', 'user.created', 'user.removed', 'user.role.changed', 'user.sessions.revoked', 'authentication.signed-in', 'authentication.signed-out', 'authentication.password.changed', 'authentication.password.reset'));",
+			"\nALTER TABLE \"activity_entries\" DROP CONSTRAINT \"activity_entries_target_kind_check\", ADD CONSTRAINT \"activity_entries_target_kind_check\" CHECK (\"target_kind\" in ('document', 'media', 'media-library', 'seo', 'user'));",
+			"\nALTER TABLE \"activity_entries\" DROP CONSTRAINT \"activity_entries_target_check\", ADD CONSTRAINT \"activity_entries_target_check\" CHECK ((\"target_kind\" in ('media-library', 'seo') AND \"target_id\" IS NULL)\n        OR (\"target_kind\" not in ('media-library', 'seo') AND \"target_id\" IS NOT NULL));",
+			"\nALTER TABLE \"pending_changes\" DROP CONSTRAINT \"pending_changes_action_check\", ADD CONSTRAINT \"pending_changes_action_check\" CHECK (\"action\" in ('document.created', 'document.updated', 'document.moved', 'document.trashed', 'document.revision.restored', 'document.untrashed', 'document.published', 'document.unpublished', 'media.uploaded', 'media.replaced', 'media.removed', 'media.cleaned', 'seo.saved', 'seo.published', 'user.created', 'user.removed', 'user.role.changed', 'user.sessions.revoked', 'authentication.signed-in', 'authentication.signed-out', 'authentication.password.changed', 'authentication.password.reset'));"
+		],
+		bps: true,
+		folderMillis: 1789233351e3,
+		hash: "8e6a6abf5385ab3ecf8eb083c1923ac9c74d72aa71bd1d444b7402d3e7e77000",
+		name: "20260912171551_charming_valkyrie"
 	}
 ];
 
@@ -7603,12 +6104,16 @@ const initializationState = pgTable("initialization_state", {
 
 //#endregion
 //#region ../sql-pg/src/internal/database/migrations.ts
-/** Applies generated CMS migrations and initializes required application state. */
+const MIGRATION_LOCK_KEY = "cms:database-migrations:v1";
 const migrateCmsDatabase = Effect.fn("CmsDatabase.migrate")(function* () {
+	const postgres = yield* PgClient.PgClient;
 	const database = yield* PgDrizzle.makeWithDefaults();
-	yield* migrate(embeddedMigrations, database._.session, "__drizzle_migrations");
-	yield* database.insert(cmsState).values({}).onConflictDoNothing({ target: cmsState.singleton });
-	yield* database.insert(initializationState).values({}).onConflictDoNothing({ target: initializationState.singleton });
+	yield* postgres.withTransaction(Effect.gen(function* () {
+		yield* postgres.unsafe("select pg_advisory_xact_lock(hashtextextended($1, 0))", [MIGRATION_LOCK_KEY]);
+		yield* migrate(embeddedMigrations, database._.session, "__drizzle_migrations");
+		yield* database.insert(cmsState).values({}).onConflictDoNothing({ target: cmsState.singleton });
+		yield* database.insert(initializationState).values({}).onConflictDoNothing({ target: initializationState.singleton });
+	}));
 });
 const cmsDatabaseMigrationLayer = Layer.effectDiscard(migrateCmsDatabase());
 
@@ -7625,13 +6130,15 @@ const applyDocumentCommitPlan = Effect.fn("DocumentStore.Drizzle.applyCommitPlan
 			const revisionId = yield* appendRevision(transaction, plan, activity);
 			yield* transaction.insert(documentHeads).values({
 				authoredRevisionId: revisionId,
-				documentId: plan.documentId
+				documentId: plan.documentId,
+				publishedRevisionId: plan.publish ? revisionId : null
 			});
 			return;
 		}
 		case "document.update": {
 			const revisionId = yield* appendRevision(transaction, plan, activity);
 			yield* updateAuthoredHead(transaction, plan.documentId, revisionId);
+			if (plan.publish) yield* transaction.update(documentHeads).set({ publishedRevisionId: revisionId }).where(eq(documentHeads.documentId, plan.documentId));
 			yield* touchDocument(transaction, plan.documentId);
 			return;
 		}
@@ -7712,7 +6219,7 @@ function mapActivePathConflict(sourcePath) {
 		const causeError = Cause$1.findErrorOption(error.cause);
 		if (Option$1.isNone(causeError) || !SqlError.isSqlError(causeError.value)) return error;
 		const reason = causeError.value.reason;
-		return reason._tag === "UniqueViolation" && reason.constraint === "documents_active_path" ? new DocumentPathConflict({ sourcePath }) : error;
+		return Predicate.isTagged("UniqueViolation")(reason) && reason.constraint === "documents_active_path" ? new DocumentPathConflict({ sourcePath }) : error;
 	}));
 }
 function updateAuthoredHead(transaction, documentId, revisionId) {
@@ -8026,7 +6533,7 @@ const isRepositoryDomainError = Schema.is(RepositoryDomainError);
 const isDocumentNotFound = Schema.is(DocumentNotFound);
 const isDocumentMediaUnavailable = Schema.is(DocumentMediaUnavailable);
 const isDocumentPersistenceError = Schema.is(DocumentPersistenceError);
-const systemActivity = ActivityContext.make({
+const systemActivity$1 = ActivityContext.make({
 	actor: {
 		email: "system@cms.invalid",
 		id: "system",
@@ -8049,15 +6556,15 @@ const documentStoreLayer = Layer.effect(DocumentStore, Effect.gen(function* () {
 		const state = yield* Schema.decodeUnknownEffect(CmsStateSelect)(stateRow);
 		const plans = [input.plan, ...input.additionalPlans ?? []];
 		const references = plans.flatMap((plan) => input.mediaReferences.filter((reference) => reference.documentId === plan.documentId));
-		if (references.length !== input.mediaReferences.length) return yield* persistenceFailure$2("DocumentStore.commit", /* @__PURE__ */ new Error("Unexpected media reference owner."));
+		if (references.length !== input.mediaReferences.length) return yield* persistenceFailure$3("DocumentStore.commit", /* @__PURE__ */ new Error("Unexpected media reference owner."));
 		yield* lockMediaReferenceKeys(transaction, references.map((reference) => reference.objectKey));
-		yield* rejectDeletingMedia(transaction, references);
-		const activity = input.activity ?? systemActivity;
+		yield* rejectUnavailableMedia(transaction, references);
+		const activity = input.activity ?? systemActivity$1;
 		for (const plan of plans) {
 			yield* applyDocumentCommitPlan(transaction, plan, activity);
 			yield* replaceDocumentMediaReferences(transaction, plan.documentId, references.filter((reference) => reference.documentId === plan.documentId));
 		}
-		const snapshot = yield* readSnapshot(transaction, state.generation);
+		const snapshot = yield* readSnapshot$1(transaction, state.generation);
 		for (const plan of plans) {
 			const affected = yield* sourceForMutation(snapshot, plan.documentId, plan.action === "document.remove");
 			yield* recordDocumentActivity(transaction, affected, plan, activity);
@@ -8079,15 +6586,15 @@ const documentStoreLayer = Layer.effect(DocumentStore, Effect.gen(function* () {
 	const load = Effect.fn("DocumentStore.Drizzle.load")((after) => database.transaction((transaction) => Effect.gen(function* () {
 		const generation = yield* readGeneration(transaction);
 		if (after === generation.toString()) return void 0;
-		return yield* readSnapshot(transaction, generation);
+		return yield* readSnapshot$1(transaction, generation);
 	}), {
 		accessMode: "read only",
 		isolationLevel: "repeatable read"
-	}).pipe(mapPersistenceFailure$2("DocumentStore.Drizzle.load")));
+	}).pipe(mapPersistenceFailure$3("DocumentStore.Drizzle.load")));
 	const synchronizeMediaReferences = Effect.fn("DocumentStore.Drizzle.synchronizeMediaReferences")((input) => database.transaction((transaction) => Effect.gen(function* () {
 		const stateRows = yield* transaction.select().from(cmsState).where(eq(cmsState.singleton, true)).limit(2).for("update");
 		const stateRow = stateRows[0];
-		if (stateRows.length !== 1 || !stateRow) return yield* persistenceFailure$2("DocumentStore.Drizzle.synchronizeMediaReferences", /* @__PURE__ */ new Error(`Expected exactly one document generation row; received ${stateRows.length}.`));
+		if (stateRows.length !== 1 || !stateRow) return yield* persistenceFailure$3("DocumentStore.Drizzle.synchronizeMediaReferences", /* @__PURE__ */ new Error(`Expected exactly one document generation row; received ${stateRows.length}.`));
 		const state = yield* Schema.decodeUnknownEffect(CmsStateSelect)(stateRow);
 		if (state.generation.toString() !== input.expectedGeneration) return yield* new DocumentGenerationConflict({
 			actualGeneration: DocumentGeneration.make(String(state.generation)),
@@ -8095,7 +6602,7 @@ const documentStoreLayer = Layer.effect(DocumentStore, Effect.gen(function* () {
 		});
 		const references = uniqueMediaReferences(input.references);
 		yield* lockMediaReferenceKeys(transaction, references.map((reference) => reference.objectKey));
-		yield* rejectDeletingMedia(transaction, references);
+		yield* rejectUnavailableMedia(transaction, references);
 		yield* transaction.delete(documentMediaReferences);
 		if (references.length > 0) yield* transaction.insert(documentMediaReferences).values(references.map(referenceValues));
 	})).pipe(mapSynchronizationFailure("DocumentStore.Drizzle.synchronizeMediaReferences")));
@@ -8111,12 +6618,12 @@ const documentStoreLayer = Layer.effect(DocumentStore, Effect.gen(function* () {
 		const cursor = query.cursor ? or(lt(documentRevisions.createdAt, DateTime.formatIso(query.cursor.createdAt)), and(eq(documentRevisions.createdAt, DateTime.formatIso(query.cursor.createdAt)), lt(documentRevisions.id, query.cursor.revisionId))) : void 0;
 		const rows = yield* transaction.select().from(documentRevisions).where(and(eq(documentRevisions.documentId, query.documentId), cursor)).orderBy(desc(documentRevisions.createdAt), desc(documentRevisions.id)).limit(query.limit + 1);
 		const total = (yield* transaction.select({ value: count() }).from(documentRevisions).where(eq(documentRevisions.documentId, query.documentId)))[0]?.value;
-		if (total === void 0) return yield* persistenceFailure$2("DocumentStore.Drizzle.revisions", /* @__PURE__ */ new Error("Documents persistence did not return a history total."));
+		if (total === void 0) return yield* persistenceFailure$3("DocumentStore.Drizzle.revisions", /* @__PURE__ */ new Error("Documents persistence did not return a history total."));
 		return revisionPage(yield* Effect.forEach(rows, decodeDocumentRevision), query.limit, total);
 	}), {
 		accessMode: "read only",
 		isolationLevel: "repeatable read"
-	}).pipe(mapPersistenceFailure$2("DocumentStore.Drizzle.revisions")));
+	}).pipe(mapPersistenceFailure$3("DocumentStore.Drizzle.revisions")));
 	return DocumentStore.of({
 		commit,
 		load,
@@ -8157,8 +6664,13 @@ const recordDocumentActivity = Effect.fn("DocumentStore.Drizzle.recordActivity")
 	};
 	if (plan.action !== "document.publish" && plan.action !== "document.unpublish") values.id = source.revisionId;
 	yield* database.insert(activityEntries).values(values);
+	if ((plan.action === "document.create" || plan.action === "document.update") && plan.publish) yield* database.insert(activityEntries).values({
+		...values,
+		action: "document.published",
+		id: void 0
+	});
 });
-const readSnapshot = Effect.fn("DocumentStore.Drizzle.readSnapshot")(function* (database, generation) {
+const readSnapshot$1 = Effect.fn("DocumentStore.Drizzle.readSnapshot")(function* (database, generation) {
 	const rows = yield* database.select({
 		authored: authoredRevision,
 		created: createdRevision,
@@ -8171,12 +6683,12 @@ const readSnapshot = Effect.fn("DocumentStore.Drizzle.readSnapshot")(function* (
 const readGeneration = Effect.fn("DocumentStore.Drizzle.readGeneration")(function* (database) {
 	const rows = yield* database.select().from(cmsState);
 	const row = rows[0];
-	if (rows.length !== 1 || !row) return yield* persistenceFailure$2("DocumentStore.Drizzle.readGeneration", /* @__PURE__ */ new Error(`Expected exactly one document generation row; received ${rows.length}.`));
+	if (rows.length !== 1 || !row) return yield* persistenceFailure$3("DocumentStore.Drizzle.readGeneration", /* @__PURE__ */ new Error(`Expected exactly one document generation row; received ${rows.length}.`));
 	return (yield* Schema.decodeUnknownEffect(CmsStateSelect)(row)).generation;
 });
 const sourceForMutation = Effect.fn("DocumentStore.Drizzle.sourceForMutation")(function* (snapshot, documentId, deleted) {
 	const source = (deleted ? snapshot.deleted : snapshot.active).find((candidate) => candidate.documentId === documentId);
-	if (!source) return yield* persistenceFailure$2("DocumentStore.Drizzle.sourceForMutation", /* @__PURE__ */ new Error(`Committed document "${documentId}" is missing from its resulting snapshot.`));
+	if (!source) return yield* persistenceFailure$3("DocumentStore.Drizzle.sourceForMutation", /* @__PURE__ */ new Error(`Committed document "${documentId}" is missing from its resulting snapshot.`));
 	return source;
 });
 function mapCommitFailure(operation) {
@@ -8188,14 +6700,27 @@ function mapSynchronizationFailure(operation) {
 		return documentPersistenceError(operation, cause);
 	}));
 }
-const rejectDeletingMedia = Effect.fn("DocumentStore.Drizzle.rejectDeletingMedia")(function* (transaction, references) {
+const rejectUnavailableMedia = Effect.fn("DocumentStore.Drizzle.rejectUnavailableMedia")(function* (transaction, references) {
 	const keys = [...new Set(references.map((reference) => reference.objectKey))];
+	const mediaIds = [...new Set(references.flatMap((reference) => reference.mediaId ? [reference.mediaId] : []))];
 	if (keys.length === 0) return;
-	const rows = yield* transaction.select({ objectKey: mediaAssets.objectKey }).from(mediaAssets).where(and(inArray(mediaAssets.objectKey, keys), eq(mediaAssets.status, "deleting")));
-	const unavailable = yield* Schema.decodeEffect(Schema.Array(MediaObjectKey))(rows.map((row) => row.objectKey));
+	if (mediaIds.length > 0) {
+		const identityRows = yield* transaction.select({ objectKey: mediaAssets.objectKey }).from(mediaAssets).where(inArray(mediaAssets.id, mediaIds));
+		yield* lockMediaReferenceKeys(transaction, yield* Schema.decodeEffect(Schema.Array(MediaObjectKey))(identityRows.map((row) => row.objectKey)));
+	}
+	const rows = yield* transaction.select({
+		id: mediaAssets.id,
+		objectKey: mediaAssets.objectKey,
+		status: mediaAssets.status
+	}).from(mediaAssets).where(mediaIds.length > 0 ? or(inArray(mediaAssets.objectKey, keys), inArray(mediaAssets.id, mediaIds)) : inArray(mediaAssets.objectKey, keys));
+	const deletingKeys = new Set(yield* Schema.decodeEffect(Schema.Array(MediaObjectKey))(rows.filter((row) => row.status === "deleting").map((row) => row.objectKey)));
+	const unavailable = references.filter((reference) => {
+		if (!reference.mediaId) return deletingKeys.has(reference.objectKey);
+		const asset = rows.find((row) => row.id === reference.mediaId);
+		return !asset || asset.status !== "ready" || asset.objectKey !== reference.objectKey;
+	});
 	if (unavailable.length === 0) return;
-	const unavailableSet = new Set(unavailable);
-	const affected = references.filter((reference) => unavailableSet.has(reference.objectKey)).sort((left, right) => left.documentId === right.documentId ? left.objectKey.localeCompare(right.objectKey) : left.documentId.localeCompare(right.documentId));
+	const affected = unavailable.sort((left, right) => left.documentId === right.documentId ? left.objectKey.localeCompare(right.objectKey) : left.documentId.localeCompare(right.documentId));
 	const first = affected[0];
 	if (!first) return;
 	return yield* new DocumentMediaUnavailable({
@@ -8219,7 +6744,7 @@ function referenceValues(reference) {
 		sourcePath: reference.sourcePath
 	};
 }
-function mapPersistenceFailure$2(operation) {
+function mapPersistenceFailure$3(operation) {
 	return (effect) => effect.pipe(Effect.mapError((cause) => isDocumentPersistenceError(cause) ? cause : documentPersistenceError(operation, cause)));
 }
 function mapRevisionFailure(operation) {
@@ -8228,7 +6753,7 @@ function mapRevisionFailure(operation) {
 		return documentPersistenceError(operation, cause);
 	}));
 }
-function persistenceFailure$2(operation, cause) {
+function persistenceFailure$3(operation, cause) {
 	return Effect.fail(documentPersistenceError(operation, cause));
 }
 
@@ -8291,7 +6816,7 @@ const initializationStoreLayer = Layer.effect(InitializationStore, Effect.gen(fu
 	const locks = yield* PostgresAdvisoryLock;
 	const claim = Effect.fn("InitializationStore.Postgres.claim")((value) => database.update(initializationState).set({
 		changeId: value.changeId,
-		claim: Schema.encodeSync(InitializationClaim)(value),
+		claim: Result.getOrThrow(Schema.encodeResult(InitializationClaim)(value)),
 		state: "claiming"
 	}).where(and(eq(initializationState.singleton, true), eq(initializationState.state, "uninitialized"))).returning({ singleton: initializationState.singleton }).pipe(Effect.map((rows) => rows.length === 1), mapUnavailable("InitializationStore.Postgres.claim")));
 	const complete = Effect.fn("InitializationStore.Postgres.complete")((changeId) => transition(database, changeId, "ready"));
@@ -8343,6 +6868,53 @@ function mapUnavailable(operation) {
 	})));
 }
 
+//#endregion
+//#region ../sql-pg/src/internal/seo/tables.ts
+const seoRevisions = pgTable("seo_revisions", {
+	id: uuid().defaultRandom().primaryKey(),
+	settings: jsonb().$type().notNull(),
+	actorId: text("actor_id").notNull(),
+	actorEmail: text("actor_email").notNull(),
+	actorName: text("actor_name").notNull(),
+	actorRoles: jsonb("actor_roles").$type().notNull(),
+	requestId: uuid("request_id").notNull(),
+	reason: text(),
+	createdAt: timestamp("created_at", {
+		mode: "string",
+		withTimezone: true
+	}).default(transactionTimestamp).notNull()
+}, (table) => [
+	check("seo_revisions_actor_roles_check", sql`jsonb_typeof(${table.actorRoles}) = 'array'`),
+	check("seo_revisions_settings_check", sql`jsonb_typeof(${table.settings}) = 'object'`),
+	index("seo_revisions_history").on(table.createdAt.desc(), table.id.desc())
+]);
+const seoState = pgTable("seo_state", {
+	singleton: boolean().default(true).primaryKey(),
+	workingRevisionId: uuid("working_revision_id").notNull(),
+	publishedRevisionId: uuid("published_revision_id").notNull()
+}, (table) => [
+	check("seo_state_singleton_check", sql`${table.singleton}`),
+	foreignKey({
+		columns: [table.workingRevisionId],
+		foreignColumns: [seoRevisions.id],
+		name: "seo_state_working_revision_fkey"
+	}).onDelete("restrict"),
+	foreignKey({
+		columns: [table.publishedRevisionId],
+		foreignColumns: [seoRevisions.id],
+		name: "seo_state_published_revision_fkey"
+	}).onDelete("restrict")
+]);
+const seoMediaReferences = pgTable("seo_media_references", {
+	id: uuid().defaultRandom().primaryKey(),
+	scope: text({ enum: ["working", "published"] }).notNull(),
+	mediaId: uuid("media_id").notNull().references(() => mediaAssets.id, { onDelete: "restrict" })
+}, (table) => [
+	check("seo_media_references_scope_check", sql`${table.scope} in ('working', 'published')`),
+	unique("seo_media_references_scope_media_unique").on(table.scope, table.mediaId),
+	index("seo_media_references_media").on(table.mediaId)
+]);
+
 //#endregion
 //#region ../sql-pg/src/internal/media/row-schema.ts
 const mediaRefinements = {
@@ -8410,14 +6982,14 @@ const isMediaReferenced = Schema.is(MediaReferenced);
 const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 	const database = yield* PgDrizzle.makeWithDefaults();
 	const reserve = Effect.fn("MediaStore.Drizzle.reserve")((record, operation) => database.transaction((transaction) => Effect.gen(function* () {
-		if (record.status !== "uploading") return yield* persistenceFailure$1("MediaStore.Drizzle.reserve", /* @__PURE__ */ new Error(`A media reservation must start as uploading, received "${record.status}".`));
+		if (record.status !== "uploading") return yield* persistenceFailure$2("MediaStore.Drizzle.reserve", /* @__PURE__ */ new Error(`A media reservation must start as uploading, received "${record.status}".`));
 		yield* beginChange(transaction, mediaUploadChange(record, operation)).pipe(Effect.flatMap(requireUnresolvedChange));
 		const rows = yield* transaction.insert(mediaAssets).values(recordValues(record)).onConflictDoNothing().returning();
 		if (rows[0]) return yield* decodeMediaRecord(rows[0]);
 		const existing = yield* rowById(transaction, record.id);
 		if (existing && existing.status !== "deleting" && isSameReservation(existing, record)) return existing;
-		return yield* persistenceFailure$1("MediaStore.Drizzle.reserve", /* @__PURE__ */ new Error(`Media reservation "${record.id}" conflicts with durable media state.`));
-	})).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.reserve")));
+		return yield* persistenceFailure$2("MediaStore.Drizzle.reserve", /* @__PURE__ */ new Error(`Media reservation "${record.id}" conflicts with durable media state.`));
+	})).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.reserve")));
 	const activate = Effect.fn("MediaStore.Drizzle.activate")((id) => database.transaction((transaction) => Effect.gen(function* () {
 		const existing = yield* lockedRowById(transaction, id);
 		if (existing?.status === "ready") return existing;
@@ -8435,11 +7007,11 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 			kind: "applied"
 		});
 		return activated;
-	})).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.activate")));
+	})).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.activate")));
 	const find = Effect.fn("MediaStore.Drizzle.find")((id) => Effect.gen(function* () {
 		const rows = yield* database.select().from(mediaAssets).where(and(eq(mediaAssets.id, id), eq(mediaAssets.status, "ready"))).limit(1);
 		return rows[0] ? Option.some(yield* decodeMediaRecord(rows[0])) : Option.none();
-	}).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.find")));
+	}).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.find")));
 	const beginDelete = Effect.fn("MediaStore.Drizzle.beginDelete")((id, operation) => database.transaction((transaction) => Effect.gen(function* () {
 		const existing = yield* lockedRowById(transaction, id);
 		if (!existing) return yield* new MediaNotFound({ mediaId: id });
@@ -8452,7 +7024,13 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 		yield* lockMediaReferenceKeys(transaction, [existing.objectKey]);
 		const referenceRows = yield* transaction.select().from(documentMediaReferences).where(eq(documentMediaReferences.objectKey, existing.objectKey)).orderBy(asc(documentMediaReferences.documentId), asc(documentMediaReferences.sourcePath), asc(documentMediaReferences.nodePath));
 		const references = yield* decodeMediaReferences(referenceRows);
-		if (references.length > 0) return yield* new MediaReferenced({
+		const seoReferenceRows = yield* transaction.select({ scope: seoMediaReferences.scope }).from(seoMediaReferences).where(eq(seoMediaReferences.mediaId, id)).orderBy(asc(seoMediaReferences.scope));
+		const seoScopes = yield* Schema.decodeEffect(Schema.Array(Schema.Literals(["working", "published"])))(seoReferenceRows.map((row) => row.scope)).pipe(Effect.mapError((cause) => mediaPersistenceError("MediaStore.Drizzle.beginDelete", cause)));
+		if (references.length > 0 || seoScopes.length > 0) return yield* new MediaReferenced(seoScopes.length > 0 ? {
+			mediaId: id,
+			references,
+			seoScopes
+		} : {
 			mediaId: id,
 			references
 		});
@@ -8473,7 +7051,7 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 		const existing = yield* replacementByMediaId(transaction, replacement.mediaId);
 		if (existing && isSameReplacement(existing, replacement)) return existing;
 		return yield* new MediaConflict({ mediaId: replacement.mediaId });
-	})).pipe(mapStoreFailure$1("MediaStore.Drizzle.beginReplace")));
+	})).pipe(mapStoreFailure$2("MediaStore.Drizzle.beginReplace")));
 	const markReplaceStaged = Effect.fn("MediaStore.Drizzle.markReplaceStaged")((replacement) => database.transaction((transaction) => Effect.gen(function* () {
 		yield* lockedRowById(transaction, replacement.mediaId);
 		const existing = yield* replacementByMediaId(transaction, replacement.mediaId);
@@ -8481,14 +7059,14 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 		if (existing.staged) return existing;
 		const rows = yield* transaction.update(mediaReplacements).set({ staged: true }).where(and(eq(mediaReplacements.mediaId, replacement.mediaId), eq(mediaReplacements.stagingObjectKey, replacement.stagingObjectKey))).returning();
 		if (rows[0]) return yield* decodeMediaReplacement(rows[0]);
-		return yield* persistenceFailure$1("MediaStore.Drizzle.markReplaceStaged", /* @__PURE__ */ new Error(`Media replacement "${replacement.mediaId}" lost its durable intent.`));
-	})).pipe(mapStoreFailure$1("MediaStore.Drizzle.markReplaceStaged")));
+		return yield* persistenceFailure$2("MediaStore.Drizzle.markReplaceStaged", /* @__PURE__ */ new Error(`Media replacement "${replacement.mediaId}" lost its durable intent.`));
+	})).pipe(mapStoreFailure$2("MediaStore.Drizzle.markReplaceStaged")));
 	const finishReplace = Effect.fn("MediaStore.Drizzle.finishReplace")((replacement) => database.transaction((transaction) => Effect.gen(function* () {
 		const asset = yield* lockedRowById(transaction, replacement.mediaId);
 		const pendingReplacement = yield* replacementByMediaId(transaction, replacement.mediaId);
 		if (!pendingReplacement) {
 			if (asset && isCompletedReplacement(asset, replacement)) return asset;
-			return yield* persistenceFailure$1("MediaStore.Drizzle.finishReplace", /* @__PURE__ */ new Error(`Media replacement "${replacement.mediaId}" cannot be replayed from durable state.`));
+			return yield* persistenceFailure$2("MediaStore.Drizzle.finishReplace", /* @__PURE__ */ new Error(`Media replacement "${replacement.mediaId}" cannot be replayed from durable state.`));
 		}
 		if (!isSameReplacement(pendingReplacement, replacement)) return yield* new MediaConflict({ mediaId: replacement.mediaId });
 		if (!asset || asset.status !== "ready" || asset.objectKey !== replacement.objectKey || asset.mimeType !== replacement.mimeType) return yield* new MediaConflict({ mediaId: replacement.mediaId });
@@ -8501,7 +7079,7 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 			updatedAt: transactionTimestamp
 		}).where(and(eq(mediaAssets.id, replacement.mediaId), eq(mediaAssets.status, "ready"))).returning())[0];
 		if (!replaced) return yield* transitionFailure("MediaStore.Drizzle.finishReplace", replacement.mediaId, asset.status);
-		if (!(yield* transaction.delete(mediaReplacements).where(and(eq(mediaReplacements.mediaId, replacement.mediaId), eq(mediaReplacements.stagingObjectKey, replacement.stagingObjectKey))).returning({ mediaId: mediaReplacements.mediaId }))[0]) return yield* persistenceFailure$1("MediaStore.Drizzle.finishReplace", /* @__PURE__ */ new Error(`Media replacement "${replacement.mediaId}" lost its durable intent.`));
+		if (!(yield* transaction.delete(mediaReplacements).where(and(eq(mediaReplacements.mediaId, replacement.mediaId), eq(mediaReplacements.stagingObjectKey, replacement.stagingObjectKey))).returning({ mediaId: mediaReplacements.mediaId }))[0]) return yield* persistenceFailure$2("MediaStore.Drizzle.finishReplace", /* @__PURE__ */ new Error(`Media replacement "${replacement.mediaId}" lost its durable intent.`));
 		const decoded = yield* decodeMediaRecord(replaced);
 		const intent = yield* decodeMediaChangeIntent(change);
 		yield* resolveChange(transaction, change, {
@@ -8509,7 +7087,7 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 			kind: "applied"
 		});
 		return decoded;
-	})).pipe(mapStoreFailure$1("MediaStore.Drizzle.finishReplace")));
+	})).pipe(mapStoreFailure$2("MediaStore.Drizzle.finishReplace")));
 	const cancelReplace = Effect.fn("MediaStore.Drizzle.cancelReplace")((replacement) => database.transaction((transaction) => Effect.gen(function* () {
 		yield* lockedRowById(transaction, replacement.mediaId);
 		const existing = yield* replacementByMediaId(transaction, replacement.mediaId);
@@ -8518,7 +7096,7 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 		const change = yield* requirePendingChange(transaction, mediaSubject(replacement.mediaId), "media.replaced");
 		if (!(yield* transaction.delete(mediaReplacements).where(and(eq(mediaReplacements.mediaId, replacement.mediaId), eq(mediaReplacements.staged, replacement.staged), eq(mediaReplacements.stagingObjectKey, replacement.stagingObjectKey))).returning({ mediaId: mediaReplacements.mediaId }))[0]) return yield* new MediaConflict({ mediaId: replacement.mediaId });
 		yield* resolveChange(transaction, change, { kind: "cancelled" });
-	})).pipe(mapStoreFailure$1("MediaStore.Drizzle.cancelReplace")));
+	})).pipe(mapStoreFailure$2("MediaStore.Drizzle.cancelReplace")));
 	const finishDelete = Effect.fn("MediaStore.Drizzle.finishDelete")((id) => database.transaction((transaction) => Effect.gen(function* () {
 		const existing = yield* lockedRowById(transaction, id);
 		if (!existing) return;
@@ -8530,7 +7108,7 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 			details: mediaChangeDetails(intent),
 			kind: "applied"
 		});
-	})).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.finishDelete")));
+	})).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.finishDelete")));
 	const abandonUpload = Effect.fn("MediaStore.Drizzle.abandonUpload")((id) => database.transaction((transaction) => Effect.gen(function* () {
 		const existing = yield* lockedRowById(transaction, id);
 		if (!existing) return;
@@ -8538,15 +7116,15 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 		const change = yield* requirePendingChange(transaction, mediaSubject(id), "media.uploaded");
 		if (!(yield* transaction.delete(mediaAssets).where(and(eq(mediaAssets.id, id), eq(mediaAssets.status, "uploading"))).returning({ id: mediaAssets.id }))[0]) return yield* transitionFailure("MediaStore.Drizzle.abandonUpload", id, existing.status);
 		yield* resolveChange(transaction, change, { kind: "cancelled" });
-	})).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.abandonUpload")));
+	})).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.abandonUpload")));
 	const pending = Effect.fn("MediaStore.Drizzle.pending")((query) => Effect.gen(function* () {
-		const rows = yield* database.select().from(mediaAssets).where(and(ne(mediaAssets.status, "ready"), lte(mediaAssets.updatedAt, DateTime.formatIso(query.before)))).orderBy(asc(mediaAssets.updatedAt), asc(mediaAssets.id)).limit(query.limit);
+		const rows = yield* database.select().from(mediaAssets).where(and(ne(mediaAssets.status, "ready"), lte(mediaAssets.updatedAt, DateTime.formatIso(query.before)), query.after === void 0 ? void 0 : gt(mediaAssets.id, query.after))).orderBy(asc(mediaAssets.id)).limit(query.limit);
 		return yield* Effect.forEach(rows, decodeMediaRecord);
-	}).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.pending")));
+	}).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.pending")));
 	const pendingReplacements = Effect.fn("MediaStore.Drizzle.pendingReplacements")((query) => Effect.gen(function* () {
-		const rows = yield* database.select().from(mediaReplacements).where(lte(mediaReplacements.updatedAt, DateTime.formatIso(query.before))).orderBy(asc(mediaReplacements.updatedAt), asc(mediaReplacements.mediaId)).limit(query.limit);
+		const rows = yield* database.select().from(mediaReplacements).where(and(lte(mediaReplacements.updatedAt, DateTime.formatIso(query.before)), query.after === void 0 ? void 0 : gt(mediaReplacements.mediaId, query.after))).orderBy(asc(mediaReplacements.mediaId)).limit(query.limit);
 		return yield* Effect.forEach(rows, decodeMediaReplacement);
-	}).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.pendingReplacements")));
+	}).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.pendingReplacements")));
 	const inspectReplacement = Effect.fn("MediaStore.Drizzle.inspectReplacement")((replacement) => database.transaction((transaction) => Effect.gen(function* () {
 		const asset = yield* lockedRowById(transaction, replacement.mediaId);
 		const pending = yield* replacementByMediaId(transaction, replacement.mediaId);
@@ -8555,17 +7133,17 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 			return yield* new MediaConflict({ mediaId: replacement.mediaId });
 		}
 		return asset && isCompletedReplacement(asset, replacement) ? "completed" : "absent";
-	})).pipe(mapStoreFailure$1("MediaStore.Drizzle.inspectReplacement")));
+	})).pipe(mapStoreFailure$2("MediaStore.Drizzle.inspectReplacement")));
 	const inventory = Effect.gen(function* () {
 		const rows = yield* database.select().from(mediaAssets).where(eq(mediaAssets.status, "ready")).orderBy(asc(mediaAssets.objectKey));
 		return yield* Effect.forEach(rows, decodeMediaRecord);
-	}).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.inventory"), Effect.withSpan("MediaStore.Drizzle.inventory"));
+	}).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.inventory"), Effect.withSpan("MediaStore.Drizzle.inventory"));
 	const knownObjectKeys = Effect.gen(function* () {
 		const assetRows = yield* database.select({ objectKey: mediaAssets.objectKey }).from(mediaAssets).orderBy(asc(mediaAssets.objectKey));
 		const replacementRows = yield* database.select({ objectKey: mediaReplacements.stagingObjectKey }).from(mediaReplacements).orderBy(asc(mediaReplacements.stagingObjectKey));
 		const objectKeys = yield* Schema.decodeEffect(Schema.Array(MediaObjectKey))([...assetRows, ...replacementRows].map((row) => row.objectKey));
 		return new Set(objectKeys);
-	}).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.knownObjectKeys"), Effect.withSpan("MediaStore.Drizzle.knownObjectKeys"));
+	}).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.knownObjectKeys"), Effect.withSpan("MediaStore.Drizzle.knownObjectKeys"));
 	const search = Effect.fn("MediaStore.Drizzle.search")((query) => database.transaction((transaction) => Effect.gen(function* () {
 		const normalizedSearch = query.search?.trim();
 		const pattern = normalizedSearch ? `%${escapeLike(normalizedSearch)}%` : void 0;
@@ -8574,14 +7152,14 @@ const mediaStoreLayer = Layer.effect(MediaStore, Effect.gen(function* () {
 		const rows = yield* transaction.select().from(mediaAssets).where(and(filters, cursorFilter)).orderBy(desc(mediaAssets.createdAt), desc(mediaAssets.id)).limit(query.limit + 1);
 		const folderRows = yield* transaction.selectDistinct({ folder: mediaAssets.folder }).from(mediaAssets).where(and(eq(mediaAssets.status, "ready"), ne(mediaAssets.folder, ""))).orderBy(asc(mediaAssets.folder));
 		const total = (yield* transaction.select({ value: count() }).from(mediaAssets).where(filters))[0]?.value;
-		if (total === void 0) return yield* persistenceFailure$1("MediaStore.Drizzle.search", /* @__PURE__ */ new Error("Media persistence did not return a search total."));
+		if (total === void 0) return yield* persistenceFailure$2("MediaStore.Drizzle.search", /* @__PURE__ */ new Error("Media persistence did not return a search total."));
 		const decoded = yield* Effect.forEach(rows, decodeMediaRecord);
 		const folders = yield* Schema.decodeEffect(Schema.Array(MediaFolder))(folderRows.map((row) => row.folder)).pipe(Effect.mapError((cause) => mediaPersistenceError("MediaStore.Drizzle.search", cause)));
 		return mediaPage(decoded, query.limit, folders, total);
 	}), {
 		accessMode: "read only",
 		isolationLevel: "repeatable read"
-	}).pipe(mapPersistenceFailure$1("MediaStore.Drizzle.search")));
+	}).pipe(mapPersistenceFailure$2("MediaStore.Drizzle.search")));
 	return MediaStore.of({
 		abandonUpload,
 		activate,
@@ -8666,45 +7244,230 @@ const replacementByMediaId = Effect.fn("MediaStore.Drizzle.replacementByMediaId"
 	return rows[0] ? yield* decodeMediaReplacement(rows[0]) : void 0;
 });
 function transitionFailure(operation, id, actualStatus) {
-	return persistenceFailure$1(operation, /* @__PURE__ */ new Error(actualStatus === void 0 ? `Media record "${id}" does not exist.` : `Media record "${id}" cannot transition from "${actualStatus}".`));
+	return persistenceFailure$2(operation, /* @__PURE__ */ new Error(actualStatus === void 0 ? `Media record "${id}" does not exist.` : `Media record "${id}" cannot transition from "${actualStatus}".`));
 }
-function mapPersistenceFailure$1(operation) {
+function mapPersistenceFailure$2(operation) {
 	return (effect) => effect.pipe(Effect.mapError((cause) => isMediaPersistenceError(cause) ? cause : mediaPersistenceError(operation, cause)));
 }
-function mapStoreFailure$1(operation) {
+function mapStoreFailure$2(operation) {
 	return (effect) => effect.pipe(Effect.mapError((cause) => isMediaConflict(cause) || isMediaPersistenceError(cause) ? cause : mediaPersistenceError(operation, cause)));
 }
 function mapBeginDeleteFailure(operation) {
 	return (effect) => effect.pipe(Effect.mapError((cause) => isMediaConflict(cause) || isMediaNotFound(cause) || isMediaPersistenceError(cause) || isMediaReferenced(cause) ? cause : mediaPersistenceError(operation, cause)));
 }
-function persistenceFailure$1(operation, cause) {
+function persistenceFailure$2(operation, cause) {
 	return Effect.fail(mediaPersistenceError(operation, cause));
 }
 
 //#endregion
-//#region ../sql-pg/src/internal/readiness.ts
-const postgresReadinessLayer = Layer.effect(Readiness, Effect.gen(function* () {
-	const postgres = yield* PgClient.PgClient;
-	const journal = yield* ChangeJournal;
-	const check = Effect.gen(function* () {
-		yield* postgres.unsafe("select 1");
-		const now = yield* DateTime.now;
-		const pending = yield* journal.pending({
-			before: DateTime.subtractDuration(now, "30 seconds"),
-			limit: 1
-		});
-		const oldest = pending.changes[0];
-		if (pending.total === 0 || oldest === void 0) return;
-		yield* Effect.logWarning("CMS readiness found a stale pending change.", {
-			action: oldest.action,
-			ageMillis: DateTime.toEpochMillis(now) - DateTime.toEpochMillis(oldest.updatedAt),
-			changeId: oldest.id,
-			phase: "pending"
+//#region ../sql-pg/src/internal/seo/seo-store.ts
+const SeoStoreDomainError = Schema.Union([
+	SeoMediaUnavailable,
+	SeoPersistenceError,
+	SeoVersionConflict
+]);
+const isSeoStoreDomainError = Schema.is(SeoStoreDomainError);
+const isSeoPersistenceError = Schema.is(SeoPersistenceError);
+const systemActivity = {
+	actor: {
+		email: "system@cms.invalid",
+		id: "system",
+		name: "CMS System",
+		roles: ["system"]
+	},
+	requestId: RequestId.make("00000000-0000-4000-8000-000000000000")
+};
+const seoStoreLayer = Layer.effect(SeoStore, Effect.gen(function* () {
+	const database = yield* PgDrizzle.makeWithDefaults();
+	const initialize = Effect.fn("SeoStore.Drizzle.initialize")((defaults) => database.transaction((transaction) => Effect.gen(function* () {
+		yield* transaction.execute(sql`SELECT pg_advisory_xact_lock(hashtext('cms:seo:singleton:v1'))`);
+		const current = yield* readSnapshot(transaction);
+		if (current) return current;
+		yield* ensureMediaAvailable(transaction, defaults).pipe(Effect.mapError((cause) => new SeoPersistenceError({
+			cause,
+			operation: "SeoStore.Drizzle.initializeDefaults"
+		})));
+		const revision = yield* insertRevision(transaction, defaults, systemActivity);
+		yield* transaction.insert(seoState).values({
+			publishedRevisionId: revision.revisionId,
+			workingRevisionId: revision.revisionId
 		});
-		return yield* new ReadinessFailed({ cause: /* @__PURE__ */ new Error("A stale change remains pending.") });
-	}).pipe(Effect.mapError((cause) => Schema.is(ReadinessFailed)(cause) ? cause : new ReadinessFailed({ cause })), Effect.withSpan("Installation.readiness"));
-	return Readiness.of({ check });
+		yield* replaceMediaReferences(transaction, "working", defaults);
+		yield* replaceMediaReferences(transaction, "published", defaults);
+		return {
+			published: revision,
+			working: revision
+		};
+	})).pipe(mapStoreFailure$1("SeoStore.Drizzle.initialize")));
+	const load = database.transaction((transaction) => readSnapshot(transaction), {
+		accessMode: "read only",
+		isolationLevel: "repeatable read"
+	}).pipe(mapPersistenceFailure$1("SeoStore.Drizzle.load"));
+	const save = Effect.fn("SeoStore.Drizzle.save")((input) => database.transaction((transaction) => Effect.gen(function* () {
+		const current = yield* lockedSnapshot(transaction);
+		yield* requireVersion(current, input.expectedVersion);
+		yield* ensureMediaAvailable(transaction, input.settings);
+		const revision = yield* insertRevision(transaction, input.settings, input.activity);
+		yield* transaction.update(seoState).set({ workingRevisionId: revision.revisionId }).where(eq(seoState.singleton, true));
+		yield* replaceMediaReferences(transaction, "working", input.settings);
+		yield* recordActivity(transaction, "seo.saved", input.activity, {
+			previousVersion: current.working.version,
+			version: revision.version
+		}, ActivityId.make(revision.revisionId));
+		return {
+			...current,
+			working: revision
+		};
+	})).pipe(mapStoreFailure$1("SeoStore.Drizzle.save")));
+	const publish = Effect.fn("SeoStore.Drizzle.publish")((input) => database.transaction((transaction) => Effect.gen(function* () {
+		const current = yield* lockedSnapshot(transaction);
+		yield* requireVersion(current, input.expectedVersion);
+		yield* ensureMediaAvailable(transaction, current.working.settings);
+		yield* transaction.update(seoState).set({ publishedRevisionId: current.working.revisionId }).where(eq(seoState.singleton, true));
+		yield* replaceMediaReferences(transaction, "published", current.working.settings);
+		yield* recordActivity(transaction, "seo.published", input.activity, { version: current.working.version });
+		return {
+			...current,
+			published: current.working
+		};
+	})).pipe(mapStoreFailure$1("SeoStore.Drizzle.publish")));
+	return SeoStore.of({
+		initialize,
+		load,
+		publish,
+		save
+	});
 }));
+const readSnapshot = Effect.fn("SeoStore.Drizzle.readSnapshot")(function* (database) {
+	const state = (yield* database.select().from(seoState).limit(1))[0];
+	if (!state) return void 0;
+	const revisionRows = yield* database.select().from(seoRevisions).where(inArray(seoRevisions.id, [state.workingRevisionId, state.publishedRevisionId]));
+	const revisions = yield* Effect.forEach(revisionRows, decodeRevision);
+	const working = revisions.find((revision) => revision.revisionId === state.workingRevisionId);
+	const published = revisions.find((revision) => revision.revisionId === state.publishedRevisionId);
+	if (!working || !published) return yield* persistenceFailure$1("SeoStore.Drizzle.readSnapshot", /* @__PURE__ */ new Error("SEO state points to a missing revision."));
+	return {
+		published,
+		working
+	};
+});
+const lockedSnapshot = Effect.fn("SeoStore.Drizzle.lockSnapshot")(function* (transaction) {
+	if (!(yield* transaction.select().from(seoState).where(eq(seoState.singleton, true)).for("update").limit(1))[0]) return yield* persistenceFailure$1("SeoStore.Drizzle.lockSnapshot", /* @__PURE__ */ new Error("SEO state is not initialized."));
+	return (yield* readSnapshot(transaction)) ?? (yield* persistenceFailure$1("SeoStore.Drizzle.lockSnapshot", /* @__PURE__ */ new Error("SEO state disappeared.")));
+});
+const insertRevision = Effect.fn("SeoStore.Drizzle.insertRevision")(function* (transaction, settings, activity) {
+	const row = (yield* transaction.insert(seoRevisions).values({
+		actorEmail: activity.actor.email,
+		actorId: activity.actor.id,
+		actorName: activity.actor.name,
+		actorRoles: activity.actor.roles,
+		reason: activity.reason,
+		requestId: activity.requestId,
+		settings
+	}).returning())[0];
+	return row ? yield* decodeRevision(row) : yield* persistenceFailure$1("SeoStore.Drizzle.insertRevision", /* @__PURE__ */ new Error("No revision row returned."));
+});
+const decodeRevision = Effect.fn("SeoStore.Drizzle.decodeRevision")(function* (row) {
+	return yield* Schema.decodeEffect(SeoRevision)({
+		editedAt: row.createdAt,
+		editedBy: {
+			email: row.actorEmail,
+			id: row.actorId,
+			name: row.actorName,
+			roles: row.actorRoles
+		},
+		revisionId: row.id,
+		settings: row.settings,
+		version: row.id
+	}).pipe(Effect.mapError((cause) => new SeoPersistenceError({
+		cause,
+		operation: "SeoStore.Drizzle.decodeRevision"
+	})));
+});
+function requireVersion(snapshot, expectedVersion) {
+	return snapshot.working.version === expectedVersion ? Effect.void : Effect.fail(new SeoVersionConflict({
+		actualVersion: snapshot.working.version,
+		expectedVersion
+	}));
+}
+const ensureMediaAvailable = Effect.fn("SeoStore.Drizzle.ensureMediaAvailable")(function* (transaction, settings) {
+	const mediaIds = settingsMediaIds(settings);
+	if (mediaIds.length === 0) return;
+	const initialRows = yield* transaction.select({
+		id: mediaAssets.id,
+		objectKey: mediaAssets.objectKey
+	}).from(mediaAssets).where(inArray(mediaAssets.id, mediaIds));
+	const objectKeys = yield* Schema.decodeEffect(Schema.Array(MediaObjectKey))(initialRows.map((row) => row.objectKey));
+	yield* lockMediaReferenceKeys(transaction, objectKeys);
+	const readyRows = yield* transaction.select({
+		id: mediaAssets.id,
+		objectKey: mediaAssets.objectKey
+	}).from(mediaAssets).where(and(inArray(mediaAssets.id, mediaIds), eq(mediaAssets.status, "ready")));
+	const unavailable = settingsMediaImages(settings).find((image) => {
+		const asset = readyRows.find((row) => row.id === image.mediaId);
+		return !asset || mediaObjectKey(image.url) !== asset.objectKey;
+	});
+	if (unavailable) return yield* new SeoMediaUnavailable({ mediaId: unavailable.mediaId });
+});
+const replaceMediaReferences = Effect.fn("SeoStore.Drizzle.replaceMediaReferences")(function* (transaction, scope, settings) {
+	yield* transaction.delete(seoMediaReferences).where(eq(seoMediaReferences.scope, scope));
+	const mediaIds = settingsMediaIds(settings);
+	if (mediaIds.length > 0) yield* transaction.insert(seoMediaReferences).values(mediaIds.map((mediaId) => ({
+		mediaId,
+		scope
+	})));
+});
+function settingsMediaIds(settings) {
+	return [...new Set(settingsMediaImages(settings).map((image) => image.mediaId))];
+}
+function settingsMediaImages(settings) {
+	const images = [settings.socialImage];
+	const identity = settings.identity;
+	if (identity?.type === "Person") images.push(identity.image);
+	if (identity?.type === "Organization") images.push(identity.logo);
+	if (identity?.type === "LocalBusiness") images.push(identity.logo, identity.image);
+	return images.filter((image) => image !== void 0);
+}
+function mediaObjectKey(url) {
+	try {
+		const encodedKey = new URL(url).pathname.match(/(?:^|\/)(media\/[^/]+)$/u)?.[1];
+		return encodedKey ? encodedKey.split("/").map(decodeURIComponent).join("/") : void 0;
+	} catch {
+		return;
+	}
+}
+const recordActivity = Effect.fn("SeoStore.Drizzle.recordActivity")(function* (transaction, action, context, details, id) {
+	yield* transaction.insert(activityEntries).values({
+		action,
+		actorEmail: context.actor.email,
+		actorId: context.actor.id,
+		actorName: context.actor.name,
+		actorRoles: context.actor.roles,
+		details,
+		id,
+		reason: context.reason,
+		requestId: context.requestId,
+		targetKind: "seo"
+	});
+});
+function mapStoreFailure$1(operation) {
+	return (effect) => effect.pipe(Effect.mapError((cause) => isSeoStoreDomainError(cause) ? cause : new SeoPersistenceError({
+		cause,
+		operation
+	})));
+}
+function mapPersistenceFailure$1(operation) {
+	return (effect) => effect.pipe(Effect.mapError((cause) => isSeoPersistenceError(cause) ? cause : new SeoPersistenceError({
+		cause,
+		operation
+	})));
+}
+function persistenceFailure$1(operation, cause) {
+	return Effect.fail(new SeoPersistenceError({
+		cause,
+		operation
+	}));
+}
 
 //#endregion
 //#region ../sql-pg/src/internal/user-administration/user-command-fence.ts
@@ -8722,7 +7485,7 @@ const postgresUserCommandFenceLayer = Layer.effect(UserCommandFence, PostgresAdv
 const WORKING_DOCUMENT_CHANGES_CHANNEL = "cms_working_documents";
 const WorkingDocumentChangePayload = Schema.fromJsonString(WorkingDocumentChange);
 function workingDocumentChangePayload(change) {
-	return Schema.encodeSync(WorkingDocumentChangePayload)(change);
+	return Result.getOrThrow(Schema.encodeResult(WorkingDocumentChangePayload)(change));
 }
 const decodeWorkingDocumentChangePayload = Schema.decodeUnknownEffect(WorkingDocumentChangePayload);
 
@@ -8757,12 +7520,13 @@ const makePostgresChanges = Effect.fn("WorkingDocumentChanges.makePostgres")(fun
 		const postgres = Context.get(context, PgClient.PgClient);
 		const heartbeats = /* @__PURE__ */ new Map();
 		let heartbeat = 0;
-		const listener = yield* postgres.listen(WORKING_DOCUMENT_CHANGES_CHANNEL).pipe(Stream.runForEach((payload) => {
-			const waiting = heartbeats.get(payload);
+		const notifications = yield* postgres.listen(WORKING_DOCUMENT_CHANGES_CHANNEL).pipe(Effect.mapError((cause) => changesError("listen", cause)));
+		const listener = yield* Stream.fromQueue(notifications).pipe(Stream.runForEach((payload) => {
+			const waiting = heartbeats.get(payload.payload);
 			if (waiting !== void 0) return Deferred.succeed(waiting, void 0).pipe(Effect.asVoid);
-			if (payload.startsWith("__cms_probe__:")) return Effect.void;
-			return decodeWorkingDocumentChangePayload(payload).pipe(Effect.flatMap((change) => PubSub.publish(changes, change)), Effect.asVoid, Effect.catchCause((cause) => Effect.logWarning("Ignored an invalid Working Document change.", Cause.pretty(cause))));
-		}), Effect.mapError((cause) => changesError("listen", cause))).pipe(Effect.forkScoped({ startImmediately: true }));
+			if (payload.payload.startsWith("__cms_probe__:")) return Effect.void;
+			return decodeWorkingDocumentChangePayload(payload.payload).pipe(Effect.flatMap((change) => PubSub.publish(changes, change)), Effect.asVoid, Effect.catchCause((cause) => Effect.logWarning("Ignored an invalid Working Document change.", Cause.pretty(cause))));
+		}), Effect.catchCause((cause) => Effect.fail(changesError("listen", cause)))).pipe(Effect.forkScoped({ startImmediately: true }));
 		const pulse = Effect.gen(function* () {
 			heartbeat += 1;
 			const payload = `__cms_probe__:${session}:${heartbeat}`;
@@ -9320,16 +8084,13 @@ function postgresLayer(options) {
 	});
 	const migrations = cmsDatabaseMigrationLayer.pipe(Layer.provide(database));
 	const locks = postgresAdvisoryLockLayer(options);
-	const stores = Layer.mergeAll(postgresActivityStoreLayer, changeJournalLayer, documentStoreLayer, mediaStoreLayer, initializationStoreLayer.pipe(Layer.provide(locks)), postgresUserCommandFenceLayer.pipe(Layer.provide(locks)), postgresWorkingDocumentChangesLayer(options), workingDocumentStoreLayer).pipe(Layer.provide(migrations), Layer.provide(database));
-	const readiness = postgresReadinessLayer.pipe(Layer.provide(stores), Layer.provide(database));
-	return Layer.merge(stores, readiness);
+	return Layer.mergeAll(postgresActivityStoreLayer, changeJournalLayer, documentStoreLayer, mediaStoreLayer, seoStoreLayer, initializationStoreLayer.pipe(Layer.provide(locks)), postgresUserCommandFenceLayer.pipe(Layer.provide(locks)), postgresWorkingDocumentChangesLayer(options), workingDocumentStoreLayer).pipe(Layer.provide(migrations), Layer.provide(database));
 }
 
 //#endregion
 //#region src/runtime/installation.ts
-/** Composes the private providers selected by the Nuxt product adapter. */
 const installCms = Effect.fn("NuxtCmsInstallation.install")(function* (options) {
-	const crypto = NodeCrypto$1.layer;
+	const crypto = NodeCrypto.layer;
 	const postgres = postgresLayer({ url: Redacted.make(options.databaseUrl) });
 	const identity = Layer.unwrap(Effect.acquireRelease(Effect.sync(() => new Pool({ connectionString: options.databaseUrl })), (pool) => Effect.promise(() => pool.end()).pipe(Effect.asVoid)).pipe(Effect.map((pool) => betterAuthLayer({
 		baseURL: options.baseUrl,
@@ -9339,6 +8100,7 @@ const installCms = Effect.fn("NuxtCmsInstallation.install")(function* (options)
 	const core = Layer.mergeAll(crypto, postgres, identity);
 	return yield* installCms$1({
 		baseUrl: options.baseUrl,
+		formHandlers: options.formHandlers,
 		authoring: options.authoring,
 		bootstrap: options.bootstrap,
 		cleanup: options.cleanup.enabled ? {
@@ -9353,7 +8115,6 @@ const installCms = Effect.fn("NuxtCmsInstallation.install")(function* (options)
 			} : void 0
 		},
 		documentModel: options.documentModel,
-		initialSources: options.initialSources,
 		initializationToken: Redacted.make(options.initializationToken),
 		studioSecret: Redacted.make(`cms-collaboration:${options.secret}`)
 	});
@@ -9377,4 +8138,4 @@ function toS3MediaObjectStoreOptions(options) {
 
 //#endregion
 export { toS3MediaObjectStoreOptions as n, installCms as t };
-//# sourceMappingURL=installation-DeuBiFRE.js.map
+//# sourceMappingURL=installation-CNfIriVm.js.map