@phtngyn/cms 0.1.0-beta.0

package/src/StudioHttp-BTLLooh0.js

@@ -0,0 +1,916 @@
+import { o as STUDIO_API_PATH } from "./HttpPaths-86qLGB90.js";
+import { A as RestoreDocumentInput, B as DocumentVersion, C as MoveDocumentInput, D as PublishedDocumentQuery, E as PublishedDocumentPage, F as Locale, G as SourcePath, H as PublicPath, K as nonNegativeInt, M as UpdateDocumentInput, O as PublishedDocumentSurroundQuery, P as CollectionName, R as DocumentHistoryCursor, T as PublishedDocumentLookup, U as RevisionId, _ as DocumentSource, b as DocumentSurround, d as DocumentIssue, f as DocumentMutationResult, g as DocumentRevisionAction, i as CreateDocumentInput, j as UndeleteDocumentInput, k as RemoveDocumentInput, m as DocumentNavigationQuery, n as CmsMarkdownDocument, o as DeletedDocument, p as DocumentNavigationItem, r as CompiledDocument, s as DocumentBrowseQuery, w as PublishDocumentInput, x as DocumentValidationResult, y as DocumentSummary, z as DocumentId } from "./models-Citx8jBi.js";
+import { c as PreviewSession, d as PreviewSessionInvalid, f as PreviewSessionRequest, i as PreviewDraftRequest, l as PreviewSessionAccess, m as RequestId, o as PreviewInvalidation, r as PreviewDraftNotFound } from "./models-DS5ClMsH.js";
+import { n as DocumentConfiguration, r as MediaConfiguration, t as ComponentDefinition } from "./Configuration-BGYFD2N1.js";
+import { Context, Schema } from "effect";
+import { Multipart } from "effect/unstable/http";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+
+//#region ../protocol/src/Media.ts
+/**
+* Media wire models. Search pages are newest-first with opaque continuation cursors; only ready
+* assets are public results, and names, folders, and object keys are validated path-safe values.
+*/
+const hasUnsafeMediaCharacter = (value) => {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (character === "\\" || codePoint !== void 0 && (codePoint <= 31 || codePoint === 127)) return true;
+	}
+	return false;
+};
+const isSafeMediaPath = (value, allowEmpty) => {
+	if (value.length === 0) return allowEmpty;
+	if (value !== value.trim() || value.startsWith("/") || value.endsWith("/") || hasUnsafeMediaCharacter(value)) return false;
+	return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+};
+const safeMediaFolder = Schema.makeFilter((value) => isSafeMediaPath(value, true), { expected: "a provider-relative media folder without traversal segments" });
+const safeMediaObjectKey = Schema.makeFilter((value) => isSafeMediaPath(value, false), { expected: "a non-empty provider-relative media object key without traversal segments" });
+const safeMediaName = Schema.makeFilter((value) => value.length > 0 && value.length <= 255 && value === value.trim() && value !== "." && value !== ".." && !value.includes("/") && !hasUnsafeMediaCharacter(value), { expected: "a safe media file name of at most 255 characters" });
+const MediaId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("MediaId"));
+const MediaFolder = Schema.String.check(Schema.isMaxLength(512), safeMediaFolder).pipe(Schema.brand("MediaFolder"));
+const MediaObjectKey = Schema.String.check(Schema.isMaxLength(1024), safeMediaObjectKey).pipe(Schema.brand("MediaObjectKey"));
+const MediaName = Schema.String.check(safeMediaName).pipe(Schema.brand("MediaName"));
+const MediaCursor = Schema.NonEmptyString.pipe(Schema.brand("MediaCursor"));
+const ImageMimeType = Schema.Literals([
+	"image/avif",
+	"image/gif",
+	"image/jpeg",
+	"image/png",
+	"image/webp"
+]);
+const MediaStatus = Schema.Literals([
+	"uploading",
+	"ready",
+	"deleting"
+]);
+const MediaByteSize = Schema.Int.check(Schema.isGreaterThan(0));
+const MediaAsset = Schema.Struct({
+	kind: Schema.tag("image"),
+	id: MediaId,
+	objectKey: MediaObjectKey,
+	url: Schema.NonEmptyString,
+	name: MediaName,
+	folder: MediaFolder,
+	mimeType: ImageMimeType,
+	byteSize: MediaByteSize,
+	createdAt: Schema.DateTimeUtcFromString,
+	updatedAt: Schema.DateTimeUtcFromString,
+	status: MediaStatus
+}).annotate({ identifier: "MediaAsset" });
+const MediaUpload = Schema.Struct({
+	name: MediaName,
+	folder: Schema.optionalKey(MediaFolder),
+	declaredMimeType: Schema.optionalKey(Schema.NonEmptyString),
+	declaredByteSize: MediaByteSize
+}).annotate({ identifier: "MediaUpload" });
+const MediaQuery = Schema.Struct({
+	cursor: Schema.optionalKey(MediaCursor),
+	folder: Schema.optionalKey(MediaFolder),
+	search: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(200))),
+	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 100
+	})))
+}).annotate({ identifier: "MediaQuery" });
+const ReadyMediaAssets = Schema.Array(MediaAsset).check(Schema.makeFilter((assets) => assets.every((asset) => asset.status === "ready"), { expected: "media assets whose lifecycle status is ready" }));
+const MediaPage = Schema.Struct({
+	assets: ReadyMediaAssets,
+	folders: Schema.Array(MediaFolder),
+	nextCursor: Schema.optionalKey(MediaCursor),
+	total: nonNegativeInt
+}).annotate({ identifier: "MediaPage" });
+const MediaReference = Schema.Struct({
+	documentId: DocumentId,
+	path: PublicPath,
+	sourcePath: SourcePath,
+	objectKey: MediaObjectKey,
+	nodePath: Schema.Array(nonNegativeInt)
+}).annotate({ identifier: "MediaReference" });
+const MediaObjectMismatch = Schema.Struct({
+	asset: MediaAsset,
+	storedByteSize: MediaByteSize,
+	storedMimeType: Schema.optionalKey(ImageMimeType)
+}).annotate({ identifier: "MediaObjectMismatch" });
+const MediaIntegrityReport = Schema.Struct({
+	missingAssets: Schema.Array(MediaReference),
+	missingObjects: Schema.Array(MediaAsset),
+	mismatchedObjects: Schema.Array(MediaObjectMismatch),
+	orphanedObjectKeys: Schema.Array(MediaObjectKey),
+	unusedAssets: Schema.Array(MediaAsset)
+}).annotate({ identifier: "MediaIntegrityReport" });
+const MediaCleanupReport = Schema.Struct({ removedObjectKeys: Schema.Array(MediaObjectKey) }).annotate({ identifier: "MediaCleanupReport" });
+var MediaNotFound = class extends Schema.TaggedError()("Media.NotFound", { mediaId: MediaId }) {};
+var MediaReferenced = class extends Schema.TaggedError()("Media.Referenced", {
+	mediaId: MediaId,
+	references: Schema.Array(MediaReference)
+}) {};
+var MediaConflict = class extends Schema.TaggedError()("Media.Conflict", { mediaId: MediaId }) {};
+var MediaInvalid = class extends Schema.TaggedError()("Media.Invalid", { message: Schema.NonEmptyString }) {};
+var MediaTooLarge = class extends Schema.TaggedError()("Media.TooLarge", {
+	declaredByteSize: MediaByteSize,
+	maxUploadBytes: MediaByteSize
+}) {};
+
+//#endregion
+//#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/AccessControl.ts
+/** Wire-visible Studio actors, request identity, roles, access decisions, and denials. */
+const ROLES = [
+	"administrator",
+	"editor",
+	"viewer"
+];
+const Role = Schema.Literals(ROLES);
+const StudioActor = Schema.Struct({
+	id: Schema.NonEmptyString,
+	email: Schema.NonEmptyString,
+	name: Schema.NonEmptyString,
+	roles: Schema.Array(Schema.NonEmptyString)
+}).annotate({ identifier: "StudioActor" });
+const StudioRequestContext = Schema.Struct({
+	actor: StudioActor,
+	requestId: RequestId
+}).annotate({ identifier: "StudioRequestContext" });
+const DOCUMENT_ACTIONS = [
+	"document.browse",
+	"document.read",
+	"document.trash",
+	"document.validate",
+	"document.create",
+	"document.update",
+	"document.move",
+	"document.remove",
+	"document.restore",
+	"document.undelete",
+	"document.publish",
+	"document.history"
+];
+const DocumentAction = Schema.Literals(DOCUMENT_ACTIONS);
+const DocumentCatalogResource = Schema.Struct({ kind: Schema.tag("catalog") });
+const CollectionResource = Schema.Struct({
+	kind: Schema.tag("collection"),
+	collection: CollectionName,
+	locale: Schema.optionalKey(Locale)
+});
+const DocumentResource = Schema.Struct({
+	kind: Schema.tag("document"),
+	documentId: DocumentId
+});
+const DocumentAccessResource = Schema.Union([
+	DocumentCatalogResource,
+	CollectionResource,
+	DocumentResource
+]).pipe(Schema.toTaggedUnion("kind"));
+const DocumentAccessDecision = Schema.Struct({
+	action: DocumentAction,
+	resource: DocumentAccessResource
+}).annotate({ identifier: "DocumentAccessDecision" });
+const MEDIA_ACTIONS = [
+	"media.read",
+	"media.search",
+	"media.integrity",
+	"media.upload",
+	"media.replace",
+	"media.remove",
+	"media.cleanup"
+];
+const MediaAction = Schema.Literals(MEDIA_ACTIONS);
+const MediaCatalogResource = Schema.Struct({ kind: Schema.tag("media-catalog") });
+const MediaAssetResource = Schema.Struct({
+	kind: Schema.tag("media-asset"),
+	mediaId: MediaId
+});
+const MediaFolderResource = Schema.Struct({
+	kind: Schema.tag("media-folder"),
+	folder: MediaFolder
+});
+const MediaResource = Schema.Union([
+	MediaCatalogResource,
+	MediaAssetResource,
+	MediaFolderResource
+]).pipe(Schema.toTaggedUnion("kind"));
+const MediaAccessDecision = Schema.Struct({
+	action: MediaAction,
+	resource: MediaResource
+}).annotate({ identifier: "MediaAccessDecision" });
+const ActivityResource = Schema.Struct({ kind: Schema.tag("activity") });
+const ActivityAccessDecision = Schema.Struct({
+	action: Schema.Literal("activity.read"),
+	resource: ActivityResource
+}).annotate({ identifier: "ActivityAccessDecision" });
+const STUDIO_ACTIONS = [
+	...DOCUMENT_ACTIONS,
+	...MEDIA_ACTIONS,
+	"activity.read"
+];
+const StudioAction = Schema.Literals(STUDIO_ACTIONS);
+const StudioResource = Schema.Union([
+	DocumentAccessResource,
+	MediaResource,
+	ActivityResource
+]);
+const StudioAccessDecision = Schema.Union([
+	DocumentAccessDecision,
+	MediaAccessDecision,
+	ActivityAccessDecision
+]);
+var AuthenticationRequired = class extends Schema.TaggedError()("Studio.AuthenticationRequired", {}) {};
+var StudioEntryDenied = class extends Schema.TaggedError()("Studio.EntryDenied", {}) {};
+var AccessDenied = class extends Schema.TaggedError()("Studio.AccessDenied", {
+	action: StudioAction,
+	actorId: StudioActor.fields.id,
+	resource: StudioResource
+}) {};
+
+//#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",
+	"media.uploaded",
+	"media.replaced",
+	"media.removed",
+	"media.cleaned",
+	"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("user"),
+		userId: Schema.NonEmptyString
+	})
+]).pipe(Schema.toTaggedUnion("kind"));
+const ActivityTargetKind = Schema.Literals([
+	"document",
+	"media",
+	"media-library",
+	"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({
+	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
+/** Exclusive first-installation claim input, state, and caller-visible rejection failures. */
+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 InvalidPreviewSession$1 = PreviewSessionInvalid.pipe(HttpApiSchema.status(401));
+const PreviewDraftMissing = PreviewDraftNotFound.pipe(HttpApiSchema.status(404));
+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]
+})).prefix("/delivery");
+const PreviewDeliveryApi = HttpApiGroup.make("previewDelivery").add(HttpApiEndpoint.post("resolve", "/preview/resolve", {
+	payload: PreviewDraftRequest,
+	success: CompiledDocument,
+	error: [
+		InvalidPreviewSession$1,
+		PreviewDraftMissing,
+		InternalError$1
+	]
+}), HttpApiEndpoint.post("invalidations", "/preview/invalidations", {
+	payload: PreviewSessionAccess,
+	success: HttpApiSchema.StreamSse({ data: PreviewInvalidation }),
+	error: [InvalidPreviewSession$1, InternalError$1]
+}));
+
+//#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,
+	components: Schema.Array(ComponentDefinition),
+	documents: DocumentConfiguration,
+	media: MediaConfiguration,
+	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 UpdateDocumentPayload = Schema.Struct({
+	expectedVersion: UpdateDocumentInput.fields.expectedVersion,
+	markdown: UpdateDocumentInput.fields.markdown
+});
+const MoveDocumentPayload = Schema.Struct({
+	expectedVersion: MoveDocumentInput.fields.expectedVersion,
+	location: MoveDocumentInput.fields.location
+});
+const PublishDocumentPayload = Schema.Struct({ expectedVersion: PublishDocumentInput.fields.expectedVersion });
+const RemoveDocumentPayload = Schema.Struct({ expectedVersion: RemoveDocumentInput.fields.expectedVersion });
+const RestoreDocumentPayload = Schema.Struct({
+	expectedVersion: RestoreDocumentInput.fields.expectedVersion,
+	revisionId: RestoreDocumentInput.fields.revisionId
+});
+const UndeleteDocumentPayload = Schema.Struct({ expectedVersion: UndeleteDocumentInput.fields.expectedVersion });
+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 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 InvalidPreviewSession = PreviewSessionInvalid.pipe(HttpApiSchema.status(401));
+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: UpdateDocumentPayload,
+	success: DocumentValidationResult,
+	error: [
+		NotFound,
+		VersionConflict,
+		Forbidden,
+		InternalError
+	]
+}), HttpApiEndpoint.post("move", "/:documentId/move", {
+	params: { documentId: DocumentId },
+	payload: MoveDocumentPayload,
+	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 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 StudioPreviewSessionsApi = HttpApiGroup.make("previewSessions").add(HttpApiEndpoint.post("issue", "/preview/sessions", {
+	payload: PreviewSessionRequest,
+	success: PreviewSession.pipe(HttpApiSchema.status(201)),
+	error: [InvalidPreviewSession, 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 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");
+var StudioApi = class extends HttpApi.make("StudioApi").add(InitializationApi, PublishedDeliveryApi, StudioConfigurationApi, StudioSessionApi, StudioDiagnosticsApi, StudioPreviewSessionsApi, PreviewDeliveryApi, StudioDocumentsApi, StudioHistoryApi, StudioActivityApi, StudioUserAdministrationApi, StudioMediaApi, StudioCollaborationApi).middleware(StudioSchemaError).prefix(STUDIO_API_PATH) {};
+
+//#endregion
+export { DocumentVersionConflict as $, ACTIVITY_ACTIONS as A, ActivityTargetKind as B, CollaborationTicket as C, DocumentRevision as D, DocumentHistoryInvalidCursor as E, ActivityEntry as F, Role as G, AuthenticationRequired as H, ActivityEntryDraft as I, StudioRequestContext as J, StudioActor as K, ActivityId as L, ActivityContext as M, ActivityCursor as N, DocumentRevisionComparison as O, ActivityCursorInvalid as P, DocumentValidationFailed as Q, ActivityPage as R, CollaborationServerMessage as S, DocumentHistoryComparisonTooLarge as T, DOCUMENT_ACTIONS as U, AccessDenied as V, MEDIA_ACTIONS as W, DocumentNotFound as X, DocumentMediaUnavailable as Y, DocumentPathConflict as Z, UserNotFound as _, MediaStatus as _t, StudioBootstrap as a, MediaConflict as at, UserSelfRoleChangeDenied as b, StudioInternalError as c, MediaId as ct, InitializationProofInvalid as d, MediaName as dt, PublishedDocumentNotFound as et, InitializationState as f, MediaNotFound as ft, UserAlreadyExists as g, MediaReferenced as gt, UserAdministrationDenied as h, MediaReference as ht, StudioBadRequest as i, MediaCleanupReport as it, ActivityAction as j, DocumentRevisionPage as k, studioInternalError as l, MediaIntegrityReport as lt, User as m, MediaPage as mt, StudioApi as n, MediaAsset as nt, StudioRequestConflict as o, MediaCursor as ot, CreateUserInput as p, MediaObjectKey as pt, StudioEntryDenied as q, StudioAuthentication as r, MediaByteSize as rt, StudioSchemaError as s, MediaFolder as st, CurrentStudioRequest as t, ImageMimeType as tt, InitializationAlreadyCompleted as u, MediaInvalid as ut, UserPage as v, MediaTooLarge as vt, StateVector as w, CollaborationClientMessage as x, UserSelfRemovalDenied as y, MediaUpload as yt, ActivityTarget as z };
+//# sourceMappingURL=StudioHttp-BTLLooh0.js.map