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

package/src/S3MediaObjects-CpPSzJto.js

@@ -0,0 +1,2777 @@
+import { c as RevisionId, d as SourcePath, f as nonNegativeInt, i as DocumentVersion, n as DocumentHistoryCursor, o as PublicPath, r as DocumentId, s as RelativeDocumentPath, t as DocumentGeneration, u as Slug } from "./scalars-B2lgGUnj.js";
+import { i as FormResult, o as FormSubmission } from "./Forms-CfcI3tPU.js";
+import { a as encodeCmsEditorComponentAttributes, d as createCmsComarkRenderData, m as toComarkDocument, p as mutableJsonObject, s as projectCmsEditorComponentAttributes } from "./Forms-Dj6NuW66.js";
+import { $ as StudioActor, B as SeoMediaUnavailable, C as PublishedDocumentLookup, D as RemoveDocumentInput, E as PublishedDocumentSurroundQuery, Et as RequestId, F as SaveSeoInput, G as SeoUrl, I as SeoCanonicalOrigin, J as AccessDenied, K as SeoVersionConflict, L as SeoCapabilities, N as GlobalSeoSettings, O as RestoreDocumentInput, P as PublishSeoInput, Q as Role, R as SeoConfiguration, S as PublishDocumentInput, T as PublishedDocumentQuery, U as SeoSnapshot, V as SeoMutationResult, W as SeoState, X as DOCUMENT_ACTIONS, Y as AuthenticationRequired, Z as MEDIA_ACTIONS, _ as DocumentSurround, _t as MediaReference, at as MediaCleanupReport, bt as MediaTooLarge, c as DocumentIssue, ct as MediaFolder, d as DocumentNavigationQuery, dt as MediaInvalid, et as StudioEntryDenied, f as DocumentQueryScalar, g as DocumentSummary, gt as MediaQuery, ht as MediaPage, i as CreateDocumentInput, it as MediaByteSize, j as UpdateDocumentInput, k as UndeleteDocumentInput, l as DocumentMutationResult, lt as MediaId, m as DocumentSource, mt as MediaObjectKey, n as CmsMarkdownDocument, nt as ImageMimeType, o as DeletedDocument, ot as MediaConflict, p as DocumentRevisionAction, pt as MediaNotFound, q as SitemapEntry, r as CompiledDocument, rt as MediaAsset, s as DocumentBrowseQuery, u as DocumentNavigationItem, ut as MediaIntegrityReport, v as DocumentValidationResult, vt as MediaReferenced, w as PublishedDocumentPage, x as MoveDocumentInput, xt as MediaUpload, y as DuplicateDocumentInput, z as SeoConfirmationRequired } from "./models-Bah5B3bT.js";
+import { u as STUDIO_API_PATH } from "./HttpPaths-c9nLZ9H2.js";
+import { i as withoutEditorMetadata } from "./metadata-BEZPWh-3.js";
+import { d as EditorRenderFailed, i as MediaConfiguration, r as DocumentConfiguration } from "./Configuration-CDMYfTre.js";
+import { i as ContentSnapshot, n as ContentApplyResult, o as ContentTransferConflict, r as ContentPlan, s as ContentTransferInput, t as ContentApplyInput } from "./ContentTransfer-C3Av9sWz.js";
+import { a as normalizeDocumentRelativePath, c as resolveDocumentAddress, i as localizeDocumentPath, n as referenceTarget, o as normalizePublicPath, r as DocumentCompilationFailed, s as parseDocumentAddress, t as createDocumentEngine } from "./DocumentEngine-J7g-emdf.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/internal/documents/errors.ts
+var DocumentNotFound = class extends Schema.TaggedError()("Document.NotFound", {
+	documentId: DocumentId,
+	revisionId: Schema.optionalKey(RevisionId)
+}) {};
+var DocumentPathConflict = class extends Schema.TaggedError()("Document.PathConflict", { sourcePath: SourcePath }) {};
+var DocumentVersionConflict = class extends Schema.TaggedError()("Document.VersionConflict", {
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	actualVersion: DocumentVersion
+}) {};
+var DocumentMediaUnavailable = class extends Schema.TaggedError()("Document.MediaUnavailable", {
+	documentId: DocumentId,
+	mediaKeys: Schema.Array(MediaObjectKey).check(Schema.isMinLength(1))
+}) {};
+var DocumentValidationFailed = class extends Schema.TaggedError()("Document.ValidationFailed", { issues: Schema.Array(DocumentIssue) }) {};
+var PublishedDocumentNotFound = class extends Schema.TaggedError()("PublishedDocument.NotFound", { lookup: PublishedDocumentLookup }) {};
+
+//#endregion
+//#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,
+	revisionId: RevisionId,
+	sourcePath: SourcePath,
+	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,
+	location: MoveDocumentInput.fields.location,
+	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,
+	DocumentPathConflict,
+	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
+	}),
+	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
+	]
+})).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/internal/document-engine/relocate-links.ts
+/** Rewrites only semantic page links, preserving bindings and unrelated content. */
+function rewriteDocumentRoutes(document, destinations, components = []) {
+	let changed = false;
+	function link(value) {
+		const target = referenceTarget("a", /* @__PURE__ */ new Map([["href", value]]), document.path, void 0);
+		if (target?.kind !== "document" || !Predicate.isString(value)) return value;
+		const destination = destinations.get(target.path);
+		const sourceMoved = destinations.has(document.path);
+		if (!destination && (!sourceMoved || value.startsWith("/"))) return value;
+		const suffix = value.match(/[?#].*$/u)?.[0] ?? "";
+		const next = `${destination ?? target.path}${suffix}`;
+		if (next !== value) changed = true;
+		return next;
+	}
+	function properties(fields, values) {
+		const result = mutableJsonObject(values);
+		for (const field of fields) {
+			const value = values[field.name] === void 0 ? field.defaultValue : values[field.name];
+			if (field.input === "link") {
+				const next = link(value);
+				if (next !== void 0 && next !== value) result[field.name] = next;
+			} else if (field.fields) {
+				const next = Array.isArray(value) ? value.map((item) => Schema.is(Schema.JsonObject)(item) ? properties(field.fields ?? [], item) : item) : Schema.is(Schema.JsonObject)(value) ? properties(field.fields, value) : value;
+				if (next !== void 0 && JSON.stringify(next) !== JSON.stringify(value)) result[field.name] = next;
+			}
+		}
+		return result;
+	}
+	function visit(node, renderData) {
+		if (Predicate.isString(node) || node[0] === null) return node;
+		const [tag, attributes, ...children] = node;
+		const projection = projectCmsEditorComponentAttributes(attributes, renderData);
+		let props = properties(components.find((component) => component.name.toLowerCase() === tag.toLowerCase())?.authoring.props ?? [], projection.props);
+		if (tag === "a") {
+			const href = link(projection.props.href);
+			if (href !== void 0) props = Object.assign({}, props, { href });
+		}
+		return [
+			tag,
+			JSON.stringify(props) === JSON.stringify(projection.props) ? attributes : encodeCmsEditorComponentAttributes(props, projection.bindings),
+			...children.map((child) => visit(child, projection.renderData))
+		];
+	}
+	const nodes = document.body.nodes.map((node) => visit(node, createCmsComarkRenderData(document.body)));
+	return changed ? Object.assign({}, document.body, { nodes }) : void 0;
+}
+
+//#endregion
+//#region ../document/src/DocumentPlanning.ts
+function planDocumentCreation(configuration, input) {
+	return Result.gen(function* () {
+		const collection = configuration.types.find((candidate) => candidate.collection === input.collection);
+		if (!collection) return yield* invalid$1(`Document collection "${input.collection}" does not exist.`, "collection");
+		const title = input.title.trim();
+		if (!title) return yield* invalid$1("A document title is required.", "title");
+		const locale = yield* resolveLocale(configuration, input.locale);
+		const address = yield* parseDocumentAddress(collection.addressPattern).pipe(Result.mapError(addressInvalid));
+		const relativePath = yield* resolveRelativePath(collection, input.location);
+		const data = Object.fromEntries(address.tokens.flatMap((token) => {
+			if (token.name === "slug" && relativePath) return [[token.name, relativePath.split("/").at(-1) ?? relativePath]];
+			return [];
+		}));
+		const relativeKey = yield* normalizePublicPath(relativePath).pipe(Result.mapError(addressInvalid));
+		const key = yield* resolveDocumentAddress(address, relativeKey, data).pipe(Result.mapError(addressInvalid));
+		const sourcePath = documentSourcePath(collection, relativePath, locale);
+		const path = localizeDocumentPath(key, locale, configuration.locales);
+		return Object.assign({
+			collection,
+			data,
+			key,
+			path,
+			sourcePath,
+			title
+		}, locale === void 0 ? void 0 : { locale });
+	});
+}
+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 planDocumentMove(configuration, document, location) {
+	return Result.gen(function* () {
+		const collection = configuration.types.find((candidate) => candidate.collection === document.collection);
+		if (!collection) return yield* invalid$1(`Document collection "${document.collection}" does not exist.`, "documentId");
+		return documentSourcePath(collection, yield* resolveRelativePath(collection, location), document.locale);
+	});
+}
+function documentRelativePath(collection, entry) {
+	let sourcePath = entry.sourcePath;
+	if (entry.document.locale && sourcePath.startsWith(`${entry.document.locale}/`)) sourcePath = sourcePath.slice(entry.document.locale.length + 1);
+	if (collection.directory !== "." && sourcePath.startsWith(`${collection.directory}/`)) sourcePath = sourcePath.slice(collection.directory.length + 1);
+	sourcePath = sourcePath.replace(/\.(?:md|mdc)$/iu, "");
+	return sourcePath.toLocaleLowerCase() === "index" ? void 0 : sourcePath.replace(/\/index$/iu, "");
+}
+function documentSourcePath(collection, relativePath, locale) {
+	const sourceName = relativePath ? `${relativePath}.md` : "index.md";
+	return SourcePath.make([
+		locale,
+		collection.directory === "." ? void 0 : collection.directory,
+		sourceName
+	].filter((value) => value !== void 0).join("/"));
+}
+function initialFrontmatter(plan) {
+	let frontmatter = {
+		...plan.data,
+		title: plan.title
+	};
+	for (const field of plan.collection.authoringFields) if (field.defaultValue !== void 0 && nestedValue$1(frontmatter, field.path) === void 0) frontmatter = setNestedValue(frontmatter, field.path.split("."), field.defaultValue);
+	return frontmatter;
+}
+function nestedValue$1(value, path) {
+	return path.split(".").reduce((current, segment) => isJsonObject(current) ? current[segment] : void 0, value);
+}
+function setNestedValue(target, path, value) {
+	const [segment, ...rest] = path;
+	if (!segment) return target;
+	if (rest.length === 0) return Object.assign({}, target, { [segment]: value });
+	const current = target[segment];
+	return Object.assign({}, target, { [segment]: setNestedValue(isJsonObject(current) ? current : {}, rest, value) });
+}
+const isJsonObject = Schema.is(Schema.JsonObject);
+function resolveLocale(configuration, requested) {
+	const locales = configuration.locales;
+	if (!locales) return requested === void 0 ? Result.succeed(void 0) : invalid$1(`Document locale "${requested}" is not configured.`, "locale");
+	const locale = requested ?? locales.defaultLocale;
+	return locales.locales.includes(locale) ? Result.succeed(locale) : invalid$1(`Document locale "${locale}" does not exist.`, "locale");
+}
+function resolveRelativePath(collection, location) {
+	if (location.kind === "home") return collection.addressPattern === "/:path*" ? Result.succeed("") : invalid$1("Only a root catch-all collection can use the home location.", "location");
+	if (location.parent !== void 0 && !collection.hierarchy) return invalid$1(`Document collection "${collection.collection}" does not allow hierarchy.`, "location.parent");
+	return normalizeDocumentRelativePath([location.parent, location.slug].filter((value) => value !== void 0).join("/")).pipe(Result.mapError((error) => addressInvalid({
+		...error,
+		field: "location"
+	})));
+}
+function addressInvalid(error) {
+	return new DocumentValidationFailed({ issues: [validationIssue(error.message, error.field)] });
+}
+function invalid$1(message, field) {
+	return Result.fail(new DocumentValidationFailed({ issues: [validationIssue(message, field)] }));
+}
+function validationIssue(message, field) {
+	return field === void 0 ? {
+		code: "document.invalid",
+		message,
+		severity: "error"
+	} : {
+		code: "document.invalid",
+		field,
+		message,
+		severity: "error"
+	};
+}
+/** Updates route-owned frontmatter when relocating a page in a slug-addressed collection. */
+const relocateDocumentMarkdown = Effect.fn("DocumentPlanning.relocateMarkdown")(function* (configuration, document, location, markdown) {
+	const collection = configuration.types.find((type) => type.collection === document.collection);
+	if (!collection || !collection.addressPattern.includes(":slug") || location.kind === "home") return markdown;
+	return yield* renderEditorMarkdown({
+		...document.body,
+		frontmatter: {
+			...document.body.frontmatter,
+			slug: location.slug
+		}
+	});
+});
+
+//#endregion
+//#region ../server/src/internal/documents/document-state.ts
+const isDocumentCompilationFailed = Schema.is(DocumentCompilationFailed);
+function makeDocumentState(authored, published, snapshot) {
+	const activeById = /* @__PURE__ */ new Map();
+	for (const source of snapshot.active) {
+		if (activeById.has(source.documentId)) throw new Error(`Document "${source.documentId}" appears more than once in the repository snapshot.`);
+		activeById.set(source.documentId, source);
+	}
+	const authoredById = /* @__PURE__ */ new Map();
+	for (const document of authored.documents) {
+		if (authoredById.has(document.id)) throw new Error(`Compiled document "${document.id}" appears more than once in the authored catalog.`);
+		if (!activeById.has(document.id)) throw new Error(`Compiled document "${document.id}" is missing from the repository snapshot.`);
+		authoredById.set(document.id, document);
+	}
+	for (const documentId of activeById.keys()) if (!authoredById.has(documentId)) throw new Error(`Compiled document "${documentId}" is missing from the repository snapshot.`);
+	return {
+		activeById,
+		authored,
+		authoredById,
+		published,
+		snapshot
+	};
+}
+const compileDocumentState = Effect.fn("DocumentState.compile")(function* (engine, snapshot, previous) {
+	return makeDocumentState(yield* engine.compileAll({
+		previous: previous?.authored,
+		sources: authoredSources(snapshot)
+	}), yield* engine.compileAll({
+		previous: previous?.published,
+		sources: publishedSources(snapshot)
+	}), snapshot);
+});
+function authoredSources(snapshot) {
+	return snapshot.active.map((source) => ({
+		documentId: source.documentId,
+		draft: source.publishedVersion !== source.version,
+		markdown: source.markdown,
+		sourcePath: source.sourcePath
+	}));
+}
+function publishedSources(snapshot) {
+	return snapshot.published.map((source) => ({
+		documentId: source.documentId,
+		draft: false,
+		markdown: source.markdown,
+		publishedAt: source.editedAt,
+		sourcePath: source.sourcePath
+	}));
+}
+const compileValidCatalog = Effect.fn("DocumentState.compileValid")(function* (engine, sources, previous) {
+	const result = yield* Effect.result(engine.compileAll({
+		previous,
+		sources
+	}));
+	if (Result.isFailure(result)) return yield* new DocumentValidationFailed({ issues: compilationIssues(result.failure) });
+	const errors = result.success.issues.filter((issue) => issue.severity === "error");
+	if (errors.length > 0) return yield* new DocumentValidationFailed({ issues: errors });
+	return result.success;
+});
+const validateDocumentSources = Effect.fn("DocumentState.validate")(function* (engine, sources, sourcePath, previous) {
+	const result = yield* Effect.result(engine.compileAll({
+		previous,
+		sources
+	}));
+	if (Result.isFailure(result)) return DocumentValidationResult.make({
+		issues: compilationIssues(result.failure),
+		valid: false
+	});
+	const catalog = result.success;
+	const document = catalog.documents.find((candidate) => candidate.source.path === sourcePath);
+	const issues = catalog.issues;
+	const validation = {
+		issues,
+		valid: document !== void 0 && !issues.some((issue) => issue.severity === "error")
+	};
+	return DocumentValidationResult.make(Object.assign(validation, document === void 0 ? void 0 : { document }));
+});
+function authoringEntries(state, query) {
+	return state.snapshot.active.flatMap((source) => {
+		const document = state.authoredById.get(source.documentId);
+		if (!document) throw new Error(`Compiled document "${source.documentId}" is missing from the repository snapshot.`);
+		if (query.collection !== void 0 && document.collection !== query.collection) return [];
+		if (query.locale !== void 0 && document.locale !== query.locale) return [];
+		return [DocumentSummary.make({
+			...browseMetadata(state, source),
+			document,
+			sourcePath: source.sourcePath,
+			version: source.version
+		})];
+	});
+}
+function deletedEntries(state) {
+	return state.snapshot.deleted.map((source) => DeletedDocument.make({
+		...source.title ? { title: source.title } : void 0,
+		...source.path ? { path: source.path } : void 0,
+		...source.trashBatchId ? { trashBatchId: source.trashBatchId } : void 0,
+		documentId: source.documentId,
+		deletedAt: source.deletedAt,
+		sourcePath: source.sourcePath,
+		version: source.version
+	}));
+}
+function entryById(state, documentId) {
+	const source = state.activeById.get(documentId);
+	const document = state.authoredById.get(documentId);
+	return source && document ? DocumentSummary.make({
+		...browseMetadata(state, source),
+		document,
+		sourcePath: source.sourcePath,
+		version: source.version
+	}) : void 0;
+}
+function compilationIssues(error) {
+	if (isDocumentCompilationFailed(error)) return error.issues;
+	return [{
+		code: "markdown.parse",
+		message: errorMessage(error.cause),
+		severity: "error",
+		sourcePath: error.sourcePath
+	}];
+}
+function errorMessage(cause) {
+	return cause instanceof Error && cause.message ? cause.message : "Markdown could not be parsed.";
+}
+function browseMetadata(state, source) {
+	const live = state.published.documents.find((document) => document.id === source.documentId);
+	const metadata = {};
+	if (source.createdBy) metadata.createdBy = source.createdBy;
+	if (source.editedBy) metadata.editedBy = source.editedBy;
+	if (source.editedAt) metadata.editedAt = source.editedAt;
+	if (source.publishedVersion) metadata.publishedVersion = source.publishedVersion;
+	if (live) metadata.publishedPath = live.path;
+	return metadata;
+}
+
+//#endregion
+//#region ../server/src/internal/documents/document-tree-mutation.ts
+/** Selects by route boundaries, never by title or a raw prefix such as /about matching /about-us. */
+function subtreeIds(state, documentId) {
+	const parent = state.authoredById.get(documentId);
+	if (!parent) return [documentId];
+	return state.authored.documents.filter((page) => page.id === parent.id || parent.key !== "/" && page.collection === parent.collection && page.locale === parent.locale && page.key.startsWith(`${parent.key}/`)).map((page) => page.id);
+}
+const prepareTreeMutation = Effect.fn("Documents.prepareTreeMutation")(function* (dependencies, state, command) {
+	const { configuration, engine } = dependencies;
+	const input = command.input;
+	const root = command.action === "document.undelete" ? state.snapshot.deleted.find((source) => source.documentId === input.documentId) : state.activeById.get(input.documentId);
+	if (!root) return yield* new DocumentNotFound({ documentId: input.documentId });
+	if (root.version !== input.expectedVersion) return yield* new DocumentVersionConflict({
+		documentId: root.documentId,
+		actualVersion: root.version,
+		expectedVersion: input.expectedVersion
+	});
+	let sources;
+	if (command.action === "document.undelete") {
+		const deleted = state.snapshot.deleted.find((source) => source.documentId === root.documentId);
+		sources = state.snapshot.deleted.filter((source) => source.documentId === root.documentId || deleted && deleted.trashBatchId && source.trashBatchId === deleted.trashBatchId && deleted.path !== void 0 && source.path?.startsWith(`${deleted.path}/`));
+	} else {
+		const ids = new Set(command.action === "document.duplicate" && !command.input.includeChildren ? [root.documentId] : subtreeIds(state, root.documentId));
+		sources = state.snapshot.active.filter((source) => ids.has(source.documentId));
+	}
+	sources = [root, ...sources.filter((source) => source.documentId !== root.documentId)];
+	const plans = [];
+	const parent = state.authoredById.get(root.documentId);
+	for (const source of sources) {
+		if (command.action === "document.remove" || command.action === "document.undelete") {
+			const page = state.authoredById.get(source.documentId);
+			plans.push({
+				...command.action === "document.remove" ? {
+					trashBatchId: root.version,
+					title: page?.title,
+					path: page?.path
+				} : void 0,
+				action: command.action,
+				documentId: source.documentId,
+				expectedVersion: source.version,
+				markdown: source.markdown,
+				sourcePath: source.sourcePath
+			});
+			continue;
+		}
+		const page = state.authoredById.get(source.documentId);
+		const collection = configuration.types.find((type) => type.collection === page?.collection);
+		if (!page || !parent || !collection) return yield* new DocumentNotFound({ documentId: source.documentId });
+		if (command.action === "document.duplicate" && !collection.canCreate) return yield* invalid("This collection does not allow new pages.");
+		const destination = command.input.location;
+		if (parent.key === "/" && command.action === "document.move") return yield* invalid("The home page cannot be moved.");
+		const rootRelative = documentRelativePath(collection, {
+			document: parent,
+			sourcePath: root.sourcePath
+		}) ?? "";
+		const nextRelative = destination.kind === "home" ? "" : [destination.parent, destination.slug].filter(Boolean).join("/");
+		if (rootRelative && (nextRelative === rootRelative || nextRelative.startsWith(`${rootRelative}/`))) return yield* invalid("Choose a destination outside this page and its subpages.");
+		const relative = documentRelativePath(collection, {
+			document: page,
+			sourcePath: source.sourcePath
+		}) ?? "";
+		const segments = `${nextRelative}${source.documentId === root.documentId ? "" : relative.slice(rootRelative.length)}`.split("/").filter(Boolean);
+		const slug = segments.pop();
+		const location = slug ? Object.assign({
+			kind: "entry",
+			slug: yield* decodeSlug(slug)
+		}, segments.length ? { parent: yield* decodeParent(segments.join("/")) } : void 0) : { kind: "home" };
+		const sourcePath = yield* Effect.fromResult(planDocumentMove(configuration, page, location));
+		const markdown = yield* relocateDocumentMarkdown(configuration, page, location, source.markdown).pipe(Effect.mapError(() => invalid("The page could not be copied to its new URL.")));
+		if (command.action === "document.duplicate") {
+			const documentId = yield* command.nextDocumentId;
+			plans.push({
+				action: "document.create",
+				documentId,
+				markdown,
+				sourcePath
+			});
+		} else plans.push({
+			action: "document.move",
+			documentId: source.documentId,
+			expectedVersion: source.version,
+			markdown,
+			sourcePath,
+			publishedVersion: source.publishedVersion
+		});
+	}
+	const changed = new Set(plans.map((plan) => plan.documentId));
+	const nextSources = authoredSources(state.snapshot).filter((source) => !changed.has(source.documentId));
+	if (command.action !== "document.remove") for (const plan of plans) {
+		if (nextSources.some((source) => source.sourcePath === plan.sourcePath)) return yield* new DocumentPathConflict({ sourcePath: plan.sourcePath });
+		nextSources.push({
+			documentId: plan.documentId,
+			draft: true,
+			markdown: plan.markdown,
+			sourcePath: plan.sourcePath
+		});
+	}
+	if (command.action === "document.move" || command.action === "document.duplicate") {
+		const preliminary = yield* engine.compileAll({
+			sources: nextSources,
+			previous: state.authored
+		});
+		const destinations = /* @__PURE__ */ new Map();
+		for (let index = 0; index < sources.length; index++) {
+			const original = sources[index];
+			const plan = plans[index];
+			const oldPage = original && state.authoredById.get(original.documentId);
+			const newPage = plan && preliminary.documents.find((document) => document.id === plan.documentId);
+			if (oldPage && newPage) destinations.set(oldPage.path, newPage.path);
+		}
+		const originals = command.action === "document.move" ? state.snapshot.active : sources;
+		for (const source of originals) {
+			const page = state.authoredById.get(source.documentId);
+			if (!page) continue;
+			const body = rewriteDocumentRoutes(page, destinations, dependencies.components);
+			if (!body) continue;
+			const index = command.action === "document.duplicate" ? sources.findIndex((item) => item.documentId === source.documentId) : plans.findIndex((plan) => plan.documentId === source.documentId);
+			const existing = index >= 0 ? plans[index] : void 0;
+			const projected = existing && preliminary.documents.find((document) => document.id === existing.documentId);
+			const markdown = yield* renderEditorMarkdown(Object.assign({}, body, { frontmatter: projected?.body.frontmatter ?? body.frontmatter })).pipe(Effect.mapError(() => invalid("Page links could not be updated.")));
+			if (existing) plans[index] = {
+				...existing,
+				markdown
+			};
+			else plans.push({
+				action: "document.update",
+				documentId: source.documentId,
+				expectedVersion: source.version,
+				sourcePath: source.sourcePath,
+				markdown,
+				publishedVersion: source.publishedVersion
+			});
+		}
+		for (const plan of plans) {
+			const index = nextSources.findIndex((source) => source.documentId === plan.documentId);
+			const updated = {
+				documentId: plan.documentId,
+				sourcePath: plan.sourcePath,
+				markdown: plan.markdown,
+				draft: true
+			};
+			if (index >= 0) nextSources[index] = updated;
+			else nextSources.push(updated);
+		}
+	}
+	const first = plans[0];
+	if (!first) return yield* Effect.die(/* @__PURE__ */ new Error("Empty subtree mutation."));
+	return {
+		authored: yield* compileValidCatalog(engine, nextSources, state.authored),
+		published: command.action === "document.remove" ? yield* compileValidCatalog(engine, publishedSources(state.snapshot).filter((source) => !changed.has(source.documentId)), state.published) : state.published,
+		commitPlan: first,
+		additionalPlans: plans.slice(1)
+	};
+});
+const decodeSlug = (value) => Schema.decodeEffect(Slug)(value).pipe(Effect.mapError(() => invalid("Invalid URL ending.")));
+const decodeParent = (value) => Schema.decodeEffect(RelativeDocumentPath)(value).pipe(Effect.mapError(() => invalid("Invalid parent URL.")));
+function invalid(message) {
+	return new DocumentValidationFailed({ issues: [{
+		code: "document.invalid",
+		severity: "error",
+		message
+	}] });
+}
+
+//#endregion
+//#region ../server/src/internal/documents/document-lifecycle.ts
+const PreparedDocumentMutation = Data.taggedEnum();
+const prepareDocumentMutation = Effect.fn("DocumentLifecycle.prepare")(function* (dependencies, state, command) {
+	const { engine, repository } = dependencies;
+	if (command.action === "document.move" || command.action === "document.remove" || command.action === "document.undelete" || command.action === "document.duplicate") return PreparedDocumentMutation.Commit(yield* prepareTreeMutation(dependencies, state, command));
+	const authored = authoredSources(state.snapshot);
+	const published = publishedSources(state.snapshot);
+	switch (command.action) {
+		case "document.create": {
+			yield* ensurePathAvailable(state, command.sourcePath);
+			const nextAuthored = [...authored, {
+				documentId: command.documentId,
+				draft: true,
+				markdown: command.markdown,
+				sourcePath: command.sourcePath
+			}];
+			return PreparedDocumentMutation.Commit({
+				authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
+				published: state.published,
+				commitPlan: {
+					action: command.action,
+					documentId: command.documentId,
+					markdown: command.markdown,
+					sourcePath: command.sourcePath
+				}
+			});
+		}
+		case "document.update": {
+			const current = yield* requireActive(state, command.input.documentId);
+			yield* requireVersion(current, command.input.expectedVersion);
+			const nextAuthored = replaceSource(authored, {
+				documentId: current.documentId,
+				draft: true,
+				markdown: command.input.markdown,
+				sourcePath: current.sourcePath
+			});
+			return PreparedDocumentMutation.Commit({
+				authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
+				published: state.published,
+				commitPlan: {
+					action: command.action,
+					documentId: current.documentId,
+					expectedVersion: command.input.expectedVersion,
+					markdown: command.input.markdown,
+					publishedVersion: current.publishedVersion,
+					sourcePath: current.sourcePath
+				}
+			});
+		}
+		case "document.restore": {
+			const current = yield* requireActive(state, command.input.documentId);
+			yield* requireVersion(current, command.input.expectedVersion);
+			const historical = yield* repository.revision(current.documentId, command.input.revisionId);
+			const nextAuthored = replaceSource(authored, {
+				documentId: current.documentId,
+				draft: true,
+				markdown: historical.markdown,
+				sourcePath: current.sourcePath
+			});
+			return PreparedDocumentMutation.Commit({
+				authored: yield* compileValidCatalog(engine, nextAuthored, state.authored),
+				published: state.published,
+				commitPlan: {
+					action: command.action,
+					documentId: current.documentId,
+					expectedVersion: command.input.expectedVersion,
+					markdown: historical.markdown,
+					publishedVersion: current.publishedVersion,
+					revisionId: command.input.revisionId,
+					sourcePath: current.sourcePath
+				}
+			});
+		}
+		case "document.unpublish": {
+			const current = yield* requireActive(state, command.input.documentId);
+			yield* requireVersion(current, command.input.expectedVersion);
+			return PreparedDocumentMutation.Commit({
+				authored: yield* compileValidCatalog(engine, replaceSource(authored, {
+					documentId: current.documentId,
+					draft: true,
+					markdown: current.markdown,
+					sourcePath: current.sourcePath
+				}), state.authored),
+				published: yield* compileValidCatalog(engine, withoutDocument(published, current.documentId), state.published),
+				commitPlan: {
+					action: command.action,
+					documentId: current.documentId,
+					expectedVersion: current.version,
+					markdown: current.markdown,
+					sourcePath: current.sourcePath,
+					revisionId: current.revisionId
+				}
+			});
+		}
+		case "document.publish": {
+			const current = yield* requireActive(state, command.input.documentId);
+			yield* requireVersion(current, command.input.expectedVersion);
+			if (current.publishedVersion === current.version) {
+				const entry = entryById(state, current.documentId);
+				const result = {
+					action: "document.publish",
+					affectedDocumentIds: [current.documentId],
+					documentId: current.documentId,
+					generation: state.snapshot.generation,
+					revisionId: current.revisionId,
+					sourcePath: current.sourcePath,
+					version: current.version
+				};
+				return PreparedDocumentMutation.Unchanged({ result: DocumentMutationResult.make(Object.assign(result, entry === void 0 ? void 0 : { entry })) });
+			}
+			const source = {
+				documentId: current.documentId,
+				draft: false,
+				markdown: current.markdown,
+				sourcePath: current.sourcePath
+			};
+			return PreparedDocumentMutation.Commit({
+				authored: yield* compileValidCatalog(engine, replaceSource(authored, source), state.authored),
+				published: yield* compileValidCatalog(engine, replaceSource(published, source), state.published),
+				commitPlan: {
+					action: command.action,
+					documentId: current.documentId,
+					expectedVersion: command.input.expectedVersion,
+					markdown: current.markdown,
+					revisionId: current.revisionId,
+					sourcePath: current.sourcePath
+				}
+			});
+		}
+	}
+});
+const validateDocumentUpdate = Effect.fn("DocumentLifecycle.validateUpdate")(function* (engine, state, input) {
+	const current = yield* requireActive(state, input.documentId);
+	yield* requireVersion(current, input.expectedVersion);
+	const source = {
+		documentId: current.documentId,
+		draft: true,
+		markdown: input.markdown,
+		sourcePath: current.sourcePath
+	};
+	return yield* validateDocumentSources(engine, replaceSource(authoredSources(state.snapshot), source), current.sourcePath, state.authored);
+});
+function requireActive(state, documentId) {
+	const source = state.activeById.get(documentId);
+	return source ? Effect.succeed(source) : Effect.fail(new DocumentNotFound({ documentId }));
+}
+function requireVersion(source, expectedVersion) {
+	return source.version === expectedVersion ? Effect.void : Effect.fail(new DocumentVersionConflict({
+		actualVersion: source.version,
+		documentId: source.documentId,
+		expectedVersion
+	}));
+}
+function ensurePathAvailable(state, sourcePath, exceptDocumentId) {
+	return state.snapshot.active.some((source) => source.sourcePath === sourcePath && source.documentId !== exceptDocumentId) ? Effect.fail(new DocumentPathConflict({ sourcePath })) : Effect.void;
+}
+function replaceSource(sources, source) {
+	return [...sources.filter((candidate) => candidate.documentId !== source.documentId), source];
+}
+function withoutDocument(sources, documentId) {
+	return sources.filter((source) => source.documentId !== documentId);
+}
+
+//#endregion
+//#region ../server/src/internal/documents/document-media-references.ts
+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),
+		path: reference.source.path,
+		sourcePath: reference.source.sourcePath
+	});
+}
+function referenceIdentity(reference) {
+	return `${reference.documentId}:${reference.sourcePath}:${reference.nodePath.join(".")}:${reference.objectKey}`;
+}
+
+//#endregion
+//#region ../server/src/internal/documents/content-transfer.ts
+/** Plan all incoming sources against one document generation, including cross-document references. */
+const planContentTransfer = Effect.fn("ContentTransfer.plan")(function* (engine, state, input, crypto) {
+	const currentByPath = new Map(state.snapshot.active.map((source) => [source.sourcePath, source]));
+	const seen = /* @__PURE__ */ new Set();
+	const commitPlans = [];
+	const entries = [];
+	const authored = new Map(authoredSources(state.snapshot).map((source) => [source.sourcePath, source]));
+	const published = new Map(publishedSources(state.snapshot).map((source) => [source.sourcePath, source]));
+	const now = yield* DateTime.now;
+	let created = 0;
+	let updated = 0;
+	let publishedCount = 0;
+	let unchanged = 0;
+	for (const source of input.sources) {
+		if (seen.has(source.sourcePath)) return yield* new ContentTransferConflict({ message: `Duplicate source path: ${source.sourcePath}` });
+		seen.add(source.sourcePath);
+		const current = currentByPath.get(source.sourcePath);
+		const shouldPublish = input.publish && source.published;
+		const action = !current ? "create" : current.markdown !== source.markdown ? input.overwrite ? "update" : "conflict" : shouldPublish && current.publishedVersion !== current.version ? "publish" : "unchanged";
+		entries.push({
+			sourcePath: source.sourcePath,
+			action,
+			currentRevisionId: current?.revisionId ?? null
+		});
+		if (action === "create" || action === "update") {
+			const documentId = current?.documentId ?? DocumentId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
+			if (current) {
+				commitPlans.push({
+					action: "document.update",
+					documentId,
+					expectedVersion: current.version,
+					markdown: source.markdown,
+					publish: shouldPublish,
+					publishedVersion: current.publishedVersion,
+					sourcePath: source.sourcePath
+				});
+				updated++;
+			} else {
+				commitPlans.push({
+					action: "document.create",
+					documentId,
+					markdown: source.markdown,
+					publish: shouldPublish,
+					sourcePath: source.sourcePath
+				});
+				created++;
+			}
+			if (shouldPublish) publishedCount++;
+			authored.set(source.sourcePath, {
+				documentId,
+				draft: !shouldPublish,
+				markdown: source.markdown,
+				sourcePath: source.sourcePath
+			});
+			if (shouldPublish) published.set(source.sourcePath, {
+				documentId,
+				draft: false,
+				markdown: source.markdown,
+				publishedAt: now,
+				sourcePath: source.sourcePath
+			});
+		} else if (action === "publish" && current) {
+			commitPlans.push({
+				action: "document.publish",
+				documentId: current.documentId,
+				expectedVersion: current.version,
+				markdown: current.markdown,
+				revisionId: current.revisionId,
+				sourcePath: current.sourcePath
+			});
+			publishedCount++;
+			authored.set(source.sourcePath, {
+				documentId: current.documentId,
+				draft: false,
+				markdown: current.markdown,
+				sourcePath: current.sourcePath
+			});
+			published.set(source.sourcePath, {
+				documentId: current.documentId,
+				draft: false,
+				markdown: current.markdown,
+				publishedAt: now,
+				sourcePath: current.sourcePath
+			});
+		} else if (action === "unchanged") unchanged++;
+	}
+	const firstPath = input.sources[0]?.sourcePath;
+	const authoredValidation = firstPath ? yield* validateDocumentSources(engine, [...authored.values()], firstPath, state.authored) : DocumentValidationResult.make({
+		issues: [],
+		valid: true
+	});
+	const publishedValidation = input.publish && firstPath ? yield* validateDocumentSources(engine, [...published.values()], firstPath, 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: [...published.values()],
+		commitPlans,
+		counts: {
+			created,
+			updated,
+			published: publishedCount,
+			unchanged
+		}
+	};
+});
+
+//#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,
+		mediaReferences: input.plans.flatMap((candidate) => projectMediaReferences(input.authored, input.published, candidate.documentId))
+	});
+});
+/** 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: source.locale
+				}
+			});
+		}
+	}
+	const prepared = yield* prepareDocumentMutation(dependencies, current, command);
+	if (command.action === "document.move" && Predicate.isTagged("Commit")(prepared)) {
+		for (const plan of prepared.additionalPlans ?? []) if (plan.action === "document.update") yield* accessControl.require({
+			actor: activity.actor,
+			requestId: activity.requestId
+		}, {
+			action: "document.update",
+			resource: {
+				kind: "document",
+				documentId: plan.documentId
+			}
+		});
+	}
+	if (command.action === "document.undelete" && 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: plan.documentId
+		}
+	});
+	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
+	});
+	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 }))
+	};
+});
+
+//#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
+}) {};
+
+//#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 itemsByKey = /* @__PURE__ */ new Map();
+	const orderByItem = /* @__PURE__ */ new Map();
+	for (const document of candidates) {
+		if (document.key === "/") {
+			const item = navigationItem(document);
+			roots.push(item);
+			orderByItem.set(item, Number.NEGATIVE_INFINITY);
+			continue;
+		}
+		const segments = document.key.slice(1).split("/");
+		let parent;
+		for (let index = 0; index < segments.length; index += 1) {
+			const key = PublicPath.make(`/${segments.slice(0, index + 1).join("/")}`);
+			let item = itemsByKey.get(key);
+			if (!item) {
+				item = {
+					children: [],
+					key,
+					title: titleFromSegment(segments[index] ?? "")
+				};
+				itemsByKey.set(key, item);
+				if (parent) parent.children.push(item);
+				else roots.push(item);
+			}
+			if (index === segments.length - 1) {
+				const resolved = navigationItem(document);
+				item.title = resolved.title;
+				item.path = resolved.path;
+				if (resolved.locale !== void 0) item.locale = resolved.locale;
+				else delete item.locale;
+				item.documentId = resolved.documentId;
+				orderByItem.set(item, navigationOrder(document));
+			}
+			parent = item;
+		}
+	}
+	sortNavigation(roots, orderByItem);
+	return roots.map((item) => DocumentNavigationItem.make(item));
+}
+function navigationItem(document) {
+	const navigation = document.data.navigation;
+	const configuredTitle = Schema.is(Schema.JsonObject)(navigation) ? navigation.title : void 0;
+	return Object.assign({
+		children: [],
+		documentId: document.id,
+		key: document.key,
+		path: document.path,
+		title: Schema.is(Schema.String)(configuredTitle) && configuredTitle.trim() ? configuredTitle.trim() : document.title
+	}, document.locale === void 0 ? void 0 : { locale: document.locale });
+}
+function navigationOrder(document) {
+	const navigation = document.data.navigation;
+	const order = (Schema.is(Schema.JsonObject)(navigation) ? navigation.order : void 0) ?? document.data.order;
+	return Schema.is(Schema.Finite)(order) ? order : Number.POSITIVE_INFINITY;
+}
+function sortNavigation(items, orderByItem) {
+	items.sort((left, right) => {
+		return (orderByItem.get(left) ?? Number.POSITIVE_INFINITY) - (orderByItem.get(right) ?? Number.POSITIVE_INFINITY) || left.title.localeCompare(right.title);
+	});
+	items.forEach((item) => sortNavigation(item.children, orderByItem));
+}
+function documentField(document, field) {
+	switch (field) {
+		case "collection": return document.collection;
+		case "description": return document.description;
+		case "id": return document.id;
+		case "key": return document.key;
+		case "locale": return document.locale;
+		case "path": return document.path;
+		case "source.path": return document.source.path;
+		case "title": return document.title;
+		default: return nestedValue(document.data, field.startsWith("data.") ? field.slice(5) : field);
+	}
+}
+function nestedValue(value, path) {
+	return path.split(".").reduce((current, segment) => {
+		if (!Schema.is(Schema.JsonObject)(current)) return void 0;
+		return current[segment];
+	}, value);
+}
+function matchesValue(actual, expected) {
+	const expectedValues = Array.isArray(expected) ? expected : [expected];
+	return (Array.isArray(actual) ? actual : [actual]).some((value) => Schema.is(DocumentQueryScalar)(value) && expectedValues.includes(value));
+}
+function sortDocuments(documents, sorts) {
+	return documents.toSorted((left, right) => {
+		for (const sort of sorts) {
+			const comparison = compareValues(documentField(left, sort.field), documentField(right, sort.field));
+			if (comparison !== 0) return sort.direction === "desc" ? -comparison : comparison;
+		}
+		return 0;
+	});
+}
+function compareValues(left, right) {
+	if (left === right) return 0;
+	if (left === void 0 || left === null) return 1;
+	if (right === void 0 || right === null) return -1;
+	if (Schema.is(Schema.Finite)(left) && Schema.is(Schema.Finite)(right)) return left - right;
+	const leftText = Schema.is(Schema.String)(left) ? left : JSON.stringify(left) ?? "";
+	const rightText = Schema.is(Schema.String)(right) ? right : JSON.stringify(right) ?? "";
+	return leftText.localeCompare(rightText);
+}
+function titleFromSegment(segment) {
+	return segment.replace(/[-_]+/gu, " ").replace(/^./u, (character) => character.toUpperCase());
+}
+
+//#endregion
+//#region ../server/src/internal/documents/documents.ts
+const isDocumentGenerationConflict = 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,
+		repository,
+		components: options.components
+	};
+	const refreshUnlocked = Effect.fn("Documents.refreshUnlocked")(function* (force = false) {
+		const current = yield* Ref.get(state);
+		const snapshot = force ? yield* loadRequired(repository) : yield* repository.load(current.snapshot.generation);
+		if (!snapshot || !generationIsAfter(snapshot.generation, current.snapshot.generation)) return current.snapshot.generation;
+		const refreshed = yield* compileDocumentState(engine, snapshot, current);
+		yield* Ref.set(state, refreshed);
+		return refreshed.snapshot.generation;
+	});
+	const executeUnlocked = Effect.fn("Documents.execute")(function* (command, activity) {
+		return yield* Effect.gen(function* () {
+			yield* refreshUnlocked();
+			const current = yield* Ref.get(state);
+			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));
+		return yield* runMutation({
+			action: "document.create",
+			documentId,
+			markdown: source.markdown,
+			sourcePath: plan.sourcePath
+		}, 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: 1,
+			sources: current.snapshot.active.map((source) => ({
+				sourcePath: source.sourcePath,
+				markdown: source.markdown,
+				published: source.publishedVersion === source.version
+			})).sort((left, right) => left.sourcePath.localeCompare(right.sourcePath))
+		});
+	}))));
+	const contentPlan = (context, input) => requireContentTransfer(context).pipe(Effect.andThen(semaphore.withPermits(1)(Effect.gen(function* () {
+		yield* refreshUnlocked();
+		return (yield* planContentTransfer(engine, 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, 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")
+		}).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({
+			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 resolveWith = (document, snapshot) => CompiledDocument.make(Object.assign({}, document, { resolvedSeo: resolveDocumentSeo({
+		capabilities: snapshot.capabilities,
+		document,
+		global: snapshot.revision.settings
+	}) }));
+	const publishedDocument = Effect.fn("SeoDelivery.publishedDocument")((document) => published.read.pipe(Effect.map((snapshot) => resolveWith(document, snapshot))));
+	const previewDocument = Effect.fn("SeoDelivery.previewDocument")((document) => previews.read.pipe(Effect.map((snapshot) => resolveWith(document, snapshot))));
+	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, client),
+		promote: (input) => promoteObject(options.bucket, input, client),
+		put: (input) => putObject(options.bucket, input, client),
+		remove: (objectKey) => providerRequest("MediaObjectStore.S3.remove", client.deleteObject({
+			bucket: options.bucket,
+			key: objectKey
+		})),
+		stat: (objectKey) => statObject(options.bucket, objectKey, client)
+	};
+}
+function promoteObject(bucket, input, client) {
+	if (input.byteSize > 5e9) return Effect.fail(storageError("MediaObjectStore.S3.promote", "The object exceeds the S3 single-copy size limit."));
+	return statObject(bucket, input.sourceObjectKey, client).pipe(Effect.flatMap((source) => Option.isSome(source) && source.value.byteSize === input.byteSize && source.value.mimeType === input.mimeType ? Effect.void : Effect.fail(storageError("MediaObjectStore.S3.promote.source", "The staged object metadata does not match its intent."))), Effect.flatMap(() => providerRequest("MediaObjectStore.S3.promote.copy", client.copyObject({
+		bucket,
+		cacheControl: replaceableMediaCacheControl,
+		contentType: input.mimeType,
+		copySource: copySource(bucket, input.sourceObjectKey),
+		key: input.destinationObjectKey
+	}))), Effect.flatMap(() => statObject(bucket, input.destinationObjectKey, client)), Effect.flatMap((destination) => Option.isSome(destination) && destination.value.byteSize === input.byteSize && destination.value.mimeType === input.mimeType ? Effect.succeed(destination.value) : Effect.fail(storageError("MediaObjectStore.S3.promote.verify", "The promoted object metadata does not match its intent."))));
+}
+function copySource(bucket, objectKey) {
+	return `/${encodeURIComponent(bucket)}/${objectKey.split("/").map(encodeURIComponent).join("/")}`;
+}
+function putObject(bucket, input, client) {
+	return Effect.gen(function* () {
+		const body = yield* validatedWriteBody(input);
+		yield* client.putObject({
+			body,
+			bucket,
+			cacheControl: replaceableMediaCacheControl,
+			contentLength: input.byteSize,
+			contentType: input.mimeType,
+			key: input.objectKey
+		}).pipe(Effect.catch((failure) => isWriteBodyError(failure.cause) ? Effect.fail(failure.cause) : Effect.fail(providerError("MediaObjectStore.S3.put", failure))));
+		return {
+			byteSize: input.byteSize,
+			mimeType: input.mimeType,
+			objectKey: input.objectKey
+		};
+	});
+}
+const validatedWriteBody = Effect.fn("MediaObjectStore.S3.validateWriteBody")(function* (input) {
+	const byteLength = yield* Ref.make(0);
+	return input.body.pipe(Stream.mapEffect((chunk) => Effect.gen(function* () {
+		if ((yield* Ref.updateAndGet(byteLength, (current) => current + chunk.byteLength)) > input.byteSize) return yield* storageError("MediaObjectStore.S3.put.body", "The object body exceeds its declared byte size.");
+		return chunk;
+	})), Stream.concat(Stream.fromEffect(Ref.get(byteLength).pipe(Effect.flatMap((actual) => actual === input.byteSize ? Effect.void : Effect.fail(storageError("MediaObjectStore.S3.put.body", "The object body does not match its declared byte size."))))).pipe(Stream.drain)));
+});
+function statObject(bucket, objectKey, client) {
+	return client.headObject({
+		bucket,
+		key: objectKey
+	}).pipe(Effect.matchEffect({
+		onFailure: (failure) => isMissingObject(failure.cause) ? Effect.succeed(Option.none()) : Effect.fail(providerError("MediaObjectStore.S3.stat", failure)),
+		onSuccess: (output) => decodeStoredObject("MediaObjectStore.S3.stat", objectKey, output.contentLength, output.contentType).pipe(Effect.asSome)
+	}));
+}
+function listObjects(bucket, client) {
+	return Stream.paginate({ seenTokens: /* @__PURE__ */ new Set() }, (state) => providerRequest("MediaObjectStore.S3.list", client.listObjects({
+		bucket,
+		continuationToken: state.continuationToken,
+		prefix: mediaObjectPrefix
+	})).pipe(Effect.flatMap((page) => Effect.gen(function* () {
+		return [yield* Effect.forEach(page.objects, decodeListedObject), yield* nextListState(state, page)];
+	}))));
+}
+function decodeListedObject(object) {
+	if (object.key === void 0) return Effect.fail(storageError("MediaObjectStore.S3.list", "The provider returned object metadata without a key."));
+	return decodeStoredObject("MediaObjectStore.S3.list", object.key, object.size);
+}
+function nextListState(state, page) {
+	if (!page.isTruncated) return Effect.succeedNone;
+	const token = page.nextContinuationToken;
+	if (!token || token === state.continuationToken || state.seenTokens.has(token)) return Effect.fail(storageError("MediaObjectStore.S3.list", "The provider returned an invalid continuation token."));
+	return Effect.succeedSome({
+		continuationToken: token,
+		seenTokens: /* @__PURE__ */ new Set([...state.seenTokens, token])
+	});
+}
+function decodeStoredObject(operation, objectKey, byteSize, contentType) {
+	const decodedObjectKey = Schema.decodeOption(MediaObjectKey)(objectKey);
+	const decodedByteSize = Schema.decodeUnknownOption(MediaByteSize)(byteSize);
+	if (Option.isNone(decodedObjectKey) || Option.isNone(decodedByteSize)) return Effect.fail(storageError(operation, "The provider returned invalid object metadata."));
+	const decodedMimeType = Schema.decodeUnknownOption(ImageMimeType)(contentType);
+	const storedObject = {
+		byteSize: decodedByteSize.value,
+		objectKey: decodedObjectKey.value
+	};
+	return Effect.succeed(Option.isSome(decodedMimeType) ? {
+		...storedObject,
+		mimeType: decodedMimeType.value
+	} : storedObject);
+}
+function providerRequest(operation, request) {
+	return request.pipe(Effect.mapError((failure) => providerError(operation, failure)));
+}
+function provisionBucket(options, client) {
+	if (!options.provisionBucket) return Effect.void;
+	return client.headBucket({ bucket: options.bucket }).pipe(Effect.catch((failure) => isMissingBucket(failure.cause) ? createMissingBucket(options, client) : Effect.fail(providerError("MediaObjectStore.S3.bucket.head", failure))));
+}
+function createMissingBucket(options, client) {
+	return client.createBucket({
+		bucket: options.bucket,
+		locationConstraint: options.endpoint || options.region === "us-east-1" ? void 0 : options.region
+	}).pipe(Effect.catch((failure) => isBucketAlreadyOwned(failure.cause) ? providerRequest("MediaObjectStore.S3.bucket.verify", client.headBucket({ bucket: options.bucket })) : Effect.fail(providerError("MediaObjectStore.S3.bucket.create", failure))));
+}
+const ProviderFailureDetails = Schema.Struct({
+	$metadata: Schema.optionalKey(Schema.Struct({
+		attempts: Schema.optionalKey(Schema.Finite),
+		httpStatusCode: Schema.optionalKey(Schema.Finite)
+	})),
+	name: Schema.optionalKey(Schema.String)
+});
+const decodeProviderFailure = Schema.decodeUnknownOption(ProviderFailureDetails);
+function providerError(operation, failure) {
+	const details = decodeProviderFailure(failure.cause);
+	const diagnostics = [];
+	if (Option.isSome(details)) {
+		if (details.value.name) diagnostics.push(`name=${details.value.name}`);
+		if (details.value.$metadata?.httpStatusCode !== void 0) diagnostics.push(`status=${details.value.$metadata.httpStatusCode}`);
+		if (details.value.$metadata?.attempts !== void 0) diagnostics.push(`attempts=${details.value.$metadata.attempts}`);
+	}
+	return storageError(operation, `The S3 provider request failed${diagnostics.length > 0 ? ` (${diagnostics.join(", ")}).` : "."}`);
+}
+function isMissingObject(cause) {
+	const details = decodeProviderFailure(cause);
+	if (Option.isNone(details)) return false;
+	return details.value.name === "NoSuchKey" || details.value.name === "NotFound";
+}
+function isMissingBucket(cause) {
+	const details = decodeProviderFailure(cause);
+	if (Option.isNone(details)) return false;
+	return details.value.name === "NoSuchBucket" || details.value.$metadata?.httpStatusCode === 404;
+}
+function isBucketAlreadyOwned(cause) {
+	const details = decodeProviderFailure(cause);
+	return Option.isSome(details) && details.value.name === "BucketAlreadyOwnedByYou";
+}
+function resolveOptions(options) {
+	const bucket = options.bucket.trim();
+	const region = options.region.trim();
+	const endpoint = options.endpoint?.trim();
+	if (!bucket || !region || options.endpoint !== void 0 && !endpoint) return Effect.fail(storageError("MediaObjectStore.S3.configure", "The bucket, region, and configured endpoint must be non-empty."));
+	if (options.credentials) {
+		const secretAccessKey = Redacted.value(options.credentials.secretAccessKey);
+		const sessionToken = options.credentials.sessionToken && Redacted.value(options.credentials.sessionToken);
+		if (!options.credentials.accessKeyId.trim() || !secretAccessKey || sessionToken === "") return Effect.fail(storageError("MediaObjectStore.S3.configure", "The configured credentials must be non-empty."));
+	}
+	return Effect.succeed({
+		...options,
+		bucket,
+		credentials: options.credentials ? {
+			...options.credentials,
+			accessKeyId: options.credentials.accessKeyId.trim()
+		} : void 0,
+		endpoint,
+		forcePathStyle: options.forcePathStyle ?? false,
+		provisionBucket: options.provisionBucket ?? false,
+		region
+	});
+}
+function storageError(operation, message) {
+	return new MediaStorageError({
+		cause: new Error(message),
+		operation
+	});
+}
+
+//#endregion
+//#region ../s3/src/S3MediaObjects.ts
+const maxS3SingleCopyBytes = 5e9;
+
+//#endregion
+export { DocumentRevision as $, StudioBadRequest as A, User as B, DocumentStore as C, CurrentStudioRequest as D, defaultAccessControlLayer as E, studioInternalError as F, UserSelfRemovalDenied as G, UserAlreadyExists as H, InitializationAlreadyCompleted as I, CollaborationServerMessage as J, UserSelfRoleChangeDenied as K, InitializationProofInvalid as L, StudioRequestConflict as M, StudioSchemaError as N, StudioApi as O, StudioInternalError as P, DocumentHistoryInvalidCursor as Q, InitializationState as R, DocumentPersistenceError as S, AccessControl as T, UserNotFound as U, UserAdministrationDenied as V, UserPage as W, StateVector as X, CollaborationTicket as Y, DocumentHistoryComparisonTooLarge as Z, Documents as _, mediaObjectPrefix as a, ActivityEntry as at, cursorCodec as b, Seo as c, ActivityPage as ct, seoDeliveryLayer as d, DocumentMediaUnavailable as dt, ACTIVITY_ACTIONS as et, seoLayer as f, DocumentNotFound as ft, DocumentPreviews as g, PublishedDocumentNotFound as gt, DocumentMaintenance as h, DocumentVersionConflict as ht, MediaObjectStore as i, ActivityCursorInvalid as it, StudioBootstrap as j, StudioAuthentication as k, SeoDelivery as l, ActivityTarget as lt, SeoStore as m, DocumentValidationFailed as mt, s3MediaObjectStoreLayer as n, ActivityContext as nt, PreviewSeo as o, ActivityEntryDraft as ot, SeoPersistenceError as p, DocumentPathConflict as pt, CollaborationClientMessage as q, MediaPersistenceError as r, ActivityCursor as rt, PublishedSeo as s, ActivityId as st, maxS3SingleCopyBytes as t, ActivityAction as tt, makeDefaultSeoOptions as u, ActivityTargetKind as ut, PublishedDocuments as v, renderEditorMarkdown as w, DocumentGenerationConflict as x, documentsLayer as y, CreateUserInput as z };
+//# sourceMappingURL=S3MediaObjects-CpPSzJto.js.map