@phtngyn/cms 0.2.0-beta.7 → 0.3.0

package/src/S3MediaObjects-Dwhl2deX.js

@@ -1,2742 +0,0 @@
-import { i as DocumentVersion, l as Slug, n as DocumentHistoryCursor, o as PublicPath, r as DocumentId, s as RevisionId, t as DocumentGeneration, u as nonNegativeInt } from "./scalars-CVZqT3L0.js";
-import { $ as MEDIA_ACTIONS, A as RestoreDocumentInput, B as SeoConfiguration, C as MoveDocumentInput, D as PublishedDocumentQuery, E as PublishedDocumentPage, F as GlobalSeoSettings, G as SeoSnapshot, H as SeoMediaUnavailable, I as PublishSeoInput, J as SeoVersionConflict, K as SeoState, L as SaveSeoInput, N as UpdateDocumentInput, O as PublishedDocumentSurroundQuery, Q as DOCUMENT_ACTIONS, R as SeoCanonicalOrigin, T as PublishedDocumentLookup, U as SeoMutationResult, V as SeoConfirmationRequired, X as AccessDenied, Y as SitemapEntry, Z as AuthenticationRequired, b as DocumentValidationResult, d as DocumentNavigationItem, et as Role, f as DocumentNavigationQuery, g as DocumentSource, h as DocumentRevisionAction, i as CreateDocumentInput, j as UndeleteDocumentInput, k as RemoveDocumentInput, l as DocumentIssue, m as DocumentQueryScalar, n as CmsMarkdownDocument, nt as StudioEntryDenied, o as DeletedDocument, p as DocumentPlacement, q as SeoUrl, r as CompiledDocument, s as DocumentBrowseQuery, st as RequestId, tt as StudioActor, u as DocumentMutationResult, v as DocumentSummary, w as PublishDocumentInput, x as DuplicateDocumentInput, y as DocumentSurround, z as SeoCapabilities } from "./models-VmGmG19-.js";
-import { _ as MediaReferenced, a as MediaConflict, b as MediaUpload, c as MediaId, f as MediaNotFound, g as MediaReference, h as MediaQuery, i as MediaCleanupReport, l as MediaIntegrityReport, m as MediaPage, n as MediaAsset, p as MediaObjectKey, r as MediaByteSize, s as MediaFolder, t as ImageMimeType, u as MediaInvalid, y as MediaTooLarge } from "./Media-j1bTritO.js";
-import { a as ContentSnapshot, c as ContentTransferConflict, d as DocumentNotFound, f as DocumentRouteConflict, h as PublishedDocumentNotFound, i as ContentPlan, l as ContentTransferInput, m as DocumentVersionConflict, n as ContentApplyResult, p as DocumentValidationFailed, t as ContentApplyInput, u as DocumentMediaUnavailable } from "./ContentTransfer-BxwswWn3.js";
-import { u as STUDIO_API_PATH } from "./HttpPaths-c9nLZ9H2.js";
-import { c as FormSubmission, o as FormResult } from "./Forms-CfNPTiCr.js";
-import { m as toComarkDocument } from "./Forms-CX-hwmJF.js";
-import { i as withoutEditorMetadata } from "./metadata-DN9_K6Yl.js";
-import { f as EditorRenderFailed, i as MediaConfiguration, r as DocumentConfiguration } from "./Configuration-Da5B2PVH.js";
-import { n as DocumentCompilationFailed, t as createDocumentEngine } from "./DocumentEngine-hh_IGPXO.js";
-import { Context, Crypto, Data, DateTime, Effect, Encoding, Layer, Option, Predicate, PubSub, Redacted, Ref, Result, Schedule, Schema, Semaphore, Stream, flow } from "effect";
-import { NodeStream } from "@effect/platform-node-shared";
-import { Multipart } from "effect/unstable/http";
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
-import { renderMarkdown } from "comark/render";
-import { diffArrays } from "diff";
-import { CopyObjectCommand, CreateBucketCommand, DeleteObjectCommand, HeadBucketCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
-
-//#region ../protocol/src/Activity.ts
-/**
-* Immutable completed Activity facts. Pages are ordered newest-first; cursors are opaque,
-* stable continuation tokens and an invalid cursor is a caller-visible failure.
-*/
-const ActivityId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("ActivityId"));
-const ActivityCursor = Schema.NonEmptyString.pipe(Schema.brand("ActivityCursor"));
-const ACTIVITY_ACTIONS = [
-	"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"
-];
-const ActivityAction = Schema.Literals(ACTIVITY_ACTIONS);
-const DocumentActivityTarget = Schema.Struct({
-	kind: Schema.tag("document"),
-	documentId: DocumentId
-});
-const MediaActivityTarget = Schema.Struct({
-	kind: Schema.tag("media"),
-	mediaId: MediaId
-});
-const MediaLibraryActivityTarget = Schema.Struct({ kind: Schema.tag("media-library") });
-const ActivityTarget = Schema.Union([
-	DocumentActivityTarget,
-	MediaActivityTarget,
-	MediaLibraryActivityTarget,
-	Schema.Struct({ kind: Schema.tag("seo") }),
-	Schema.Struct({
-		kind: Schema.tag("user"),
-		userId: Schema.NonEmptyString
-	})
-]).pipe(Schema.toTaggedUnion("kind"));
-const ActivityTargetKind = Schema.Literals([
-	"document",
-	"media",
-	"media-library",
-	"seo",
-	"user"
-]);
-const ActivityContext = Schema.Struct({
-	actor: StudioActor,
-	requestId: RequestId,
-	reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1e3)))
-}).annotate({ identifier: "ActivityContext" });
-const ActivityEntry = Schema.Struct({
-	id: ActivityId,
-	action: ActivityAction,
-	actor: StudioActor,
-	requestId: RequestId,
-	reason: ActivityContext.fields.reason,
-	target: ActivityTarget,
-	details: Schema.JsonObject,
-	occurredAt: Schema.DateTimeUtcFromString
-}).annotate({ identifier: "ActivityEntry" });
-const ActivityEntryDraft = Schema.Struct({
-	action: ActivityAction,
-	context: ActivityContext,
-	target: ActivityTarget,
-	details: Schema.JsonObject
-}).annotate({ identifier: "ActivityEntryDraft" });
-const ActivityQuery = Schema.Struct({
-	action: Schema.optionalKey(ActivityAction),
-	actorId: Schema.optionalKey(StudioActor.fields.id),
-	cursor: Schema.optionalKey(ActivityCursor),
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 100
-	}))),
-	requestId: Schema.optionalKey(RequestId),
-	targetId: Schema.optionalKey(Schema.NonEmptyString),
-	targetKind: Schema.optionalKey(ActivityTargetKind)
-}).annotate({ identifier: "ActivityQuery" });
-const ActivityPage = Schema.Struct({
-	entries: Schema.Array(ActivityEntry),
-	nextCursor: Schema.optionalKey(ActivityCursor),
-	total: nonNegativeInt
-}).annotate({ identifier: "ActivityPage" });
-var ActivityCursorInvalid = class extends Schema.TaggedError()("Activity.CursorInvalid", {}) {};
-
-//#endregion
-//#region ../protocol/src/internal/documents/history.ts
-const DocumentRevisionSummary = Schema.Struct({
-	action: DocumentRevisionAction,
-	activity: ActivityEntry,
-	createdAt: Schema.DateTimeUtcFromString,
-	documentId: DocumentId,
-	placement: DocumentPlacement,
-	revisionId: RevisionId,
-	version: DocumentVersion
-}).annotate({ identifier: "DocumentRevisionSummary" });
-const DocumentRevision = Schema.Struct({
-	...DocumentRevisionSummary.fields,
-	markdown: Schema.String
-}).annotate({ identifier: "DocumentRevision" });
-const DocumentHistoryQuery = Schema.Struct({
-	documentId: DocumentId,
-	cursor: Schema.optionalKey(DocumentHistoryCursor),
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 100
-	})))
-}).annotate({ identifier: "DocumentHistoryQuery" });
-const DocumentRevisionPage = Schema.Struct({
-	revisions: Schema.Array(DocumentRevisionSummary),
-	nextCursor: Schema.optionalKey(DocumentHistoryCursor),
-	total: nonNegativeInt
-}).annotate({ identifier: "DocumentRevisionPage" });
-const LineNumber = Schema.Int.check(Schema.isGreaterThan(0));
-const DocumentRevisionChange = Schema.Union([
-	Schema.Struct({
-		kind: Schema.tag("equal"),
-		beforeLine: LineNumber,
-		afterLine: LineNumber,
-		line: Schema.String
-	}),
-	Schema.Struct({
-		kind: Schema.tag("added"),
-		afterLine: LineNumber,
-		line: Schema.String
-	}),
-	Schema.Struct({
-		kind: Schema.tag("removed"),
-		beforeLine: LineNumber,
-		line: Schema.String
-	})
-]).pipe(Schema.toTaggedUnion("kind"));
-const CompareDocumentRevisionsInput = Schema.Struct({
-	documentId: DocumentId,
-	fromRevisionId: RevisionId,
-	toRevisionId: RevisionId
-}).annotate({ identifier: "CompareDocumentRevisionsInput" });
-const DocumentRevisionComparison = Schema.Struct({
-	from: DocumentRevision,
-	to: DocumentRevision,
-	changes: Schema.Array(DocumentRevisionChange)
-}).annotate({ identifier: "DocumentRevisionComparison" });
-var DocumentHistoryInvalidCursor = class extends Schema.TaggedError()("DocumentHistory.InvalidCursor", {}) {};
-var DocumentHistoryComparisonTooLarge = class extends Schema.TaggedError()("DocumentHistory.ComparisonTooLarge", {
-	maximumEditLength: Schema.Int.check(Schema.isGreaterThan(0)),
-	maximumLines: Schema.Int.check(Schema.isGreaterThan(0))
-}) {};
-
-//#endregion
-//#region ../protocol/src/Collaboration.ts
-/**
-* Collaboration handshake and WebSocket envelopes. Command results correlate by RequestId;
-* checkpoints carry the durable state vector needed for retry and recovery.
-*/
-const StateVector = Schema.String.check(Schema.isBase64()).pipe(Schema.brand("StateVector"));
-const HttpErrorStatus = Schema.Int.check(Schema.isBetween({
-	minimum: 400,
-	maximum: 599
-}));
-const CollaborationUser = Schema.Struct({
-	color: Schema.NonEmptyString,
-	id: Schema.NonEmptyString,
-	name: Schema.NonEmptyString
-});
-const CollaborationTicket = Schema.Struct({
-	authoringRevision: Schema.NonEmptyString,
-	authoredStateVector: StateVector,
-	documentName: Schema.NonEmptyString,
-	source: DocumentSource,
-	token: Schema.NonEmptyString,
-	url: Schema.NonEmptyString,
-	user: CollaborationUser,
-	workingStateVector: StateVector
-}).annotate({ identifier: "CollaborationTicket" });
-const CollaborationPreview = DocumentValidationResult.pipe(Schema.fieldsAssign({
-	markdown: Schema.String,
-	preview: Schema.Struct({
-		body: CmsMarkdownDocument,
-		fallbacks: Schema.Record(Schema.String, Schema.String)
-	})
-})).annotate({ identifier: "CollaborationPreview" });
-const CheckpointMessage = Schema.Struct({ type: Schema.tag("checkpoint") });
-const PreviewMessage = Schema.Struct({
-	type: Schema.tag("preview"),
-	requestId: RequestId
-});
-const PublishMessage = Schema.Struct({
-	type: Schema.tag("publish"),
-	requestId: RequestId
-});
-const CollaborationClientMessage = Schema.Union([
-	CheckpointMessage,
-	PreviewMessage,
-	PublishMessage
-]).pipe(Schema.toTaggedUnion("type"));
-const requestFailure = {
-	error: Schema.NonEmptyString,
-	statusCode: HttpErrorStatus
-};
-const RequestFailure = Schema.Struct({
-	status: Schema.tag("failure"),
-	...requestFailure
-});
-const PreviewOutcome = Schema.Union([Schema.Struct({
-	status: Schema.tag("success"),
-	result: CollaborationPreview
-}), RequestFailure]).pipe(Schema.toTaggedUnion("status"));
-const PublishCheckpoint = Schema.Struct({
-	authoredStateVector: StateVector,
-	result: Schema.optionalKey(DocumentMutationResult)
-});
-const PublishOutcome = Schema.Union([Schema.Struct({
-	status: Schema.tag("success"),
-	authoredStateVector: StateVector,
-	result: DocumentMutationResult
-}), Schema.Struct({
-	status: Schema.tag("failure"),
-	...requestFailure,
-	checkpoint: Schema.optionalKey(PublishCheckpoint)
-})]).pipe(Schema.toTaggedUnion("status"));
-const WorkingSavedMessage = Schema.Struct({
-	type: Schema.tag("working-saved"),
-	workingStateVector: StateVector
-});
-const WorkingSaveErrorMessage = Schema.Struct({
-	type: Schema.tag("working-save-error"),
-	error: Schema.NonEmptyString
-});
-const PreviewResultMessage = Schema.Struct({
-	type: Schema.tag("preview-result"),
-	requestId: RequestId,
-	outcome: PreviewOutcome
-});
-const PublishResultMessage = Schema.Struct({
-	type: Schema.tag("publish-result"),
-	requestId: RequestId,
-	outcome: PublishOutcome
-});
-const CollaborationServerMessage = Schema.Union([
-	WorkingSavedMessage,
-	WorkingSaveErrorMessage,
-	PreviewResultMessage,
-	PublishResultMessage
-]).pipe(Schema.toTaggedUnion("type"));
-
-//#endregion
-//#region ../protocol/src/Users.ts
-/**
-* User administration inputs, offset-paginated directory results, and caller-visible command
-* failures. Commands carry no idempotency key; clients resolve ambiguous outcomes by listing again.
-*/
-const UserEmail = Schema.NonEmptyString.check(Schema.isMaxLength(320), Schema.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/u)).annotate({ identifier: "UserEmail" });
-const UserName = Schema.NonEmptyString.check(Schema.isMaxLength(200)).annotate({ identifier: "UserName" });
-const UserPassword = Schema.NonEmptyString.check(Schema.isMinLength(8), Schema.isMaxLength(200)).annotate({ identifier: "UserPassword" });
-const User = Schema.Struct({
-	id: Schema.NonEmptyString,
-	email: UserEmail,
-	name: UserName,
-	role: Role,
-	emailVerified: Schema.Boolean,
-	banned: Schema.Boolean,
-	createdAt: Schema.DateTimeUtcFromString,
-	updatedAt: Schema.DateTimeUtcFromString
-}).annotate({ identifier: "User" });
-const UserPage = Schema.Struct({
-	users: Schema.Array(User),
-	total: nonNegativeInt
-}).annotate({ identifier: "UserPage" });
-const UserQuery = Schema.Struct({
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 100
-	}))),
-	offset: Schema.optionalKey(nonNegativeInt),
-	search: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(200)))
-}).annotate({ identifier: "UserQuery" });
-const CreateUserInput = Schema.Struct({
-	email: UserEmail,
-	name: UserName,
-	password: UserPassword,
-	role: Role
-}).annotate({ identifier: "CreateUserInput" });
-var UserAlreadyExists = class extends Schema.TaggedError()("User.AlreadyExists", { email: UserEmail }) {};
-var UserNotFound = class extends Schema.TaggedError()("User.NotFound", { userId: User.fields.id }) {};
-var UserSelfRemovalDenied = class extends Schema.TaggedError()("User.SelfRemovalDenied", { userId: User.fields.id }) {};
-var UserSelfRoleChangeDenied = class extends Schema.TaggedError()("User.SelfRoleChangeDenied", { userId: User.fields.id }) {};
-var UserAdministrationDenied = class extends Schema.TaggedError()("UserAdministration.Denied", {}) {};
-
-//#endregion
-//#region ../protocol/src/Initialization.ts
-const InitializationInput = Schema.Struct({
-	email: UserEmail,
-	initializationToken: Schema.NonEmptyString.check(Schema.isMaxLength(512)),
-	name: UserName,
-	password: UserPassword
-}).annotate({ identifier: "InitializationInput" });
-const InitializationState = Schema.Struct({ needsAdministrator: Schema.Boolean }).annotate({ identifier: "InitializationState" });
-var InitializationAlreadyCompleted = class extends Schema.TaggedError()("Initialization.AlreadyCompleted", {}) {};
-var InitializationProofInvalid = class extends Schema.TaggedError()("Initialization.ProofInvalid", {}) {};
-
-//#endregion
-//#region ../protocol/src/internal/http/failures.ts
-var StudioInternalError = class extends Schema.TaggedError()("Studio.InternalError", { message: Schema.Literal("The request could not be completed.") }) {};
-function studioInternalError() {
-	return new StudioInternalError({ message: "The request could not be completed." });
-}
-
-//#endregion
-//#region ../protocol/src/internal/http/delivery.ts
-const DeliverySurroundPayload = Schema.Struct({
-	lookup: PublishedDocumentLookup,
-	query: PublishedDocumentSurroundQuery
-}).annotate({ identifier: "DeliverySurroundPayload" });
-const InternalError$1 = StudioInternalError.pipe(HttpApiSchema.status(500));
-const PublishedNotFound = PublishedDocumentNotFound.pipe(HttpApiSchema.status(404));
-const Forbidden$1 = AccessDenied.pipe(HttpApiSchema.status(403));
-const PublishedDeliveryApi = HttpApiGroup.make("delivery").add(HttpApiEndpoint.post("read", "/read", {
-	payload: PublishedDocumentLookup,
-	success: CompiledDocument,
-	error: [PublishedNotFound, InternalError$1]
-}), HttpApiEndpoint.post("query", "/query", {
-	payload: PublishedDocumentQuery,
-	success: PublishedDocumentPage,
-	error: InternalError$1
-}), HttpApiEndpoint.post("navigation", "/navigation", {
-	payload: DocumentNavigationQuery,
-	success: Schema.Array(DocumentNavigationItem),
-	error: InternalError$1
-}), HttpApiEndpoint.post("surround", "/surround", {
-	payload: DeliverySurroundPayload,
-	success: DocumentSurround,
-	error: [PublishedNotFound, InternalError$1]
-}), HttpApiEndpoint.get("seo", "/seo", {
-	success: SeoSnapshot,
-	error: InternalError$1
-}), HttpApiEndpoint.get("sitemap", "/sitemap", {
-	success: Schema.Array(SitemapEntry),
-	error: InternalError$1
-})).prefix("/delivery");
-const PreviewDeliveryApi = HttpApiGroup.make("previewDelivery").add(HttpApiEndpoint.post("read", "/read", {
-	payload: PublishedDocumentLookup,
-	success: CompiledDocument,
-	error: [
-		PublishedNotFound,
-		InternalError$1,
-		Forbidden$1
-	]
-}), HttpApiEndpoint.post("query", "/query", {
-	payload: PublishedDocumentQuery,
-	success: PublishedDocumentPage,
-	error: [InternalError$1, Forbidden$1]
-}), HttpApiEndpoint.post("navigation", "/navigation", {
-	payload: DocumentNavigationQuery,
-	success: Schema.Array(DocumentNavigationItem),
-	error: [InternalError$1, Forbidden$1]
-}), HttpApiEndpoint.post("surround", "/surround", {
-	payload: DeliverySurroundPayload,
-	success: DocumentSurround,
-	error: [
-		PublishedNotFound,
-		InternalError$1,
-		Forbidden$1
-	]
-}), HttpApiEndpoint.get("seo", "/seo", {
-	success: SeoSnapshot,
-	error: [InternalError$1, Forbidden$1]
-})).prefix("/preview");
-
-//#endregion
-//#region ../protocol/src/StudioHttp.ts
-/**
-* Studio HTTP paths, middleware contracts, payloads, and the composed CMS API. Every expected
-* caller failure is a tagged schema with an explicit status; unclassified failures become the
-* deliberately opaque `StudioInternalError`.
-*/
-const ApiVersion = Schema.NonEmptyString.pipe(Schema.brand("ApiVersion"));
-const StudioBootstrap = Schema.Struct({
-	basePath: PublicPath,
-	documents: DocumentConfiguration,
-	media: MediaConfiguration,
-	seo: Schema.optionalKey(SeoConfiguration),
-	version: ApiVersion
-}).annotate({ identifier: "StudioBootstrap" });
-var StudioBadRequest = class extends Schema.TaggedError()("Studio.BadRequest", { kind: Schema.Literals([
-	"Headers",
-	"Params",
-	"Payload",
-	"Query"
-]) }) {};
-var StudioRequestConflict = class extends Schema.TaggedError()("Studio.RequestConflict", { retryable: Schema.Literal(true) }) {};
-var StudioSchemaError = class extends HttpApiMiddleware.Service()("@internal/protocol/StudioSchemaError", { error: [StudioBadRequest.pipe(HttpApiSchema.status(400)), StudioInternalError.pipe(HttpApiSchema.status(500))] }) {};
-var CurrentStudioRequest = class extends Context.Service()("@internal/protocol/CurrentStudioRequest") {};
-var StudioAuthentication = class extends HttpApiMiddleware.Service()("@internal/protocol/StudioAuthentication", { error: [
-	AuthenticationRequired.pipe(HttpApiSchema.status(401)),
-	StudioEntryDenied.pipe(HttpApiSchema.status(403)),
-	StudioInternalError.pipe(HttpApiSchema.status(500))
-] }) {};
-const ValidateDocumentPayload = Schema.Struct({
-	expectedVersion: UpdateDocumentInput.fields.expectedVersion,
-	markdown: UpdateDocumentInput.fields.markdown
-});
-const UpdateDocumentPayload = ValidateDocumentPayload.pipe(Schema.fieldsAssign({ reason: UpdateDocumentInput.fields.reason }));
-const MoveDocumentPayload = Schema.Struct({
-	expectedVersion: MoveDocumentInput.fields.expectedVersion,
-	placement: MoveDocumentInput.fields.placement,
-	reason: MoveDocumentInput.fields.reason
-});
-const PublishDocumentPayload = Schema.Struct({
-	expectedVersion: PublishDocumentInput.fields.expectedVersion,
-	reason: PublishDocumentInput.fields.reason
-});
-const RemoveDocumentPayload = Schema.Struct({
-	expectedVersion: RemoveDocumentInput.fields.expectedVersion,
-	reason: RemoveDocumentInput.fields.reason
-});
-const RestoreDocumentPayload = Schema.Struct({
-	expectedVersion: RestoreDocumentInput.fields.expectedVersion,
-	revisionId: RestoreDocumentInput.fields.revisionId,
-	reason: RestoreDocumentInput.fields.reason
-});
-const UndeleteDocumentPayload = Schema.Struct({
-	expectedVersion: UndeleteDocumentInput.fields.expectedVersion,
-	reason: UndeleteDocumentInput.fields.reason
-});
-const ChangeRolePayload = Schema.Struct({ role: Role }).annotate({ identifier: "ChangeRolePayload" });
-const MediaUploadQuery = Schema.Struct({
-	declaredByteSize: MediaUpload.fields.declaredByteSize,
-	folder: Schema.optionalKey(MediaFolder)
-}).annotate({ identifier: "MediaUploadQuery" });
-const MediaUploadPayload = Schema.Struct({ file: Multipart.SingleFileSchema }).pipe(HttpApiSchema.asMultipartStream({ maxParts: 1 }));
-const NotFound = DocumentNotFound.pipe(HttpApiSchema.status(404));
-const VersionConflict = DocumentVersionConflict.pipe(HttpApiSchema.status(409));
-const Conflict = Schema.Union([
-	DocumentMediaUnavailable,
-	DocumentRouteConflict,
-	DocumentVersionConflict
-]).pipe(HttpApiSchema.status(409));
-const ValidationFailed = DocumentValidationFailed.pipe(HttpApiSchema.status(422));
-const RequestConflict = StudioRequestConflict.pipe(HttpApiSchema.status(409));
-const InternalError = StudioInternalError.pipe(HttpApiSchema.status(500));
-const Forbidden = AccessDenied.pipe(HttpApiSchema.status(403));
-const MutationErrors = [
-	NotFound,
-	Conflict,
-	ValidationFailed,
-	RequestConflict,
-	Forbidden,
-	InternalError
-];
-const MediaNotFoundResponse = MediaNotFound.pipe(HttpApiSchema.status(404));
-const MediaInvalidQuery = MediaInvalid.pipe(HttpApiSchema.status(400));
-const MediaInvalidUpload = MediaInvalid.pipe(HttpApiSchema.status(422));
-const MediaTooLargeResponse = MediaTooLarge.pipe(HttpApiSchema.status(413));
-const MediaReferencedResponse = MediaReferenced.pipe(HttpApiSchema.status(409));
-const MediaConflictResponse = MediaConflict.pipe(HttpApiSchema.status(409));
-const InvalidActivityCursor = ActivityCursorInvalid.pipe(HttpApiSchema.status(400));
-const InvalidHistoryCursor = DocumentHistoryInvalidCursor.pipe(HttpApiSchema.status(400));
-const HistoryComparisonTooLarge = DocumentHistoryComparisonTooLarge.pipe(HttpApiSchema.status(422));
-const ContentConflict = ContentTransferConflict.pipe(HttpApiSchema.status(409));
-const AlreadyInitialized = InitializationAlreadyCompleted.pipe(HttpApiSchema.status(409));
-const InitializationProofRejected = InitializationProofInvalid.pipe(HttpApiSchema.status(403));
-const UserAdministrationForbidden = UserAdministrationDenied.pipe(HttpApiSchema.status(403));
-const UserDuplicate = UserAlreadyExists.pipe(HttpApiSchema.status(409));
-const MissingUser = UserNotFound.pipe(HttpApiSchema.status(404));
-const UserSelfRemoval = UserSelfRemovalDenied.pipe(HttpApiSchema.status(409));
-const UserSelfRoleChange = UserSelfRoleChangeDenied.pipe(HttpApiSchema.status(409));
-const SeoConflict = SeoVersionConflict.pipe(HttpApiSchema.status(409));
-const SeoConfirmation = SeoConfirmationRequired.pipe(HttpApiSchema.status(409));
-const SeoMediaInvalid = SeoMediaUnavailable.pipe(HttpApiSchema.status(422));
-const StudioDocumentsApi = HttpApiGroup.make("documents").add(HttpApiEndpoint.get("browse", "/", {
-	query: DocumentBrowseQuery,
-	success: Schema.Array(DocumentSummary),
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("trash", "/trash", {
-	success: Schema.Array(DeletedDocument),
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("read", "/:documentId", {
-	params: { documentId: DocumentId },
-	success: DocumentSource,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("create", "/", {
-	payload: CreateDocumentInput,
-	success: DocumentMutationResult.pipe(HttpApiSchema.status(201)),
-	error: MutationErrors
-}), HttpApiEndpoint.put("update", "/:documentId", {
-	params: { documentId: DocumentId },
-	payload: UpdateDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("validate", "/:documentId/validate", {
-	params: { documentId: DocumentId },
-	payload: ValidateDocumentPayload,
-	success: DocumentValidationResult,
-	error: [
-		NotFound,
-		VersionConflict,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("move", "/:documentId/move", {
-	params: { documentId: DocumentId },
-	payload: MoveDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("duplicate", "/:documentId/duplicate", {
-	params: { documentId: DocumentId },
-	payload: Schema.Struct({
-		...MoveDocumentPayload.fields,
-		includeChildren: DuplicateDocumentInput.fields.includeChildren,
-		locale: DuplicateDocumentInput.fields.locale
-	}),
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("unpublish", "/:documentId/unpublish", {
-	params: { documentId: DocumentId },
-	payload: PublishDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("publish", "/:documentId/publish", {
-	params: { documentId: DocumentId },
-	payload: PublishDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("remove", "/:documentId/remove", {
-	params: { documentId: DocumentId },
-	payload: RemoveDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("restore", "/:documentId/restore", {
-	params: { documentId: DocumentId },
-	payload: RestoreDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("undelete", "/:documentId/undelete", {
-	params: { documentId: DocumentId },
-	payload: UndeleteDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-})).middleware(StudioAuthentication).prefix("/documents");
-const StudioContentApi = HttpApiGroup.make("content").add(HttpApiEndpoint.get("snapshot", "/snapshot", {
-	success: ContentSnapshot,
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.post("plan", "/plan", {
-	payload: ContentTransferInput,
-	success: ContentPlan,
-	error: [
-		ContentConflict,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("apply", "/apply", {
-	payload: ContentApplyInput,
-	success: ContentApplyResult,
-	error: [
-		ContentConflict,
-		ValidationFailed,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/content");
-const StudioMediaApi = HttpApiGroup.make("media").add(HttpApiEndpoint.get("search", "/", {
-	query: MediaQuery,
-	success: MediaPage,
-	error: [
-		MediaInvalidQuery,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("upload", "/", {
-	query: MediaUploadQuery,
-	payload: MediaUploadPayload,
-	success: MediaAsset.pipe(HttpApiSchema.status(201)),
-	error: [
-		MediaInvalidUpload,
-		MediaTooLargeResponse,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.put("replace", "/:mediaId", {
-	params: { mediaId: MediaId },
-	query: MediaUploadQuery,
-	payload: MediaUploadPayload,
-	success: MediaAsset,
-	error: [
-		MediaNotFoundResponse,
-		MediaConflictResponse,
-		MediaInvalidUpload,
-		MediaTooLargeResponse,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("cleanup", "/cleanup", {
-	success: MediaCleanupReport,
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("integrity", "/integrity", {
-	success: MediaIntegrityReport,
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("get", "/:mediaId", {
-	params: { mediaId: MediaId },
-	success: MediaAsset,
-	error: [
-		MediaNotFoundResponse,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.delete("remove", "/:mediaId", {
-	params: { mediaId: MediaId },
-	success: HttpApiSchema.NoContent,
-	error: [
-		MediaNotFoundResponse,
-		MediaConflictResponse,
-		MediaReferencedResponse,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/media");
-const StudioConfigurationApi = HttpApiGroup.make("configuration").add(HttpApiEndpoint.get("bootstrap", "/bootstrap", { success: StudioBootstrap })).middleware(StudioAuthentication);
-const StudioSessionApi = HttpApiGroup.make("session").add(HttpApiEndpoint.get("current", "/session", { success: StudioActor })).middleware(StudioAuthentication);
-const InitializationApi = HttpApiGroup.make("initialization").add(HttpApiEndpoint.get("status", "/initialization", {
-	success: InitializationState,
-	error: InternalError
-}), HttpApiEndpoint.post("claim", "/initialization", {
-	payload: InitializationInput,
-	success: User.pipe(HttpApiSchema.status(201)),
-	error: [
-		AlreadyInitialized,
-		InitializationProofRejected,
-		InternalError
-	]
-}));
-const StudioDiagnosticsApi = HttpApiGroup.make("diagnostics").add(HttpApiEndpoint.get("documents", "/diagnostics/documents", {
-	success: Schema.Array(DocumentIssue),
-	error: [Forbidden, InternalError]
-})).middleware(StudioAuthentication);
-const StudioHistoryApi = HttpApiGroup.make("history").add(HttpApiEndpoint.get("list", "/", {
-	query: DocumentHistoryQuery,
-	success: DocumentRevisionPage,
-	error: [
-		InvalidHistoryCursor,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.get("read", "/:documentId/:revisionId", {
-	params: {
-		documentId: DocumentId,
-		revisionId: DocumentRevision.fields.revisionId
-	},
-	success: DocumentRevision,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("compare", "/compare", {
-	payload: CompareDocumentRevisionsInput,
-	success: DocumentRevisionComparison,
-	error: [
-		NotFound,
-		HistoryComparisonTooLarge,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/history");
-const StudioActivityApi = HttpApiGroup.make("activity").add(HttpApiEndpoint.get("list", "/", {
-	query: ActivityQuery,
-	success: ActivityPage,
-	error: [
-		InvalidActivityCursor,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/activity");
-const StudioSeoApi = HttpApiGroup.make("seo").add(HttpApiEndpoint.get("read", "/", {
-	success: SeoState,
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.put("save", "/", {
-	payload: SaveSeoInput,
-	success: SeoMutationResult,
-	error: [
-		SeoConflict,
-		SeoConfirmation,
-		SeoMediaInvalid,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("publish", "/publish", {
-	payload: PublishSeoInput,
-	success: SeoMutationResult,
-	error: [
-		SeoConflict,
-		SeoConfirmation,
-		SeoMediaInvalid,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/seo");
-const StudioUserAdministrationApi = HttpApiGroup.make("users").add(HttpApiEndpoint.get("list", "/", {
-	query: UserQuery,
-	success: UserPage,
-	error: [UserAdministrationForbidden, InternalError]
-}), HttpApiEndpoint.post("create", "/", {
-	payload: CreateUserInput,
-	success: User.pipe(HttpApiSchema.status(201)),
-	error: [
-		UserDuplicate,
-		UserAdministrationForbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("changeRole", "/:userId/role", {
-	params: { userId: User.fields.id },
-	payload: ChangeRolePayload,
-	success: User,
-	error: [
-		MissingUser,
-		UserSelfRoleChange,
-		UserAdministrationForbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("revokeSessions", "/:userId/sessions/revoke", {
-	params: { userId: User.fields.id },
-	success: User,
-	error: [
-		MissingUser,
-		UserAdministrationForbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.delete("remove", "/:userId", {
-	params: { userId: User.fields.id },
-	success: User,
-	error: [
-		MissingUser,
-		UserSelfRemoval,
-		UserAdministrationForbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/users");
-const StudioCollaborationApi = HttpApiGroup.make("collaboration").add(HttpApiEndpoint.post("ticket", "/:documentId/ticket", {
-	params: { documentId: DocumentId },
-	success: CollaborationTicket,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("discard", "/:documentId/discard", {
-	params: { documentId: DocumentId },
-	success: CollaborationTicket,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/collaboration");
-const FormsApi = HttpApiGroup.make("forms").add(HttpApiEndpoint.post("submit", "/submit", {
-	payload: FormSubmission,
-	success: FormResult
-})).prefix("/forms");
-var StudioApi = class extends HttpApi.make("StudioApi").add(FormsApi, InitializationApi, PublishedDeliveryApi, StudioConfigurationApi, StudioSessionApi, StudioDiagnosticsApi, PreviewDeliveryApi.middleware(StudioAuthentication), StudioDocumentsApi, StudioContentApi, StudioHistoryApi, StudioActivityApi, StudioSeoApi, StudioUserAdministrationApi, StudioMediaApi, StudioCollaborationApi).middleware(StudioSchemaError).prefix(STUDIO_API_PATH) {};
-
-//#endregion
-//#region ../document/src/Seo.ts
-function resolveDocumentSeo({ document, global, capabilities }) {
-	const authored = document.seo;
-	const baseTitle = authored?.title ?? document.title;
-	const title = global.titleTemplate?.replaceAll("%s", baseTitle) ?? baseTitle;
-	const description = authored?.description ?? document.description ?? global.defaultDescription;
-	const socialTitle = authored?.socialTitle ?? global.socialTitle ?? title;
-	const socialDescription = authored?.socialDescription ?? global.socialDescription ?? description;
-	const socialImage = authored?.socialImage ?? global.socialImage;
-	const canonicalUrl = authored?.canonicalUrl ?? SeoUrl.make(new URL(document.path, `${global.canonicalOrigin}/`).href);
-	const structuredData = resolveStructuredData(authored?.structuredData, capabilities);
-	const identity = resolveIdentity(global.identity, capabilities);
-	return {
-		title,
-		...description === void 0 ? void 0 : { description },
-		socialTitle,
-		...socialDescription === void 0 ? void 0 : { socialDescription },
-		...socialImage === void 0 ? void 0 : { socialImage },
-		canonicalUrl,
-		index: global.index && (authored?.index ?? true),
-		follow: global.follow && (authored?.follow ?? true),
-		...structuredData === void 0 ? void 0 : { structuredData },
-		...identity === void 0 ? void 0 : { identity }
-	};
-}
-function resolveStructuredData(authored, capabilities) {
-	if (authored && capabilities.structuredDataTypes.includes(authored.type)) return authored;
-	return capabilities.structuredDataTypes.includes("WebPage") ? { type: "WebPage" } : void 0;
-}
-function resolveIdentity(identity, capabilities) {
-	return identity && capabilities.identityTypes.includes(identity.type) ? identity : void 0;
-}
-
-//#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.filter((action) => action !== "document.transfer"), ...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 ../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/DocumentPlanning.ts
-function planDocumentCreation(configuration, input) {
-	return Result.gen(function* () {
-		const collection = configuration.types.find((candidate) => candidate.collection === input.collection);
-		if (!collection) return yield* invalid(`Document collection "${input.collection}" does not exist.`, "collection");
-		const title = input.title.trim();
-		if (!title) return yield* invalid("A document title is required.", "title");
-		const locale = yield* resolveLocale(configuration, input.locale);
-		return Object.assign({
-			collection,
-			placement: input.placement,
-			title
-		}, locale === void 0 ? void 0 : { locale });
-	});
-}
-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)
-	};
-});
-function initialFrontmatter(plan) {
-	return Object.assign(structuredDefaults(plan.collection.authoringFields), { title: plan.title });
-}
-function structuredDefaults(fields) {
-	return Object.fromEntries(fields.flatMap((field) => {
-		if (field.defaultValue !== void 0) return [[field.name, structuredClone(field.defaultValue)]];
-		if (field.type !== "object") return [];
-		const nested = structuredDefaults(field.fields ?? []);
-		return Object.keys(nested).length === 0 ? [] : [[field.name, nested]];
-	}));
-}
-function resolveLocale(configuration, requested) {
-	const locales = configuration.locales;
-	if (!locales) return requested === void 0 ? Result.succeed(void 0) : invalid(`Document locale "${requested}" is not configured.`, "locale");
-	const locale = requested ?? locales.defaultLocale;
-	return locales.locales.includes(locale) ? Result.succeed(locale) : invalid(`Document locale "${locale}" does not exist.`, "locale");
-}
-function invalid(message, field) {
-	return Result.fail(new DocumentValidationFailed({ issues: [field === void 0 ? {
-		code: "document.invalid",
-		message,
-		severity: "error"
-	} : {
-		code: "document.invalid",
-		field,
-		message,
-		severity: "error"
-	}] }));
-}
-
-//#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.`);
-	const publishedById = /* @__PURE__ */ new Map();
-	for (const document of published.documents) {
-		if (publishedById.has(document.id)) throw new Error(`Compiled document "${document.id}" appears more than once in the published catalog.`);
-		publishedById.set(document.id, document);
-	}
-	return {
-		activeById,
-		authored,
-		authoredById,
-		published,
-		publishedById,
-		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) => ({
-		draft: source.publishedVersion !== source.version,
-		identity: source.identity,
-		markdown: source.markdown,
-		placement: source.placement
-	}));
-}
-function publishedSources(snapshot) {
-	return snapshot.published.map((source) => ({
-		draft: false,
-		identity: source.identity,
-		markdown: source.markdown,
-		placement: source.placement,
-		publishedAt: source.editedAt
-	}));
-}
-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, documentId, 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.id === documentId);
-	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: summaryDocument(document),
-			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,
-		identity: source.identity,
-		placement: source.placement,
-		deletedAt: source.deletedAt,
-		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: summaryDocument(document),
-		version: source.version
-	}) : void 0;
-}
-function summaryDocument(document) {
-	return {
-		collection: document.collection,
-		draft: document.draft,
-		id: document.id,
-		identity: document.identity,
-		issues: document.issues,
-		key: document.key,
-		...document.locale ? { locale: document.locale } : void 0,
-		path: document.path,
-		placement: document.placement,
-		searchText: document.analysis.searchText,
-		title: document.title
-	};
-}
-function compilationIssues(error) {
-	if (isDocumentCompilationFailed(error)) return error.issues;
-	return [{
-		code: "markdown.parse",
-		message: errorMessage(error.cause),
-		severity: "error",
-		documentId: error.documentId
-	}];
-}
-function errorMessage(cause) {
-	return cause instanceof Error && cause.message ? cause.message : "Markdown could not be parsed.";
-}
-function browseMetadata(state, source) {
-	const live = state.publishedById.get(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
-function subtreeIds(state, documentId, catalog = "authored") {
-	const documents = catalog === "authored" ? state.authored.documents : state.published.documents;
-	const children = /* @__PURE__ */ new Map();
-	for (const document of documents) {
-		if (document.placement.kind === "home") continue;
-		const existing = children.get(document.placement.parentDocumentId) ?? [];
-		existing.push(document.id);
-		children.set(document.placement.parentDocumentId, existing);
-	}
-	const result = [];
-	const pending = [documentId];
-	while (pending.length > 0) {
-		const current = pending.shift();
-		if (!current || result.includes(current)) continue;
-		result.push(current);
-		pending.push(...children.get(current) ?? []);
-	}
-	return result;
-}
-const prepareTreeMutation = Effect.fn("Documents.prepareTreeMutation")(function* (dependencies, state, command) {
-	const { 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
-	});
-	const sources = affectedSources(state, root, command);
-	const authored = authoredSources(state.snapshot);
-	const published = publishedSources(state.snapshot);
-	const plans = [];
-	let nextAuthored = [...authored];
-	let nextPublished = [...published];
-	switch (command.action) {
-		case "document.move": {
-			const next = compilationSource$2(root, command.input.placement);
-			nextAuthored = replaceSource$1(nextAuthored, next);
-			plans.push({
-				action: command.action,
-				documentId: root.documentId,
-				expectedVersion: root.version,
-				markdown: root.markdown,
-				placement: command.input.placement,
-				publishedVersion: root.publishedVersion
-			});
-			break;
-		}
-		case "document.duplicate": {
-			const ids = /* @__PURE__ */ new Map();
-			for (const source of sources) ids.set(source.documentId, yield* command.nextDocumentId);
-			for (const source of sources) {
-				const documentId = ids.get(source.documentId);
-				if (!documentId) return yield* Effect.die(/* @__PURE__ */ new Error("Duplicate document identity was not allocated."));
-				const placement = duplicatePlacement(source, root, command.input.placement, ids);
-				const identity = {
-					...source.identity,
-					documentId,
-					...command.input.locale === void 0 ? void 0 : { locale: command.input.locale }
-				};
-				const next = {
-					draft: true,
-					identity,
-					markdown: source.markdown,
-					placement
-				};
-				nextAuthored.push(next);
-				plans.push({
-					action: "document.create",
-					identity,
-					markdown: source.markdown,
-					placement
-				});
-			}
-			break;
-		}
-		case "document.remove": {
-			const ids = new Set(sources.map((source) => source.documentId));
-			nextAuthored = nextAuthored.filter((source) => !ids.has(source.identity.documentId));
-			nextPublished = nextPublished.filter((source) => !ids.has(source.identity.documentId));
-			for (const source of sources) {
-				const page = state.authoredById.get(source.documentId);
-				plans.push({
-					action: command.action,
-					trashBatchId: root.version,
-					title: page?.title,
-					path: page?.path,
-					documentId: source.documentId,
-					expectedVersion: source.version,
-					markdown: source.markdown,
-					placement: source.placement
-				});
-			}
-			break;
-		}
-		case "document.undelete": for (const source of sources) {
-			const next = compilationSource$2(source, source.placement);
-			nextAuthored.push(next);
-			plans.push({
-				action: command.action,
-				documentId: source.documentId,
-				expectedVersion: source.version,
-				markdown: source.markdown,
-				placement: source.placement
-			});
-		}
-	}
-	const first = plans[0];
-	if (!first) return yield* Effect.die(/* @__PURE__ */ new Error("Empty subtree mutation."));
-	return {
-		authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
-		published: yield* compileValidCatalog(engine, nextPublished, state.published),
-		commitPlan: first,
-		additionalPlans: plans.slice(1)
-	};
-});
-function affectedSources(state, root, command) {
-	if (command.action === "document.undelete") {
-		if (!("deletedAt" in root)) return [];
-		return state.snapshot.deleted.filter((source) => source.documentId === root.documentId || root.trashBatchId !== void 0 && source.trashBatchId === root.trashBatchId);
-	}
-	const ids = new Set(command.action === "document.duplicate" && !command.input.includeChildren ? [root.documentId] : subtreeIds(state, root.documentId));
-	return [root, ...state.snapshot.active.filter((source) => source.documentId !== root.documentId && ids.has(source.documentId))];
-}
-function compilationSource$2(source, placement) {
-	return {
-		draft: true,
-		identity: source.identity,
-		markdown: source.markdown,
-		placement
-	};
-}
-function duplicatePlacement(source, root, rootPlacement, ids) {
-	if (source.documentId === root.documentId) return rootPlacement;
-	if (source.placement.kind === "home") return source.placement;
-	const parentDocumentId = ids.get(source.placement.parentDocumentId);
-	return parentDocumentId === void 0 ? source.placement : {
-		...source.placement,
-		parentDocumentId
-	};
-}
-function replaceSource$1(sources, source) {
-	return [...sources.filter((candidate) => candidate.identity.documentId !== source.identity.documentId), source];
-}
-
-//#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": {
-			const source = compilationSource$1(command.identity, command.placement, command.markdown, true);
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, [...authored, source], state.authored),
-				published: state.published,
-				commitPlan: {
-					action: command.action,
-					identity: command.identity,
-					markdown: command.markdown,
-					placement: command.placement
-				}
-			});
-		}
-		case "document.update": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			const source = compilationSource$1(current.identity, current.placement, command.input.markdown, true);
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, replaceSource(authored, source), state.authored),
-				published: state.published,
-				commitPlan: {
-					action: command.action,
-					documentId: current.documentId,
-					expectedVersion: command.input.expectedVersion,
-					markdown: command.input.markdown,
-					placement: current.placement,
-					publishedVersion: current.publishedVersion
-				}
-			});
-		}
-		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 source = compilationSource$1(current.identity, historical.placement, historical.markdown, true);
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, replaceSource(authored, source), state.authored),
-				published: state.published,
-				commitPlan: {
-					action: command.action,
-					documentId: current.documentId,
-					expectedVersion: command.input.expectedVersion,
-					markdown: historical.markdown,
-					placement: historical.placement,
-					publishedVersion: current.publishedVersion,
-					revisionId: command.input.revisionId
-				}
-			});
-		}
-		case "document.unpublish": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			const ids = new Set(subtreeIds(state, current.documentId, "published"));
-			const plans = state.snapshot.active.filter((source) => ids.has(source.documentId) && source.publishedVersion !== void 0).map((source) => ({
-				action: "document.unpublish",
-				documentId: source.documentId,
-				expectedVersion: source.version,
-				markdown: source.markdown,
-				placement: source.placement,
-				revisionId: source.revisionId
-			}));
-			const first = plans[0];
-			if (!first) return unchanged(state, current, "document.unpublish");
-			return PreparedDocumentMutation.Commit({
-				authored: yield* compileValidCatalog(engine, authored.map((source) => ids.has(source.identity.documentId) ? Object.assign({}, source, { draft: true }) : source), state.authored),
-				published: yield* compileValidCatalog(engine, published.filter((source) => !ids.has(source.identity.documentId)), state.published),
-				commitPlan: first,
-				additionalPlans: plans.slice(1)
-			});
-		}
-		case "document.publish": {
-			const current = yield* requireActive(state, command.input.documentId);
-			yield* requireVersion(current, command.input.expectedVersion);
-			if (current.publishedVersion === current.version) return unchanged(state, current, "document.publish");
-			const source = compilationSource$1(current.identity, current.placement, current.markdown, false);
-			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,
-					placement: current.placement,
-					revisionId: current.revisionId
-				}
-			});
-		}
-	}
-});
-const validateDocumentUpdate = Effect.fn("DocumentLifecycle.validateUpdate")(function* (engine, state, input) {
-	const current = yield* requireActive(state, input.documentId);
-	yield* requireVersion(current, input.expectedVersion);
-	const source = compilationSource$1(current.identity, current.placement, input.markdown, true);
-	return yield* validateDocumentSources(engine, replaceSource(authoredSources(state.snapshot), source), current.documentId, state.authored);
-});
-function compilationSource$1(identity, placement, markdown, draft) {
-	return {
-		draft,
-		identity,
-		markdown,
-		placement
-	};
-}
-function unchanged(state, current, action) {
-	const entry = entryById(state, current.documentId);
-	const result = DocumentMutationResult.make({
-		action,
-		affectedDocumentIds: [current.documentId],
-		documentId: current.documentId,
-		generation: state.snapshot.generation,
-		revisionId: current.revisionId,
-		version: current.version,
-		...entry === void 0 ? void 0 : { entry }
-	});
-	return PreparedDocumentMutation.Unchanged({ result });
-}
-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
-	}));
-}
-function replaceSource(sources, source) {
-	return [...sources.filter((candidate) => candidate.identity.documentId !== source.identity.documentId), source];
-}
-
-//#endregion
-//#region ../server/src/internal/documents/document-media-references.ts
-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,
-		...reference.target.mediaId ? { mediaId: reference.target.mediaId } : void 0,
-		nodePath: reference.nodePath,
-		objectKey: MediaObjectKey.make(reference.target.key),
-		route: reference.source.route
-	});
-}
-function referenceIdentity(reference) {
-	return `${reference.documentId}:${reference.nodePath.join(".")}:${reference.objectKey}`;
-}
-
-//#endregion
-//#region ../server/src/internal/documents/content-transfer.ts
-/** Import/export adapter planning. File paths are consumed here and never enter document state. */
-const planContentTransfer = Effect.fn("ContentTransfer.plan")(function* (engine, configuration, state, input, crypto) {
-	const incoming = yield* resolveSources(configuration, state, input.sources, crypto);
-	const currentById = new Map(state.snapshot.active.map((source) => [source.documentId, source]));
-	const seen = /* @__PURE__ */ new Set();
-	const commitPlans = [];
-	const entries = [];
-	const authored = new Map(authoredSources(state.snapshot).map((source) => [source.identity.documentId, source]));
-	const published = new Map(publishedSources(state.snapshot).map((source) => [source.identity.documentId, source]));
-	const now = yield* DateTime.now;
-	let created = 0;
-	let updated = 0;
-	let publishedCount = 0;
-	let unchanged = 0;
-	for (const source of incoming) {
-		if (seen.has(source.filePath)) return yield* new ContentTransferConflict({ message: `Duplicate content file path: ${source.filePath}` });
-		seen.add(source.filePath);
-		const current = currentById.get(source.identity.documentId);
-		const shouldPublish = input.publish && source.published;
-		const shouldUnpublish = input.publish && !source.published && current?.publishedVersion !== void 0;
-		const identityConflict = current !== void 0 && !sameIdentity(current.identity, source.identity);
-		const changed = current !== void 0 && (current.markdown !== source.markdown || !samePlacement(current.placement, source.placement) || source.revisionId !== void 0 && current.revisionId !== source.revisionId);
-		const action = identityConflict ? "conflict" : !current ? "create" : changed ? input.overwrite ? "update" : "conflict" : shouldPublish && current.publishedVersion !== current.version ? "publish" : shouldUnpublish ? "unpublish" : "unchanged";
-		entries.push({
-			filePath: source.filePath,
-			action,
-			currentRevisionId: current?.revisionId ?? null
-		});
-		if (action === "create" || action === "update") {
-			if (current) {
-				commitPlans.push({
-					action: "document.update",
-					documentId: current.documentId,
-					expectedVersion: current.version,
-					markdown: source.markdown,
-					placement: source.placement,
-					publish: shouldPublish,
-					publishedVersion: current.publishedVersion,
-					...source.revisionId === void 0 ? void 0 : { newRevisionId: source.revisionId },
-					...shouldUnpublish ? { unpublish: true } : void 0
-				});
-				updated++;
-			} else {
-				commitPlans.push({
-					action: "document.create",
-					identity: source.identity,
-					markdown: source.markdown,
-					placement: source.placement,
-					publish: shouldPublish,
-					...source.revisionId === void 0 ? void 0 : { newRevisionId: source.revisionId }
-				});
-				created++;
-			}
-			if (shouldPublish) publishedCount++;
-			const compiled = compilationSource(source, !shouldPublish);
-			authored.set(source.identity.documentId, compiled);
-			if (shouldPublish) published.set(source.identity.documentId, Object.assign({}, compiled, {
-				draft: false,
-				publishedAt: now
-			}));
-			else if (shouldUnpublish) published.delete(source.identity.documentId);
-		} else if (action === "publish" && current) {
-			commitPlans.push({
-				action: "document.publish",
-				documentId: current.documentId,
-				expectedVersion: current.version,
-				markdown: current.markdown,
-				placement: current.placement,
-				revisionId: current.revisionId
-			});
-			publishedCount++;
-			const compiled = compilationSource(source, false);
-			authored.set(source.identity.documentId, compiled);
-			published.set(source.identity.documentId, Object.assign({}, compiled, { publishedAt: now }));
-		} else if (action === "unpublish" && current) {
-			commitPlans.push({
-				action: "document.unpublish",
-				documentId: current.documentId,
-				expectedVersion: current.version,
-				markdown: current.markdown,
-				placement: current.placement,
-				revisionId: current.revisionId
-			});
-			published.delete(source.identity.documentId);
-		} else if (action === "unchanged") unchanged++;
-	}
-	const firstDocumentId = incoming[0]?.identity.documentId;
-	const publishedValues = [...published.values()];
-	const publishedDocumentId = publishedValues[0]?.identity.documentId;
-	const authoredValidation = firstDocumentId ? yield* validateDocumentSources(engine, [...authored.values()], firstDocumentId, state.authored) : DocumentValidationResult.make({
-		issues: [],
-		valid: true
-	});
-	const publishedValidation = input.publish && publishedDocumentId ? yield* validateDocumentSources(engine, publishedValues, publishedDocumentId, state.published) : DocumentValidationResult.make({
-		issues: [],
-		valid: true
-	});
-	const issues = [...authoredValidation.issues, ...publishedValidation.issues];
-	return {
-		plan: ContentPlan.make({
-			generation: state.snapshot.generation,
-			entries,
-			issues,
-			valid: authoredValidation.valid && !entries.some((entry) => entry.action === "conflict") && !issues.some((issue) => issue.severity === "error")
-		}),
-		authoredSources: [...authored.values()],
-		publishedSources: publishedValues,
-		commitPlans,
-		counts: {
-			created,
-			updated,
-			published: publishedCount,
-			unchanged
-		}
-	};
-});
-function resolveSources(configuration, state, sources, crypto) {
-	return Effect.gen(function* () {
-		const resolved = [];
-		const indexed = [];
-		const unindexed = [];
-		for (const source of sources) {
-			if (source.identity && source.placement) {
-				indexed.push(Object.assign({}, source, {
-					identity: source.identity,
-					placement: source.placement
-				}));
-				continue;
-			}
-			if (source.identity || source.placement) return yield* new ContentTransferConflict({ message: `${source.filePath}: indexed content must include both identity and placement.` });
-			unindexed.push(source);
-		}
-		resolved.push(...indexed);
-		const byPlacement = placementIndex([...state.snapshot.active, ...indexed]);
-		const pending = unindexed.map((source) => ({
-			inferred: inferFilePlacement(configuration, source.filePath),
-			source
-		})).toSorted((left, right) => Number(right.inferred.home) - Number(left.inferred.home) || left.inferred.segments.length - right.inferred.segments.length || left.source.filePath.localeCompare(right.source.filePath));
-		for (const { inferred, source } of pending) {
-			const scope = `${inferred.collection}:${inferred.locale ?? ""}`;
-			const key = `${scope}:${inferred.segments.join("/")}`;
-			let identity = byPlacement.get(key);
-			if (!identity) identity = {
-				collection: inferred.collection,
-				documentId: DocumentId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
-				...inferred.locale === void 0 ? void 0 : { locale: inferred.locale }
-			};
-			const placement = inferred.home ? { kind: "home" } : {
-				kind: "entry",
-				parentDocumentId: byPlacement.get(`${scope}:${inferred.segments.slice(0, -1).join("/")}`)?.documentId ?? (yield* new ContentTransferConflict({ message: `${source.filePath}: parent document is missing from the import and target catalog.` })),
-				slug: Slug.make(inferred.segments.at(-1) ?? "")
-			};
-			const value = Object.assign({}, source, {
-				identity,
-				placement
-			});
-			resolved.push(value);
-			byPlacement.set(key, identity);
-		}
-		return resolved;
-	});
-}
-function inferFilePlacement(configuration, filePath) {
-	const segments = filePath.replace(/\.(?:md|mdc)$/iu, "").split("/");
-	let locale = configuration.locales?.locales.find((candidate) => candidate === segments[0]);
-	if (locale) segments.shift();
-	else locale = configuration.locales?.defaultLocale;
-	let collection = configuration.types[0]?.collection;
-	const configured = configuration.types.find((candidate) => candidate.collection === segments[0]);
-	if (configured) {
-		collection = configured.collection;
-		segments.shift();
-	}
-	if (!collection) throw new Error("Content import needs at least one configured collection.");
-	const home = segments.length === 1 && segments[0]?.toLocaleLowerCase() === "index";
-	const normalized = home ? [] : segments.at(-1)?.toLocaleLowerCase() === "index" ? segments.slice(0, -1) : segments;
-	return {
-		collection,
-		home,
-		locale,
-		segments: normalized
-	};
-}
-function placementIndex(sources) {
-	const index = /* @__PURE__ */ new Map();
-	const byId = new Map(sources.map((source) => [source.identity.documentId, source]));
-	const resolved = /* @__PURE__ */ new Map();
-	const segmentsFor = (documentId, ancestors) => {
-		const cached = resolved.get(documentId);
-		if (cached) return cached;
-		if (ancestors.has(documentId)) return void 0;
-		const source = byId.get(documentId);
-		if (!source) return void 0;
-		if (source.placement.kind === "home") {
-			resolved.set(documentId, []);
-			return [];
-		}
-		const parent = segmentsFor(source.placement.parentDocumentId, /* @__PURE__ */ new Set([...ancestors, documentId]));
-		if (!parent) return void 0;
-		const segments = [...parent, source.placement.slug];
-		resolved.set(documentId, segments);
-		return segments;
-	};
-	for (const source of sources) {
-		const segments = segmentsFor(source.identity.documentId, /* @__PURE__ */ new Set());
-		if (segments) index.set(placementIndexKey(source.identity, segments), source.identity);
-	}
-	return index;
-}
-function placementIndexKey(identity, segments) {
-	return `${identity.collection}:${identity.locale ?? ""}:${segments.join("/")}`;
-}
-function compilationSource(source, draft) {
-	return {
-		draft,
-		identity: source.identity,
-		markdown: source.markdown,
-		placement: source.placement
-	};
-}
-function samePlacement(left, right) {
-	return left.kind === right.kind && (left.kind === "home" || right.kind === "entry" && left.parentDocumentId === right.parentDocumentId && left.slug === right.slug);
-}
-function sameIdentity(left, right) {
-	return left.documentId === right.documentId && left.collection === right.collection && left.locale === right.locale;
-}
-
-//#endregion
-//#region ../server/src/internal/documents/document-mutation.ts
-/** Commit validated sources and their media references through one generation fence. */
-const commitApprovedDocumentPlans = Effect.fn("Documents.commitApprovedPlans")(function* (input) {
-	const [plan, ...additionalPlans] = input.plans;
-	return yield* input.repository.commit({
-		activity: input.activity,
-		plan,
-		additionalPlans,
-		expectedGeneration: input.current.snapshot.generation,
-		...input.configurationRevision === void 0 ? void 0 : { expectedConfigurationRevision: input.configurationRevision },
-		mediaReferences: input.plans.flatMap((candidate) => projectMediaReferences(input.authored, input.published, planDocumentId(candidate)))
-	});
-});
-/** Authorize every affected document before the adapter commits the approved plan atomically. */
-const commitDocumentMutation = Effect.fn("Documents.commitMutation")(function* (accessControl, dependencies, current, command, activity) {
-	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: command.input.locale ?? source.locale
-				}
-			});
-		}
-	}
-	const prepared = yield* prepareDocumentMutation(dependencies, current, command);
-	if (command.action === "document.undelete" && Predicate.isTagged("Commit")(prepared)) for (const plan of [prepared.commitPlan, ...prepared.additionalPlans ?? []]) yield* accessControl.require({
-		actor: activity.actor,
-		requestId: activity.requestId
-	}, {
-		action: "document.undelete",
-		resource: {
-			kind: "document",
-			documentId: planDocumentId(plan)
-		}
-	});
-	if (Predicate.isTagged("Unchanged")(prepared)) return {
-		kind: "unchanged",
-		result: prepared.result
-	};
-	const committed = yield* commitApprovedDocumentPlans({
-		repository: dependencies.repository,
-		current,
-		plans: [prepared.commitPlan, ...prepared.additionalPlans ?? []],
-		authored: prepared.authored,
-		published: prepared.published,
-		activity,
-		...dependencies.configurationRevision === void 0 ? void 0 : { configurationRevision: dependencies.configurationRevision }
-	});
-	const next = makeDocumentState(prepared.authored, prepared.published, committed.snapshot);
-	const entry = entryById(next, committed.mutation.documentId);
-	return {
-		kind: "committed",
-		next,
-		result: DocumentMutationResult.make(Object.assign({}, committed.mutation, entry === void 0 ? void 0 : { entry }))
-	};
-});
-function planDocumentId(plan) {
-	return plan.action === "document.create" ? plan.identity.documentId : plan.documentId;
-}
-
-//#endregion
-//#region ../server/src/internal/documents/document-store.ts
-var DocumentStore = class extends Context.Service()("@internal/server/DocumentStore") {};
-
-//#endregion
-//#region ../server/src/internal/documents/document-failures.ts
-var DocumentPersistenceError = class extends Schema.TaggedError()("Documents.PersistenceError", {
-	operation: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-var DocumentGenerationConflict = class extends Schema.TaggedError()("Documents.GenerationConflict", {
-	expectedGeneration: DocumentGeneration,
-	actualGeneration: DocumentGeneration
-}) {};
-var DocumentConfigurationConflict = class extends Schema.TaggedError()("Documents.ConfigurationConflict", {
-	expectedRevision: Schema.NonEmptyString,
-	actualRevision: Schema.NullOr(Schema.NonEmptyString)
-}) {};
-
-//#endregion
-//#region ../server/src/internal/cursor.ts
-function cursorCodec(schema, makeCursor, invalid) {
-	const decodeJson = Schema.decodeUnknownResult(schema);
-	const encodeJson = flow(Schema.encodeResult(schema), Result.getOrThrow);
-	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/documents/document-history.ts
-const CursorPayload = Schema.Struct({
-	createdAt: Schema.DateTimeUtcFromString,
-	revisionId: RevisionId
-});
-const CursorJson = Schema.fromJsonString(CursorPayload);
-const cursors = cursorCodec(CursorJson, (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.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.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;
-});
-
-//#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 itemsById = new Map(candidates.map((document) => [document.id, navigationItem(document)]));
-	const orderByItem = /* @__PURE__ */ new Map();
-	for (const document of candidates) {
-		const item = itemsById.get(document.id);
-		if (!item) continue;
-		orderByItem.set(item, document.placement.kind === "home" ? Number.NEGATIVE_INFINITY : navigationOrder(document));
-		if (document.placement.kind === "entry") {
-			const parent = itemsById.get(document.placement.parentDocumentId);
-			if (parent) parent.children.push(item);
-			else roots.push(item);
-		} else roots.push(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 "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);
-}
-
-//#endregion
-//#region ../server/src/internal/documents/documents.ts
-const isDocumentGenerationConflict = Schema.is(DocumentGenerationConflict);
-const isDocumentMediaUnavailable = 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,
-		...options.configurationRevision === void 0 ? void 0 : { configurationRevision: options.configurationRevision },
-		repository
-	};
-	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);
-			const outcome = yield* commitDocumentMutation(accessControl, dependencies, current, command, activity);
-			if (outcome.kind === "unchanged") return outcome.result;
-			yield* Ref.set(state, outcome.next);
-			yield* PubSub.publish(mutationEvents, outcome.result);
-			return outcome.result;
-		}).pipe(Effect.tapError((error) => isDocumentGenerationConflict(error) ? refreshUnlocked(true) : Effect.void), Effect.retry({
-			schedule: Schedule.recurs(3),
-			while: isDocumentGenerationConflict
-		}));
-	});
-	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 collection = configuration.types.find((candidate) => candidate.collection === input.collection);
-		if (collection && !collection.canCreate) return yield* new DocumentValidationFailed({ issues: [{
-			code: "document.invalid",
-			field: "collection",
-			message: `Document collection "${input.collection}" does not allow creation.`,
-			severity: "error"
-		}] });
-		const plan = yield* Effect.fromResult(planDocumentCreation(configuration, input));
-		const source = yield* createInitialDocumentSource(plan);
-		const documentId = DocumentId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
-		const identity = Object.assign({
-			collection: plan.collection.collection,
-			documentId
-		}, plan.locale === void 0 ? void 0 : { locale: plan.locale });
-		return yield* runMutation({
-			action: "document.create",
-			identity,
-			markdown: source.markdown,
-			placement: plan.placement
-		}, activity, input.reason);
-	});
-	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 requireContentTransfer = (context) => accessControl.require(context, {
-		action: "document.transfer",
-		resource: { kind: "catalog" }
-	});
-	const contentSnapshot = (context) => requireContentTransfer(context).pipe(Effect.andThen(semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		const current = yield* Ref.get(state);
-		return ContentSnapshot.make({
-			version: 2,
-			sources: current.snapshot.active.map((source) => ({
-				identity: source.identity,
-				placement: source.placement,
-				markdown: source.markdown,
-				published: source.publishedVersion === source.version,
-				revisionId: source.revisionId
-			})).sort((left, right) => left.identity.documentId.localeCompare(right.identity.documentId))
-		});
-	}))));
-	const contentPlan = (context, input) => requireContentTransfer(context).pipe(Effect.andThen(semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		return (yield* planContentTransfer(engine, configuration, yield* Ref.get(state), input, crypto)).plan;
-	}))));
-	const contentApply = (context, input) => requireContentTransfer(context).pipe(Effect.andThen(semaphore.withPermits(1)(Effect.gen(function* () {
-		yield* refreshUnlocked();
-		const current = yield* Ref.get(state);
-		if (current.snapshot.generation !== input.expectedGeneration) return yield* new ContentTransferConflict({ message: "Content changed since the plan. Run content plan again." });
-		const planned = yield* planContentTransfer(engine, configuration, current, input, crypto);
-		if (planned.plan.entries.some((entry) => entry.action === "conflict")) return yield* new ContentTransferConflict({ message: "Destination content differs. Use --overwrite after reviewing the plan." });
-		if (!planned.plan.valid) return yield* new DocumentValidationFailed({ issues: planned.plan.issues });
-		if (planned.commitPlans.length === 0) return ContentApplyResult.make({
-			...planned.counts,
-			generation: current.snapshot.generation
-		});
-		const authored = yield* compileValidCatalog(engine, planned.authoredSources, current.authored);
-		const publishedCatalog = yield* compileValidCatalog(engine, planned.publishedSources, current.published);
-		const [first, ...additionalPlans] = planned.commitPlans;
-		if (!first) throw new Error("Content import requires a commit plan.");
-		const committed = yield* commitApprovedDocumentPlans({
-			repository,
-			current,
-			plans: [first, ...additionalPlans],
-			authored,
-			published: publishedCatalog,
-			activity: requestActivity$1(context, "CMS content import"),
-			...options.configurationRevision === void 0 ? void 0 : { configurationRevision: options.configurationRevision }
-		}).pipe(Effect.mapError((error) => isDocumentGenerationConflict(error) ? new ContentTransferConflict({ message: "Content changed since the plan. Run content plan again." }) : error));
-		yield* Ref.set(state, yield* compileDocumentState(engine, committed.snapshot, current));
-		yield* PubSub.publish(mutationEvents, committed.mutation);
-		return ContentApplyResult.make({
-			...planned.counts,
-			generation: committed.snapshot.generation
-		});
-	}))));
-	const documents = Documents.of({
-		contentSnapshot,
-		contentPlan,
-		contentApply,
-		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$1(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$1(context, input.reason))),
-		unpublish: (context, input) => requireThen(context, "document.unpublish", document(input.documentId), () => unpublish(input, requestActivity$1(context, input.reason))),
-		move: (context, input) => requireThen(context, "document.move", document(input.documentId), () => move(input, requestActivity$1(context, input.reason))),
-		publish: (context, input) => requireThen(context, "document.publish", document(input.documentId), () => publish(input, requestActivity$1(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$1(context, input.reason))),
-		restore: (context, input) => requireThen(context, "document.restore", document(input.documentId), () => restore(input, requestActivity$1(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$1(context, input.reason))),
-		update: (context, input) => requireThen(context, "document.update", document(input.documentId), () => update(input, requestActivity$1(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,
-		snapshot: published.pipe(Effect.map((catalog) => catalog.documents)),
-		surround: delivery.surround,
-		diagnostics: (context) => accessControl.require(context, {
-			action: "document.browse",
-			resource: { kind: "catalog" }
-		}).pipe(Effect.andThen(delivery.diagnostics))
-	});
-	return {
-		documents,
-		maintenance: DocumentMaintenance.of({
-			compile: (source) => engine.compile({
-				draft: source.publishedVersion !== source.version,
-				identity: source.identity,
-				markdown: source.markdown,
-				placement: source.placement
-			}),
-			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
-	};
-});
-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
-	}), Effect.mapError((error) => isDocumentGenerationConflict(error) || isDocumentMediaUnavailable(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$1(context, reason) {
-	return ActivityContext.make(Object.assign({
-		actor: context.actor,
-		requestId: context.requestId
-	}, reason === void 0 ? void 0 : { reason }));
-}
-
-//#endregion
-//#region ../server/src/internal/seo/seo-store.ts
-var SeoPersistenceError = class extends Schema.TaggedError()("Seo.PersistenceError", {
-	operation: Schema.NonEmptyString,
-	cause: Schema.Defect()
-}) {};
-var SeoStore = class extends Context.Service()("@internal/server/SeoStore") {};
-
-//#endregion
-//#region ../server/src/internal/seo/seo.ts
-var Seo = class extends Context.Service()("@internal/server/Seo") {};
-var PublishedSeo = class extends Context.Service()("@internal/server/PublishedSeo") {};
-var PreviewSeo = class extends Context.Service()("@internal/server/PreviewSeo") {};
-var SeoDelivery = class extends Context.Service()("@internal/server/SeoDelivery") {};
-function makeDefaultSeoOptions(baseUrl) {
-	const url = new URL(baseUrl);
-	return {
-		capabilities: SeoCapabilities.make({
-			generatedSocialImageTemplateIds: [],
-			identityTypes: [
-				"Person",
-				"Organization",
-				"LocalBusiness"
-			],
-			structuredDataTypes: ["WebPage", "Article"]
-		}),
-		defaults: GlobalSeoSettings.make({
-			canonicalOrigin: SeoCanonicalOrigin.make(url.origin),
-			follow: true,
-			index: true,
-			siteName: url.hostname
-		})
-	};
-}
-const seoLayer = (options) => Layer.effectContext(Effect.gen(function* () {
-	const accessControl = yield* AccessControl;
-	const store = yield* SeoStore;
-	const load = Effect.fn("Seo.load")(function* () {
-		return (yield* store.load) ?? (yield* store.initialize(options.defaults));
-	});
-	const state = Effect.fn("Seo.state")(function* () {
-		return makeState(yield* load(), options.capabilities);
-	});
-	const requireAdministrator = (context, action) => accessControl.require(context, {
-		action,
-		resource: { kind: "seo" }
-	});
-	const read = Effect.fn("Seo.read")(function* (context) {
-		yield* requireAdministrator(context, "seo.read");
-		return yield* state();
-	});
-	const save = Effect.fn("Seo.save")(function* (context, input) {
-		yield* requireAdministrator(context, "seo.save");
-		const snapshot = yield* store.save({
-			activity: requestActivity(context, input.reason),
-			expectedVersion: input.expectedVersion,
-			settings: input.settings
-		});
-		return SeoMutationResult.make({
-			action: "seo.save",
-			state: makeState(snapshot, options.capabilities)
-		});
-	});
-	const publish = Effect.fn("Seo.publish")(function* (context, input) {
-		yield* requireAdministrator(context, "seo.publish");
-		const snapshot = yield* load();
-		const confirmationChanges = productionChanges(snapshot.published?.settings ?? options.defaults, snapshot.working.settings);
-		if (confirmationChanges.length > 0 && input.confirmedSiteWideChange !== true) return yield* new SeoConfirmationRequired({ changes: confirmationChanges });
-		const published = yield* store.publish({
-			activity: requestActivity(context, input.reason),
-			expectedVersion: input.expectedVersion
-		});
-		return SeoMutationResult.make({
-			action: "seo.publish",
-			state: makeState(published, options.capabilities)
-		});
-	});
-	const seo = Seo.of({
-		publish,
-		read,
-		save
-	});
-	const publishedSeo = PublishedSeo.of({ read: load().pipe(Effect.map((snapshot) => SeoSnapshot.make({
-		capabilities: options.capabilities,
-		revision: snapshot.published ?? snapshot.working
-	}))) });
-	const previewSeo = PreviewSeo.of({ read: load().pipe(Effect.map((snapshot) => SeoSnapshot.make({
-		capabilities: options.capabilities,
-		revision: snapshot.working
-	}))) });
-	return Context.empty().pipe(Context.add(Seo, seo), Context.add(PublishedSeo, publishedSeo), Context.add(PreviewSeo, previewSeo));
-}));
-const seoDeliveryLayer = Layer.effect(SeoDelivery, Effect.gen(function* () {
-	const previews = yield* PreviewSeo;
-	const published = yield* PublishedSeo;
-	const documents = yield* PublishedDocuments;
-	const alternatives = (document) => documents.snapshot.pipe(Effect.map((snapshot) => snapshot.flatMap((candidate) => candidate.key === document.key && candidate.locale !== void 0 ? [{
-		locale: candidate.locale,
-		path: candidate.path
-	}] : [])));
-	const resolveWith = (document, snapshot, localized) => CompiledDocument.make(Object.assign({}, document, {
-		alternatives: localized,
-		resolvedSeo: resolveDocumentSeo({
-			capabilities: snapshot.capabilities,
-			document,
-			global: snapshot.revision.settings
-		})
-	}));
-	const publishedDocument = Effect.fn("SeoDelivery.publishedDocument")((document) => Effect.all({
-		snapshot: published.read,
-		alternatives: alternatives(document)
-	}).pipe(Effect.map(({ alternatives, snapshot }) => resolveWith(document, snapshot, alternatives))));
-	const previewDocument = Effect.fn("SeoDelivery.previewDocument")((document) => Effect.all({
-		snapshot: previews.read,
-		alternatives: alternatives(document)
-	}).pipe(Effect.map(({ alternatives, snapshot }) => resolveWith(document, snapshot, alternatives))));
-	const sitemap = Effect.gen(function* () {
-		const snapshot = yield* published.read;
-		const resolved = (yield* documents.snapshot).flatMap((document) => {
-			const resolvedDocument = resolveWith(document, snapshot, []);
-			return resolvedDocument.resolvedSeo?.index === true && resolvedDocument.source.publishedAt !== void 0 ? [resolvedDocument] : [];
-		});
-		const localesByKey = /* @__PURE__ */ new Map();
-		for (const document of resolved) {
-			if (document.locale === void 0) continue;
-			const alternatives = localesByKey.get(document.key) ?? [];
-			alternatives.push({
-				locale: document.locale,
-				loc: document.path
-			});
-			localesByKey.set(document.key, alternatives);
-		}
-		return resolved.flatMap((document) => {
-			const publishedAt = document.source.publishedAt;
-			if (publishedAt === void 0) return [];
-			const alternatives = localesByKey.get(document.key);
-			const entry = {
-				loc: document.path,
-				lastmod: publishedAt
-			};
-			return [SitemapEntry.make(alternatives && alternatives.length > 1 ? {
-				...entry,
-				alternatives
-			} : entry)];
-		}).sort((left, right) => left.loc.localeCompare(right.loc));
-	}).pipe(Effect.withSpan("SeoDelivery.sitemap"));
-	return SeoDelivery.of({
-		previewDocument,
-		publishedDocument,
-		sitemap
-	});
-}));
-function makeState(snapshot, capabilities) {
-	return SeoState.make(snapshot.published === void 0 ? {
-		capabilities,
-		working: snapshot.working
-	} : {
-		capabilities,
-		published: snapshot.published,
-		working: snapshot.working
-	});
-}
-function requestActivity(context, reason) {
-	return {
-		actor: context.actor,
-		requestId: context.requestId,
-		...reason === void 0 ? void 0 : { reason }
-	};
-}
-function productionChanges(previous, next) {
-	const changes = [];
-	if (previous.canonicalOrigin !== next.canonicalOrigin) changes.push("canonicalOrigin");
-	if (previous.index !== next.index || previous.follow !== next.follow) changes.push("indexability");
-	return changes;
-}
-
-//#endregion
-//#region ../server/src/internal/media/media-object-store.ts
-const mediaObjectPrefix = "media/";
-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 ../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,
-		requestChecksumCalculation: "WHEN_REQUIRED"
-	}));
-}
-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(input.body),
-			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 replaceableMediaCacheControl = "public, max-age=0, must-revalidate";
-const isWriteBodyError = Schema.is(Schema.Union([MediaInvalid, MediaStorageError]));
-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, options.prefix, client),
-		promote: (input) => promoteObject(options.bucket, options.prefix, input, client),
-		put: (input) => putObject(options.bucket, options.prefix, input, client),
-		remove: (objectKey) => providerRequest("MediaObjectStore.S3.remove", client.deleteObject({
-			bucket: options.bucket,
-			key: physicalKey(options.prefix, objectKey)
-		})),
-		stat: (objectKey) => statObject(options.bucket, options.prefix, objectKey, client)
-	};
-}
-function promoteObject(bucket, prefix, input, client) {
-	if (input.byteSize > 5e9) return Effect.fail(storageError("MediaObjectStore.S3.promote", "The object exceeds the S3 single-copy size limit."));
-	return statObject(bucket, prefix, 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: replaceableMediaCacheControl,
-		contentType: input.mimeType,
-		copySource: copySource(bucket, physicalKey(prefix, input.sourceObjectKey)),
-		key: physicalKey(prefix, input.destinationObjectKey)
-	}))), Effect.flatMap(() => statObject(bucket, prefix, 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, prefix, input, client) {
-	return Effect.gen(function* () {
-		const body = yield* validatedWriteBody(input);
-		yield* client.putObject({
-			body,
-			bucket,
-			cacheControl: replaceableMediaCacheControl,
-			contentLength: input.byteSize,
-			contentType: input.mimeType,
-			key: physicalKey(prefix, 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, prefix, objectKey, client) {
-	return client.headObject({
-		bucket,
-		key: physicalKey(prefix, 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, prefix, client) {
-	return Stream.suspend(() => {
-		const seenTokens = /* @__PURE__ */ new Set();
-		return Stream.paginate(void 0, (continuationToken) => providerRequest("MediaObjectStore.S3.list", client.listObjects({
-			bucket,
-			continuationToken,
-			prefix: `${prefix}${mediaObjectPrefix}`
-		})).pipe(Effect.flatMap((page) => Effect.gen(function* () {
-			return [yield* Effect.forEach(page.objects, (object) => decodeListedObject(object, prefix)), yield* validateNextContinuationToken(continuationToken, seenTokens, page)];
-		}))));
-	});
-}
-function decodeListedObject(object, prefix) {
-	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.slice(prefix.length), object.size);
-}
-function validateNextContinuationToken(continuationToken, seenTokens, page) {
-	if (!page.isTruncated) return Effect.succeedNone;
-	const token = page.nextContinuationToken;
-	if (!token || token === continuationToken || seenTokens.has(token)) return Effect.fail(storageError("MediaObjectStore.S3.list", "The provider returned an invalid continuation token."));
-	seenTokens.add(token);
-	return Effect.succeedSome(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();
-	const prefix = options.prefix.trim();
-	if (!bucket || !region || options.endpoint !== void 0 && !endpoint || !prefix || prefix.startsWith("/") || !prefix.endsWith("/") || prefix.includes("..")) return Effect.fail(storageError("MediaObjectStore.S3.configure", "The bucket, region, configured endpoint, and relative object prefix must be valid."));
-	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,
-		prefix,
-		provisionBucket: options.provisionBucket ?? false,
-		region
-	});
-}
-function physicalKey(prefix, objectKey) {
-	return `${prefix}${objectKey}`;
-}
-function storageError(operation, message) {
-	return new MediaStorageError({
-		cause: new Error(message),
-		operation
-	});
-}
-
-//#endregion
-//#region ../s3/src/S3MediaObjects.ts
-const maxS3SingleCopyBytes = 5e9;
-
-//#endregion
-export { DocumentHistoryInvalidCursor as $, StudioAuthentication as A, CreateUserInput as B, DocumentPersistenceError as C, defaultAccessControlLayer as D, AccessControl as E, StudioInternalError as F, UserPage as G, UserAdministrationDenied as H, studioInternalError as I, CollaborationClientMessage as J, UserSelfRemovalDenied as K, InitializationAlreadyCompleted as L, StudioBootstrap as M, StudioRequestConflict as N, CurrentStudioRequest as O, StudioSchemaError as P, DocumentHistoryComparisonTooLarge as Q, InitializationProofInvalid as R, DocumentGenerationConflict as S, renderEditorMarkdown as T, UserAlreadyExists as U, User as V, UserNotFound as W, CollaborationTicket as X, CollaborationServerMessage as Y, StateVector as Z, Documents as _, mediaObjectPrefix as a, ActivityCursorInvalid as at, cursorCodec as b, Seo as c, ActivityId as ct, seoDeliveryLayer as d, ActivityTargetKind as dt, DocumentRevision as et, seoLayer as f, DocumentPreviews as g, DocumentMaintenance as h, MediaObjectStore as i, ActivityCursor as it, StudioBadRequest as j, StudioApi as k, SeoDelivery as l, ActivityPage as lt, SeoStore as m, s3MediaObjectStoreLayer as n, ActivityAction as nt, PreviewSeo as o, ActivityEntry as ot, SeoPersistenceError as p, UserSelfRoleChangeDenied as q, MediaPersistenceError as r, ActivityContext as rt, PublishedSeo as s, ActivityEntryDraft as st, maxS3SingleCopyBytes as t, ACTIVITY_ACTIONS as tt, makeDefaultSeoOptions as u, ActivityTarget as ut, PublishedDocuments as v, DocumentStore as w, DocumentConfigurationConflict as x, documentsLayer as y, InitializationState as z };
-//# sourceMappingURL=S3MediaObjects-Dwhl2deX.js.map