@sudobility/screenwriter_types 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,33 +1,4386 @@
-/**
- * @sudobility/screenwriter_types
- * Shared types and Zod schemas for the Fadewright frontend and backend.
- * Import from the package root only.
- */
-export * from './api/envelope.js';
-export * from './api/pagination.js';
-export * from './api/routes.js';
-export * from './ids/index.js';
-export * from './tenancy/index.js';
-export * from './sharing/index.js';
-export * from './projects/index.js';
-export * from './lifecycle/index.js';
-export * from './me/index.js';
-export * from './account/index.js';
-export * from './templates/index.js';
-export * from './versions/index.js';
-export * from './commands/index.js';
-export * from './formats/index.js';
-export * from './io/index.js';
-export * from './keys/index.js';
-export * from './ai/index.js';
-export * from './jobs/index.js';
-export * from './reads/index.js';
-export * from './reports/index.js';
-export * from './packets/index.js';
-export * from './assets/index.js';
-export * from './collab/index.js';
-export * from './credits/index.js';
-export * from './public/index.js';
-export * from './admin/index.js';
-export * from './sync/index.js';
-export * from './sync/codec.js';
+import { z } from "zod";
+import { DOCUMENT_KINDS } from "@sudobility/writing_core";
+import { DOCUMENT_KINDS as DOCUMENT_KINDS2, ID_PREFIXES, idKind, isId, newId } from "@sudobility/writing_core";
+import { API_KEY_FORMAT_RE, API_KEY_MAX_ACTIVE, API_KEY_SCOPES, CLIENT_HEADER, MCP_CLIENT_NAME, apiKeyCreateSchema, apiKeyScopeSchema, apiKeyUpdateSchema } from "./keys.js";
+const ERROR_TABLE = [
+  ["UNAUTHORIZED", 401],
+  ["REAUTH_REQUIRED", 401],
+  ["API_KEY_FORBIDDEN", 403],
+  ["FORBIDDEN", 403],
+  ["ROLE_ESCALATION", 403],
+  ["NOT_FOUND", 404],
+  ["PROJECT_NOT_FOUND", 404],
+  ["DOCUMENT_NOT_FOUND", 404],
+  ["SNAPSHOT_NOT_FOUND", 404],
+  ["TEMPLATE_NOT_FOUND", 404],
+  ["ITEM_NOT_FOUND", 404],
+  ["ANCHOR_NOT_FOUND", 404],
+  ["TARGET_NOT_FOUND", 404],
+  ["VALIDATION", 400],
+  ["COMMAND_INVALID", 422],
+  ["TEMPLATE_INVALID", 422],
+  ["CONFIRMATION_MISMATCH", 400],
+  ["EPOCH_MISMATCH", 409],
+  ["DOCUMENT_LOCKED", 423],
+  ["DOCUMENT_BUSY", 409],
+  ["JOB_ALREADY_RUNNING", 409],
+  ["JOB_FINISHED", 409],
+  ["JOB_NOT_FINISHED", 409],
+  ["LAST_OWNER", 409],
+  ["ALREADY_MEMBER", 409],
+  ["NOT_A_MEMBER", 409],
+  ["PERSONAL_WORKSPACE_IMMUTABLE", 409],
+  ["OWNS_TEAM_WORKSPACE", 409],
+  ["NOT_IN_TRASH", 409],
+  ["PARENT_IN_TRASH", 409],
+  ["FOLDER_DEPTH", 409],
+  ["FOLDER_CYCLE", 409],
+  ["MOVE_FORBIDDEN", 403],
+  ["BUILTIN_IMMUTABLE", 409],
+  ["LOCATOR_AMBIGUOUS", 409],
+  ["INVITATION_INVALID", 410],
+  ["INVITATION_EXPIRED", 410],
+  ["INVITATION_CLOSED", 410],
+  ["EMAIL_MISMATCH", 403],
+  ["SHARE_LINK_INVALID", 404],
+  ["SHARE_LINK_PASSWORD_REQUIRED", 401],
+  ["WATERMARK_REQUIRED", 403],
+  ["EDIT_WINDOW_CLOSED", 409],
+  ["ASSET_TOO_LARGE", 413],
+  ["IMPORT_TOO_LARGE", 413],
+  ["UNSUPPORTED_FORMAT", 400],
+  ["IMPORT_FAILED", 400],
+  ["IMPORT_INVALID", 422],
+  ["ASSET_TYPE_REJECTED", 415],
+  ["ASSET_CHECKSUM_MISMATCH", 422],
+  ["ASSET_NOT_READY", 409],
+  ["ASSET_IN_USE", 409],
+  ["UPLOAD_INCOMPLETE", 409],
+  ["UPLOAD_EXPIRED", 410],
+  ["STORAGE_QUOTA_EXCEEDED", 507],
+  ["STORAGE_UNAVAILABLE", 503],
+  ["IMPORT_FORMAT_UNSUPPORTED", 415],
+  ["EXPORT_FORMAT_UNSUPPORTED", 415],
+  ["COMPARE_TOO_LARGE", 413],
+  ["LIMIT_EXCEEDED", 409],
+  ["RATE_LIMITED", 429],
+  ["QUOTA_EXCEEDED", 429],
+  ["INSUFFICIENT_CREDITS", 402],
+  ["AI_UNAVAILABLE", 503],
+  ["AI_INPUT_TOO_LARGE", 413],
+  ["AI_GENERATION_FAILED", 502],
+  ["AI_OUTPUT_INVALID", 502],
+  ["CONFIG_MISSING", 503],
+  ["CLIENT_TOO_OLD", 426],
+  ["CONTENT_CHANGED", 409],
+  ["STYLE_NOT_IN_TEMPLATE", 422],
+  ["NOT_CONTIGUOUS", 422],
+  ["LOCKED_CONTENT", 409],
+  ["NAME_COLLISION", 409],
+  ["KIND_MISMATCH", 422],
+  ["OVERLAPPING_SHOTS", 422],
+  ["OVERLAPPING_NODE", 422],
+  ["SCENES_LOCKED", 409],
+  ["NOT_LOCKED", 409],
+  ["RANGE_OUT_OF_BOUNDS", 422],
+  ["INVALID_TARGET", 422],
+  ["INVALID_DUAL_DIALOGUE", 422],
+  ["FOUNTAIN_PARSE_ERROR", 422],
+  ["UNMAPPED_STYLES", 422],
+  ["RANGE_TOO_LARGE", 413],
+  ["PAYLOAD_TOO_LARGE", 413],
+  ["INVALID_REGEX", 400],
+  ["REPORT_OPTIONS_INVALID", 400],
+  ["REPORT_KIND_UNAVAILABLE", 501],
+  ["ENTITY_IN_USE", 409],
+  ["VARIANT_IN_USE", 409],
+  ["SNAPSHOT_NOT_IN_DOCUMENT", 404],
+  ["ITEM_NOT_IN_SNAPSHOT", 404],
+  ["INVALID_LOCATOR", 400],
+  ["LOCATOR_NOT_FOUND", 404],
+  ["ROLE_NOT_ALLOWED_FOR_TARGET", 422],
+  ["ID_CONFLICT", 409],
+  ["IDEMPOTENCY_KEY_REUSED", 409],
+  ["IDEMPOTENCY_IN_PROGRESS", 409],
+  ["DEVICE_REVOKED", 403],
+  ["MACRO_TRIGGER_TAKEN", 409],
+  ["STALE_WRITE", 409],
+  ["HANDOFF_INVALID", 410],
+  ["WATERMARK_NOT_FOUND", 404],
+  ["OCR_UNAVAILABLE", 503],
+  ["GRAMMAR_UNAVAILABLE", 503],
+  ["AI_CONSENT_REQUIRED", 403],
+  ["AI_DISABLED_FOR_WORKSPACE", 403],
+  ["AI_EXCLUDED_DOCUMENT", 403],
+  ["AI_KEY_NOT_PERMITTED", 403],
+  ["QUOTE_EXCEEDS_MAX", 402],
+  ["AI_CONTENT_REFUSED", 422],
+  ["SCOPE_TOO_LARGE", 413],
+  ["SUGGESTION_UNAVAILABLE", 409],
+  ["JOB_KIND_DISABLED", 501],
+  ["JOB_KIND_NOT_GENERIC", 400],
+  ["JOB_FAILED", 409],
+  ["JOB_TIMEOUT", 504],
+  ["LIKENESS_CONSENT_REQUIRED", 422],
+  ["CONTENT_REJECTED", 422],
+  ["INTERNAL", 500]
+];
+const API_ERROR_CODES = Object.fromEntries(
+  ERROR_TABLE.map(([code]) => [code, code])
+);
+const ERROR_STATUS = Object.fromEntries(ERROR_TABLE);
+function successResponse(data) {
+  return { success: true, data };
+}
+function errorResponse(message, code, details) {
+  return details === void 0 ? { success: false, error: message, code } : { success: false, error: message, code, details };
+}
+const cursorQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  cursor: z.string().regex(/^[A-Za-z0-9_-]+$/).optional()
+});
+const API_BASE_PATH = "/api/v1";
+const r = (method, path, auth, permission = null) => ({ method, path, auth, permission });
+const API_ROUTES = {
+  // B1
+  health: r("GET", "/health", "P"),
+  meGet: r("GET", "/me", "U,Kr"),
+  mePatch: r("PATCH", "/me", "U"),
+  // B2 workspaces
+  workspacesList: r("GET", "/workspaces", "U,Kr"),
+  workspaceGet: r("GET", "/workspaces/:wid", "U,Kr", "workspace.read"),
+  // B2 projects
+  projectsList: r("GET", "/workspaces/:wid/projects", "U,Kr", "project.read"),
+  projectCreate: r(
+    "POST",
+    "/workspaces/:wid/projects",
+    "U,Krw",
+    "project.create"
+  ),
+  projectGet: r("GET", "/projects/:pid", "U,Kr,L", "project.read"),
+  projectUpdate: r("PATCH", "/projects/:pid", "U,Krw", "project.update"),
+  projectTrash: r("POST", "/projects/:pid/trash", "U,Krw", "project.trash"),
+  projectRestore: r(
+    "POST",
+    "/projects/:pid/restore",
+    "U,Krw",
+    "project.restore"
+  ),
+  // B2 documents
+  documentsList: r(
+    "GET",
+    "/projects/:pid/documents",
+    "U,Kr,L",
+    "document.read"
+  ),
+  documentCreate: r(
+    "POST",
+    "/projects/:pid/documents",
+    "U,Krw",
+    "document.create"
+  ),
+  documentGet: r("GET", "/documents/:did", "U,Kr,L", "document.read"),
+  documentUpdate: r("PATCH", "/documents/:did", "U,Krw", "document.edit"),
+  documentTrash: r("POST", "/documents/:did/trash", "U,Krw", "document.trash"),
+  documentRestore: r(
+    "POST",
+    "/documents/:did/restore",
+    "U,Krw",
+    "document.restore"
+  ),
+  documentState: r("GET", "/documents/:did/state", "U,Kr,L", "document.read"),
+  documentContent: r(
+    "GET",
+    "/documents/:did/content",
+    "U,Kr,L",
+    "document.read"
+  ),
+  // B2 templates
+  templatesList: r("GET", "/templates", "U,Kr"),
+  templateGet: r("GET", "/templates/:tid", "U,Kr"),
+  // B3 sync (WebSocket upgrade, credentials travel in the first `auth` frame)
+  sync: r("GET", "/sync", "P"),
+  // B4 versions and snapshots
+  versionsList: r("GET", "/documents/:did/versions", "U,Kr,L", "document.read"),
+  versionState: r(
+    "GET",
+    "/documents/:did/versions/:vid/state",
+    "U,Kr,L",
+    "document.read"
+  ),
+  versionRestore: r(
+    "POST",
+    "/documents/:did/versions/:vid/restore",
+    "U,Krw",
+    "document.restore"
+  ),
+  versionSnapshot: r(
+    "POST",
+    "/documents/:did/versions/:vid/snapshot",
+    "U,Krw",
+    "snapshot.create"
+  ),
+  snapshotsList: r(
+    "GET",
+    "/documents/:did/snapshots",
+    "U,Kr,L",
+    "snapshot.read"
+  ),
+  snapshotCreate: r(
+    "POST",
+    "/documents/:did/snapshots",
+    "U,Krw",
+    "snapshot.create"
+  ),
+  snapshotGet: r("GET", "/snapshots/:sid", "U,Kr,L", "snapshot.read"),
+  snapshotState: r("GET", "/snapshots/:sid/state", "U,Kr,L", "snapshot.read"),
+  snapshotContent: r(
+    "GET",
+    "/snapshots/:sid/content",
+    "U,Kr,L",
+    "snapshot.read"
+  ),
+  snapshotOpen: r("POST", "/snapshots/:sid/open", "U,Krw", "snapshot.open"),
+  snapshotFork: r("POST", "/snapshots/:sid/fork", "U,Krw", "snapshot.read"),
+  // B15 versions, snapshots and sync completion (spec 05 §6.7.1, §6.9-6.11)
+  elementHistory: r(
+    "GET",
+    "/documents/:did/elements/:elementId/history",
+    "U,Kr",
+    "document.read"
+  ),
+  documentPresence: r(
+    "GET",
+    "/documents/:did/presence",
+    "U,Kr",
+    "document.read"
+  ),
+  versionRestoreAsCopy: r(
+    "POST",
+    "/documents/:did/versions/:vid/restore-as-copy",
+    "U,Krw",
+    "version.restoreAsCopy"
+  ),
+  snapshotPrefs: r("PUT", "/snapshots/:sid/prefs", "U", "snapshot.hideForSelf"),
+  snapshotNotesList: r(
+    "GET",
+    "/snapshots/:sid/notes",
+    "U,Kr,L",
+    "snapshot.read"
+  ),
+  snapshotNoteCreate: r(
+    "POST",
+    "/snapshots/:sid/notes",
+    "U,Krw",
+    "snapshot.appendNote"
+  ),
+  snapshotCommentsList: r(
+    "GET",
+    "/snapshots/:sid/comments",
+    "U,Kr,L",
+    "snapshot.read"
+  ),
+  snapshotCommentCreate: r(
+    "POST",
+    "/snapshots/:sid/comments",
+    "U,L",
+    "document.comment"
+  ),
+  snapshotCommentCopyToLive: r(
+    "POST",
+    "/snapshot-comments/:cid/copy-to-live",
+    "U",
+    "document.edit"
+  ),
+  snapshotCommentResolve: r(
+    "POST",
+    "/snapshot-comments/:cid/resolve",
+    "U",
+    "document.comment"
+  ),
+  documentCompare: r(
+    "POST",
+    "/documents/:did/compare",
+    "U,Kr,L",
+    "snapshot.read"
+  ),
+  // Import and export (synchronous, no jobs)
+  documentImport: r(
+    "POST",
+    "/projects/:pid/documents/import",
+    "U,Krw",
+    "document.create"
+  ),
+  documentExport: r("POST", "/documents/:did/export", "U,Kr", "document.read"),
+  formatsList: r("GET", "/formats", "U,Kr"),
+  // B5 commands and reads
+  commands: r("POST", "/documents/:did/commands", "U,Krw", "document.edit"),
+  outline: r("GET", "/documents/:did/outline", "U,Kr,L", "document.read"),
+  scene: r("GET", "/documents/:did/scenes/:sceneId", "U,Kr,L", "document.read"),
+  scenesBatch: r(
+    "POST",
+    "/documents/:did/scenes/batch",
+    "U,Kr,L",
+    "document.read"
+  ),
+  elementsBatch: r(
+    "POST",
+    "/documents/:did/elements/batch",
+    "U,Kr,L",
+    "document.read"
+  ),
+  // B6 personal API keys (user principals only; a key gets 403 API_KEY_FORBIDDEN)
+  apiKeysList: r("GET", "/api-keys", "U"),
+  apiKeyCreate: r("POST", "/api-keys", "U", "apiKeys.use"),
+  apiKeyUpdate: r("PATCH", "/api-keys/:kid", "U"),
+  apiKeyRevoke: r("DELETE", "/api-keys/:kid", "U"),
+  // B7 AI: script review and polish. Keys need the `ai` flag (403 AI_KEY_NOT_PERMITTED) and, to start
+  // jobs or decide suggestions, read_write scope.
+  aiStatus: r("GET", "/ai/status", "U,Kr"),
+  aiJobCreate: r("POST", "/documents/:did/ai/jobs", "U,Krw", "ai.run"),
+  aiJobsList: r("GET", "/documents/:did/ai/jobs", "U,Kr", "document.read"),
+  aiJobGet: r("GET", "/ai/jobs/:jobId", "U,Kr", "document.read"),
+  aiJobCancel: r("POST", "/ai/jobs/:jobId/cancel", "U,Krw", "ai.review"),
+  aiSuggestionSetsList: r(
+    "GET",
+    "/documents/:did/ai/suggestion-sets",
+    "U,Kr",
+    "document.read"
+  ),
+  aiSuggestionSetGet: r(
+    "GET",
+    "/ai/suggestion-sets/:ssid",
+    "U,Kr",
+    "document.read"
+  ),
+  aiSuggestionSetAccept: r(
+    "POST",
+    "/ai/suggestion-sets/:ssid/accept",
+    "U,Krw",
+    "document.edit"
+  ),
+  aiSuggestionSetReject: r(
+    "POST",
+    "/ai/suggestion-sets/:ssid/reject",
+    "U,Krw",
+    "document.edit"
+  ),
+  // B8 tenancy, roles, sharing. Keys (K) only read members and /me/shared; everything else is user-only (403 API_KEY_FORBIDDEN).
+  workspaceCreate: r("POST", "/workspaces", "U"),
+  workspaceUpdate: r("PATCH", "/workspaces/:wid", "U", "workspace.update"),
+  workspaceDelete: r("DELETE", "/workspaces/:wid", "U", "workspace.delete"),
+  workspaceTransfer: r(
+    "POST",
+    "/workspaces/:wid/transfer",
+    "U",
+    "workspace.transfer"
+  ),
+  workspaceLeave: r("POST", "/workspaces/:wid/leave", "U", "workspace.leave"),
+  workspaceUsage: r("GET", "/workspaces/:wid/usage", "U", "workspace.read"),
+  workspaceAudit: r(
+    "GET",
+    "/workspaces/:wid/audit.csv",
+    "U",
+    "workspace.audit"
+  ),
+  membersList: r("GET", "/workspaces/:wid/members", "U,Kr", "members.read"),
+  memberUpdate: r(
+    "PATCH",
+    "/workspaces/:wid/members/:uid",
+    "U",
+    "members.updateRole"
+  ),
+  memberRemove: r(
+    "DELETE",
+    "/workspaces/:wid/members/:uid",
+    "U",
+    "members.remove"
+  ),
+  invitationCreateWorkspace: r(
+    "POST",
+    "/workspaces/:wid/invitations",
+    "U",
+    "members.invite"
+  ),
+  invitationCreateProject: r(
+    "POST",
+    "/projects/:pid/invitations",
+    "U",
+    "share.manage"
+  ),
+  invitationCreateDocument: r(
+    "POST",
+    "/documents/:did/invitations",
+    "U",
+    "share.manage"
+  ),
+  workspaceInvitationsList: r(
+    "GET",
+    "/workspaces/:wid/invitations",
+    "U",
+    "members.invite"
+  ),
+  myInvitations: r("GET", "/me/invitations", "U"),
+  invitationRenew: r("POST", "/invitations/:iid/renew", "U"),
+  invitationCancel: r("DELETE", "/invitations/:iid", "U"),
+  invitationAccept: r("POST", "/invitations/accept", "U"),
+  invitationDecline: r("POST", "/invitations/:iid/decline", "U"),
+  sharedWithMe: r("GET", "/me/shared", "U,Kr"),
+  documentLock: r("POST", "/documents/:did/lock", "U", "document.lock"),
+  documentUnlock: r("DELETE", "/documents/:did/lock", "U", "document.lock"),
+  documentUnlockSession: r(
+    "POST",
+    "/documents/:did/unlock-session",
+    "U",
+    "document.read"
+  ),
+  shareLinkCreateDocument: r(
+    "POST",
+    "/documents/:did/share-links",
+    "U",
+    "share.manage"
+  ),
+  shareLinkCreateProject: r(
+    "POST",
+    "/projects/:pid/share-links",
+    "U",
+    "share.manage"
+  ),
+  shareLinkCreateSnapshot: r(
+    "POST",
+    "/snapshots/:sid/share-links",
+    "U",
+    "share.manage"
+  ),
+  shareLinksListDocument: r(
+    "GET",
+    "/documents/:did/share-links",
+    "U",
+    "share.manage"
+  ),
+  shareLinksListProject: r(
+    "GET",
+    "/projects/:pid/share-links",
+    "U",
+    "share.manage"
+  ),
+  shareLinkUpdate: r("PATCH", "/share-links/:lid", "U", "share.manage"),
+  shareLinkRevoke: r("DELETE", "/share-links/:lid", "U", "share.manage"),
+  grantsListDocument: r("GET", "/documents/:did/grants", "U", "share.manage"),
+  grantsListProject: r("GET", "/projects/:pid/grants", "U", "share.manage"),
+  grantUpdate: r("PATCH", "/grants/:gid", "U", "share.manage"),
+  grantRemove: r("DELETE", "/grants/:gid", "U", "share.manage"),
+  // B8 public link routes: the token in the path is the credential; an optional Bearer is a user or a link session (`fls_`).
+  publicShareResolve: r("GET", "/public/share/:token", "P"),
+  shareUnlock: r("POST", "/share/:token/unlock", "P"),
+  shareState: r("GET", "/share/:token/state", "P,L", "document.read"),
+  // B9 generic jobs (spec 05 §6.19). Jobs are visible to their owner, or to anyone who can read the job's document;
+  // cancel, outputs and recipients are owner-only. `/ai/jobs*` stays as the AI facade over the same rows.
+  jobsList: r("GET", "/jobs", "U,Kr", "document.read"),
+  jobGet: r("GET", "/jobs/:jobId", "U,Kr,L", "document.read"),
+  jobCreate: r("POST", "/jobs", "U,Krw", "document.read"),
+  jobCancel: r("POST", "/jobs/:jobId/cancel", "U,Krw", "document.read"),
+  jobOutputs: r("GET", "/jobs/:jobId/outputs", "U,K,L", "document.export"),
+  jobRecipients: r("GET", "/jobs/:jobId/recipients", "U", "document.export"),
+  // Provider webhook: unauthenticated, HMAC-signed with JOB_WEBHOOK_SECRET_<ADAPTER> (fails closed: 401 when unset).
+  jobWebhook: r("POST", "/webhooks/jobs/:adapterId", "W"),
+  // B10 projection-backed reads, search, reports, packets (spec 05 §6.7.1, §6.7.2, §6.12, §6.14, §6.15, §6.17, §6.18, §6.22).
+  // `?source=live|snapshot:<id>|version:<id>` selects the state a read answers from. Keys (K) read all of these; the report
+  // and resolve POSTs are reads, so a read-only key may send them.
+  entitiesList: r("GET", "/documents/:did/entities", "U,Kr,L", "document.read"),
+  entityGet: r(
+    "GET",
+    "/documents/:did/entities/:eid",
+    "U,Kr,L",
+    "document.read"
+  ),
+  entityUsage: r(
+    "GET",
+    "/documents/:did/entities/:eid/usage",
+    "U,Kr,L",
+    "document.read"
+  ),
+  entityDialogue: r(
+    "GET",
+    "/documents/:did/entities/:eid/dialogue",
+    "U,Kr,L",
+    "document.read"
+  ),
+  tagCategoriesList: r(
+    "GET",
+    "/documents/:did/tag-categories",
+    "U,Kr,L",
+    "document.read"
+  ),
+  tagsList: r("GET", "/documents/:did/tags", "U,Kr,L", "document.read"),
+  notesList: r("GET", "/documents/:did/notes", "U,Kr,L", "document.read"),
+  beatsList: r("GET", "/documents/:did/beats", "U,Kr,L", "document.read"),
+  binList: r("GET", "/documents/:did/bin", "U,Kr,L", "document.read"),
+  revisionsGet: r(
+    "GET",
+    "/documents/:did/revisions",
+    "U,Kr,L",
+    "document.read"
+  ),
+  changesList: r("GET", "/documents/:did/changes", "U,Kr,L", "document.read"),
+  alternatesGet: r(
+    "GET",
+    "/documents/:did/alternates/:elementId",
+    "U,Kr,L",
+    "document.read"
+  ),
+  titlePageGet: r(
+    "GET",
+    "/documents/:did/title-page",
+    "U,Kr,L",
+    "document.read"
+  ),
+  statsGet: r("GET", "/documents/:did/stats", "U,Kr,L", "document.read"),
+  fountainGet: r("GET", "/documents/:did/fountain", "U,Kr,L", "document.read"),
+  sceneShotsList: r(
+    "GET",
+    "/documents/:did/scenes/:sceneId/shots",
+    "U,Kr,L",
+    "document.read"
+  ),
+  resolveBatch: r("POST", "/documents/:did/resolve", "U,Kr,L", "document.read"),
+  resolveOne: r("GET", "/documents/:did/resolve", "U,Kr,L", "document.read"),
+  documentSearch: r("GET", "/documents/:did/search", "U,Kr,L", "document.read"),
+  workspaceSearch: r(
+    "GET",
+    "/workspaces/:wid/search",
+    "U,Kr",
+    "workspace.read"
+  ),
+  search: r("GET", "/search", "U,Kr"),
+  reportKinds: r("GET", "/reports/kinds", "U,Kr"),
+  reportGet: r("GET", "/documents/:did/reports/:kind", "U,Kr,L", "reports.run"),
+  reportCreate: r("POST", "/documents/:did/reports", "U,Kr,L", "reports.run"),
+  packetScene: r(
+    "GET",
+    "/documents/:did/packets/scene/:locator",
+    "U,Kr",
+    "document.read"
+  ),
+  packetCharacter: r(
+    "GET",
+    "/documents/:did/packets/character/:locator",
+    "U,Kr",
+    "document.read"
+  ),
+  packetLocation: r(
+    "GET",
+    "/documents/:did/packets/location/:locator",
+    "U,Kr",
+    "document.read"
+  ),
+  packetShot: r(
+    "GET",
+    "/documents/:did/packets/shot/:locator",
+    "U,Kr",
+    "document.read"
+  ),
+  // B13 account and per-user data (spec 05 §6.1, §6.1.1, §6.26). User-only (a key gets 403 API_KEY_FORBIDDEN) except the macro list (Kr).
+  meDictionaryGet: r("GET", "/me/dictionary", "U"),
+  meDictionaryUpdate: r("PUT", "/me/dictionary", "U"),
+  mePreferencesGet: r("GET", "/me/preferences", "U"),
+  mePreferencesSet: r("PUT", "/me/preferences", "U"),
+  meMacrosList: r("GET", "/me/macros", "U,Kr"),
+  meMacroCreate: r("POST", "/me/macros", "U"),
+  meMacroUpdate: r("PATCH", "/me/macros/:mid", "U"),
+  meMacroDelete: r("DELETE", "/me/macros/:mid", "U"),
+  meWritingStats: r("GET", "/me/writing-stats", "U"),
+  meWritingSessionCreate: r("POST", "/me/writing-sessions", "U"),
+  meWritingGoalsGet: r("GET", "/me/writing-goals", "U"),
+  meWritingGoalsSet: r("PUT", "/me/writing-goals", "U"),
+  meExport: r("POST", "/me/export", "U"),
+  meDelete: r("DELETE", "/me", "U"),
+  meRestore: r("POST", "/me/restore", "U"),
+  documentMyStateGet: r(
+    "GET",
+    "/documents/:did/my-state",
+    "U",
+    "document.read"
+  ),
+  documentMyStateSet: r(
+    "PUT",
+    "/documents/:did/my-state",
+    "U",
+    "document.read"
+  ),
+  documentStar: r("PUT", "/documents/:did/star", "U", "document.read"),
+  documentUnstar: r("DELETE", "/documents/:did/star", "U", "document.read"),
+  // B14 project, document and template lifecycle, workspace settings (spec 05 §6.2, §6.6-§6.8, §6.26). Writes are `Krw`; purge,
+  // trash-empty, workspace defaults and contacts are user-only (a key gets 403 API_KEY_FORBIDDEN).
+  workspaceDocuments: r(
+    "GET",
+    "/workspaces/:wid/documents",
+    "U,Kr",
+    "project.read"
+  ),
+  workspaceTrash: r("GET", "/workspaces/:wid/trash", "U,Kr", "project.read"),
+  workspaceTrashEmpty: r(
+    "POST",
+    "/workspaces/:wid/trash/empty",
+    "U",
+    "project.purge"
+  ),
+  projectPurge: r("DELETE", "/projects/:pid", "U", "project.purge"),
+  projectDuplicate: r(
+    "POST",
+    "/projects/:pid/duplicate",
+    "U,Krw",
+    "project.create"
+  ),
+  projectFolderCreate: r(
+    "POST",
+    "/projects/:pid/folders",
+    "U,Krw",
+    "project.update"
+  ),
+  projectFolderUpdate: r(
+    "PATCH",
+    "/project-folders/:fid",
+    "U,Krw",
+    "project.update"
+  ),
+  projectFolderDelete: r(
+    "DELETE",
+    "/project-folders/:fid",
+    "U,Krw",
+    "project.update"
+  ),
+  documentMove: r("POST", "/documents/:did/move", "U,Krw", "document.move"),
+  documentPurge: r("DELETE", "/documents/:did", "U", "project.purge"),
+  documentDuplicate: r(
+    "POST",
+    "/documents/:did/duplicate",
+    "U,Krw",
+    "document.create"
+  ),
+  documentApplyTemplate: r(
+    "POST",
+    "/documents/:did/template",
+    "U,Krw",
+    "document.lock"
+  ),
+  templateCreate: r("POST", "/templates", "U,Krw", "templates.manage"),
+  templateVersionCreate: r(
+    "POST",
+    "/templates/:tid/versions",
+    "U,Krw",
+    "templates.manage"
+  ),
+  templateUpdate: r("PATCH", "/templates/:tid", "U,Krw", "templates.manage"),
+  templateDelete: r("DELETE", "/templates/:tid", "U,Krw", "templates.manage"),
+  templateImport: r("POST", "/templates/import", "U,Krw", "templates.manage"),
+  templateExport: r("GET", "/templates/:tid/export", "U,Kr"),
+  projectBinList: r("GET", "/projects/:pid/bin", "U,Kr", "project.read"),
+  projectBinCreate: r("POST", "/projects/:pid/bin", "U,Krw", "document.edit"),
+  projectBinDelete: r(
+    "DELETE",
+    "/project-bin-items/:id",
+    "U,Krw",
+    "document.edit"
+  ),
+  workspaceDefaultsGet: r(
+    "GET",
+    "/workspaces/:wid/defaults",
+    "U,Kr",
+    "workspace.read"
+  ),
+  workspaceDefaultsSet: r(
+    "PUT",
+    "/workspaces/:wid/defaults",
+    "U",
+    "workspace.update"
+  ),
+  workspaceContactsList: r(
+    "GET",
+    "/workspaces/:wid/contacts",
+    "U",
+    "workspace.read"
+  ),
+  workspaceContactsCreate: r(
+    "POST",
+    "/workspaces/:wid/contacts",
+    "U",
+    "workspace.update"
+  ),
+  workspaceContactUpdate: r(
+    "PATCH",
+    "/workspace-contacts/:cid",
+    "U",
+    "workspace.update"
+  ),
+  workspaceContactDelete: r(
+    "DELETE",
+    "/workspace-contacts/:cid",
+    "U",
+    "workspace.update"
+  ),
+  // B16 imports, exports and watermark as jobs (spec 05 §6.18). `POST /imports*` and `/uploads/state` are `Krw`; exports are `Kr` (a read key may
+  // export what it can read); the watermark lookup is user-only (403 API_KEY_FORBIDDEN for a key). The synchronous
+  // `documentImport`/`documentExport`/`formatsList` stay until the app moves to these (see the plan's B16 "Deferred" list).
+  uploadState: r("POST", "/uploads/state", "U,Krw"),
+  importCreate: r("POST", "/imports", "U,Krw", "document.create"),
+  importStart: r("POST", "/imports/:importId/start", "U,Krw"),
+  documentImportOver: r(
+    "POST",
+    "/documents/:did/import-over",
+    "U,Krw",
+    "document.edit"
+  ),
+  documentExportCreate: r(
+    "POST",
+    "/documents/:did/exports",
+    "U,Kr",
+    "document.export"
+  ),
+  documentExportCombined: r(
+    "POST",
+    "/documents/export-combined",
+    "U,Kr",
+    "document.export"
+  ),
+  watermarkLookup: r(
+    "POST",
+    "/workspaces/:wid/watermark-lookup",
+    "U",
+    "workspace.audit"
+  ),
+  // B11 assets and R2 (spec 05 §6.13). Bytes go to object storage through presigned URLs, never through the API. Writes are `Krw`, reads `Kr`;
+  // share-link readers (`L`) are not built (no `/share/:token/assets` route yet). The uploader routes check the caller is the uploader.
+  assetUploadCreate: r(
+    "POST",
+    "/workspaces/:wid/assets/uploads",
+    "U,Krw",
+    "assets.upload"
+  ),
+  assetUploadGet: r("GET", "/assets/uploads/:uploadId", "U,Krw"),
+  assetUploadParts: r("POST", "/assets/uploads/:uploadId/parts", "U,Krw"),
+  assetUploadComplete: r("POST", "/assets/uploads/:uploadId/complete", "U,Krw"),
+  assetUploadAbort: r("DELETE", "/assets/uploads/:uploadId", "U,Krw"),
+  assetsList: r("GET", "/assets", "U,Kr", "assets.read"),
+  assetGet: r("GET", "/assets/:aid", "U,Kr", "assets.read"),
+  assetUrl: r("GET", "/assets/:aid/versions/:vid/url", "U,Kr", "assets.read"),
+  assetUpdate: r("PATCH", "/assets/:aid", "U,Krw", "assets.upload"),
+  assetDelete: r("DELETE", "/assets/:aid", "U,Krw", "assets.upload"),
+  assetRestore: r("POST", "/assets/:aid/restore", "U,Krw", "assets.upload"),
+  assetLinkCreate: r("POST", "/asset-links", "U,Krw", "assets.link"),
+  documentAssetLinks: r(
+    "GET",
+    "/documents/:did/asset-links",
+    "U,Kr",
+    "assets.read"
+  ),
+  assetLinkUpdate: r("PATCH", "/asset-links/:lid", "U,Krw", "assets.link"),
+  assetLinkDelete: r("DELETE", "/asset-links/:lid", "U,Krw", "assets.link"),
+  documentStaleness: r(
+    "GET",
+    "/documents/:did/staleness",
+    "U,Kr",
+    "document.read"
+  ),
+  assetLinkStaleness: r(
+    "GET",
+    "/asset-links/:lid/staleness",
+    "U,Kr",
+    "assets.read"
+  ),
+  // B12 collaboration, notifications, devices, email (spec 05 §6.15, §6.16, §6.24, §6.26). Most of this slice is
+  // user-only (a key gets 403 API_KEY_FORBIDDEN): personal notifications and devices, and chat/activity writes are
+  // never for a key. `documentChatList` and `documentActivity` are the two exceptions (`Kr`, a read key may read them).
+  meNotificationPrefsGet: r("GET", "/me/notification-prefs", "U"),
+  meNotificationPrefsSet: r("PUT", "/me/notification-prefs", "U"),
+  documentMentionsWithoutAccess: r(
+    "GET",
+    "/documents/:did/mentions-without-access",
+    "U",
+    "share.manage"
+  ),
+  documentChatList: r("GET", "/documents/:did/chat", "U,Kr,L", "document.chat"),
+  documentChatCreate: r("POST", "/documents/:did/chat", "U,L", "document.chat"),
+  chatMessageUpdate: r("PATCH", "/chat-messages/:mid", "U", "document.chat"),
+  chatMessageDelete: r("DELETE", "/chat-messages/:mid", "U", "document.chat"),
+  documentActivity: r(
+    "GET",
+    "/documents/:did/activity",
+    "U,Kr",
+    "document.activity"
+  ),
+  workspaceActivity: r(
+    "GET",
+    "/workspaces/:wid/activity",
+    "U",
+    "workspace.read"
+  ),
+  notificationsList: r("GET", "/notifications", "U"),
+  notificationsRead: r("POST", "/notifications/read", "U"),
+  notificationDelete: r("DELETE", "/notifications/:nid", "U"),
+  notificationsStream: r("GET", "/notifications/stream", "U"),
+  devicesList: r("GET", "/devices", "U"),
+  deviceCreate: r("POST", "/devices", "U"),
+  deviceUpdate: r("PATCH", "/devices/:devid", "U"),
+  deviceRevoke: r("POST", "/devices/:devid/revoke", "U"),
+  devicePushTokenSet: r("PUT", "/devices/:devid/push-token", "U"),
+  devicePushTokenDelete: r("DELETE", "/devices/:devid/push-token", "U"),
+  // B17 AI completion and credits (spec 05 §6.3, §6.19, §6.20, §6.21; spec 06 §9-10). AI routes need the key's `ai`
+  // flag (403 AI_KEY_NOT_PERMITTED); `decide` needs read_write. Consent, activity and credits are user-only except
+  // the balance/products reads (Kr; a key spends its own workspace's credits so it may read them) — `consumables/products`
+  // is also public (unauthenticated pricing display). `GET .../suggestion-sets` and `GET /suggestion-sets/:ssid` are
+  // already built (B7, under `/ai/` — kept as-is rather than duplicated at the bare path spec 05 Appendix A also lists).
+  meAiConsentGet: r("GET", "/me/ai-consents", "U"),
+  meAiConsentAccept: r("POST", "/me/ai-consents", "U"),
+  meAiActivity: r("GET", "/me/ai-activity", "U"),
+  workspaceAiActivity: r(
+    "GET",
+    "/workspaces/:wid/ai-activity",
+    "U",
+    "workspace.audit"
+  ),
+  aiEstimate: r("POST", "/documents/:did/ai/estimate", "U,Kr", "document.read"),
+  aiReportsList: r(
+    "GET",
+    "/documents/:did/ai/reports",
+    "U,Kr",
+    "document.read"
+  ),
+  aiReportGet: r(
+    "GET",
+    "/documents/:did/ai/reports/:jobId",
+    "U,Kr",
+    "document.read"
+  ),
+  aiReportNoteConvert: r(
+    "POST",
+    "/documents/:did/ai/reports/:jobId/notes/:noteId/convert",
+    "U,Krw",
+    "document.comment"
+  ),
+  aiSuggestionSetDecide: r(
+    "POST",
+    "/ai/suggestion-sets/:ssid/decide",
+    "U,Krw",
+    "document.edit"
+  ),
+  consumablesBalance: r("GET", "/consumables/balance", "U,Kr"),
+  consumablesPurchases: r("GET", "/consumables/purchases", "U"),
+  consumablesUsages: r("GET", "/consumables/usages", "U"),
+  consumablesProducts: r("GET", "/consumables/products", "U,Kr,P"),
+  consumablesWebhook: r("POST", "/consumables/webhook", "W"),
+  purchaseHandoffCreate: r("POST", "/purchases/handoff", "U"),
+  // B18 public, admin, telemetry (spec 05 §6.21, §6.23, §6.24; `/language/*` skipped by decision, see the plan's
+  // B18 note). Public routes need no session at all. Admin needs `siteAdmin` on a USER principal specifically —
+  // never an API key, whatever its scope — enforced in the handler (there is no per-object permission to check).
+  publicTemplatesList: r("GET", "/public/templates", "P"),
+  publicTemplateGet: r("GET", "/public/templates/:builtinKey", "P"),
+  publicConfig: r("GET", "/public/config", "P"),
+  publicNamesDb: r("GET", "/public/names-db/:version", "P"),
+  publicHealthDeep: r("GET", "/public/health/deep", "P"),
+  publicWatermarkedGet: r("GET", "/public/watermarked/:exportId/:token", "P"),
+  purchaseHandoffRedeem: r("POST", "/public/purchases/handoff/redeem", "P"),
+  telemetryCreate: r("POST", "/telemetry", "U,P"),
+  adminUsersLookup: r("GET", "/admin/users", "U"),
+  adminUserRestore: r("POST", "/admin/users/:uid/restore", "U"),
+  adminUserPurge: r("DELETE", "/admin/users/:uid", "U"),
+  adminJobsList: r("GET", "/admin/jobs", "U"),
+  adminJobRetry: r("POST", "/admin/jobs/:id/retry", "U"),
+  adminJobRefund: r("POST", "/admin/jobs/:id/refund", "U"),
+  adminJobKindUpdate: r("PATCH", "/admin/job-kinds/:kind", "U"),
+  adminDocumentMeta: r("GET", "/admin/documents/:did/meta", "U")
+};
+const WORKSPACE_KINDS = ["personal", "team"];
+const ROLES = [
+  "owner",
+  "admin",
+  "writer",
+  "commenter",
+  "viewer"
+];
+const workspaceKindSchema = z.enum(WORKSPACE_KINDS);
+const roleSchema = z.enum(ROLES);
+const PERMISSION_MIN_ROLE = {
+  "workspace.read": "viewer",
+  "workspace.update": "admin",
+  "workspace.aiToggle": "owner",
+  "workspace.audit": "admin",
+  "workspace.delete": "owner",
+  "workspace.transfer": "owner",
+  "workspace.leave": "viewer",
+  "members.read": "viewer",
+  "members.invite": "admin",
+  "members.updateRole": "admin",
+  "members.remove": "admin",
+  "project.create": "writer",
+  "project.read": "viewer",
+  "project.update": "writer",
+  "project.trash": "writer",
+  "project.restore": "writer",
+  "project.purge": "admin",
+  "document.create": "writer",
+  "document.read": "viewer",
+  "document.export": "viewer",
+  "document.edit": "writer",
+  "document.comment": "commenter",
+  "document.chat": "commenter",
+  "document.activity": "viewer",
+  "document.trash": "writer",
+  "document.restore": "writer",
+  "document.move": "writer",
+  "document.lock": "writer",
+  "document.aiExclude": "writer",
+  "snapshot.create": "writer",
+  "snapshot.open": "writer",
+  "snapshot.fork": "writer",
+  "snapshot.cherryPick": "writer",
+  "snapshot.appendNote": "writer",
+  "snapshot.read": "viewer",
+  "snapshot.compare": "viewer",
+  "snapshot.hideForSelf": "viewer",
+  "version.restore": "writer",
+  "version.restoreAsCopy": "writer",
+  "share.manage": "writer",
+  "assets.upload": "writer",
+  "assets.link": "writer",
+  "assets.read": "viewer",
+  "ai.run": "writer",
+  "ai.review": "commenter",
+  "jobs.media": "writer",
+  "templates.manage": "writer",
+  "reports.run": "viewer",
+  "apiKeys.use": "viewer"
+};
+const PERMISSIONS = Object.keys(PERMISSION_MIN_ROLE);
+const RANK = {
+  owner: 0,
+  admin: 1,
+  writer: 2,
+  commenter: 3,
+  viewer: 4
+};
+const roleAtLeast = (a, b) => RANK[a] <= RANK[b];
+function maxRole(...roles) {
+  let best = null;
+  for (const r2 of roles)
+    if (r2 && (best === null || RANK[r2] < RANK[best])) best = r2;
+  return best;
+}
+const minRole = (a, b) => RANK[a] >= RANK[b] ? a : b;
+const ROLE_PERMISSIONS = Object.fromEntries(
+  ROLES.map((role) => [
+    role,
+    PERMISSIONS.filter((p) => roleAtLeast(role, PERMISSION_MIN_ROLE[p]))
+  ])
+);
+const hasPermission = (role, permission) => roleAtLeast(role, PERMISSION_MIN_ROLE[permission]);
+const requiredRoleFor = (permission) => PERMISSION_MIN_ROLE[permission];
+const SHARE_ROLES = ["admin", "writer", "commenter", "viewer"];
+const TEAM_WORKSPACE_LIMIT = 50;
+const workspaceCreateSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  avatarAssetId: z.string().min(1).nullable().optional()
+});
+const workspaceUpdateSchema = z.object({
+  name: z.string().trim().min(1).max(80).optional(),
+  avatarAssetId: z.string().min(1).nullable().optional(),
+  defaultTemplateId: z.string().min(1).nullable().optional(),
+  defaultLanguage: z.string().min(2).max(35).optional(),
+  aiEnabled: z.boolean().optional(),
+  allowPublicLinks: z.boolean().optional()
+});
+const workspaceDeleteSchema = z.object({ confirmName: z.string() });
+const workspaceTransferSchema = z.object({
+  toUserId: z.string().min(1)
+});
+const workspaceAuditQuerySchema = z.object({
+  from: z.iso.datetime({ offset: true }).optional(),
+  to: z.iso.datetime({ offset: true }).optional()
+});
+const AUDIT_CSV_COLUMNS = [
+  "created_at",
+  "actor",
+  "action",
+  "target_type",
+  "target_id",
+  "ip"
+];
+const AUDIT_MAX_RANGE_DAYS = 366;
+const memberUpdateSchema = z.object({ role: roleSchema });
+const INVITATION_TARGETS = ["workspace", "project", "document"];
+const INVITATION_TTL_DAYS = 14;
+const INVITATION_STATUSES = [
+  "pending",
+  "accepted",
+  "declined",
+  "cancelled",
+  "expired"
+];
+const invitationCreateSchema = z.object({
+  email: z.email().max(254),
+  role: roleSchema
+});
+const invitationAcceptSchema = z.object({ token: z.string().min(1) });
+const grantUpdateSchema = z.object({ role: roleSchema });
+const SHARE_LINK_ACCESS = ["view", "comment"];
+const SHARE_LINK_GENERAL_ACCESS = ["anyone", "restricted"];
+const SHARE_LINK_TARGETS = ["project", "document", "snapshot"];
+const SHARE_LINK_TOKEN_PREFIX = "fws_";
+const LINK_SESSION_TTL_S = 900;
+const LINK_SESSION_PREFIX = "fls_";
+const shareLinkCreateSchema = z.object({
+  access: z.enum(SHARE_LINK_ACCESS),
+  generalAccess: z.enum(SHARE_LINK_GENERAL_ACCESS).default("anyone"),
+  expiresAt: z.iso.datetime({ offset: true }).nullable().optional(),
+  password: z.string().min(1).max(200).optional(),
+  allowDownload: z.boolean().default(true),
+  watermarkText: z.string().max(200).nullable().optional()
+});
+const shareLinkUpdateSchema = z.object({
+  access: z.enum(SHARE_LINK_ACCESS).optional(),
+  generalAccess: z.enum(SHARE_LINK_GENERAL_ACCESS).optional(),
+  expiresAt: z.iso.datetime({ offset: true }).nullable().optional(),
+  password: z.string().min(1).max(200).optional(),
+  clearPassword: z.boolean().optional(),
+  allowDownload: z.boolean().optional(),
+  watermarkText: z.string().max(200).nullable().optional()
+}).refine((v) => !(v.password !== void 0 && v.clearPassword), {
+  message: "password and clearPassword are exclusive"
+});
+const shareUnlockSchema = z.object({
+  password: z.string().max(200).optional()
+});
+const UNLOCK_SESSION_TTL_S = 1800;
+const REAUTH_MAX_AGE_S = 300;
+const documentKindSchema = z.enum(DOCUMENT_KINDS);
+const SORT_OPTIONS = ["updated", "name", "created"];
+const PROJECT_KINDS = ["feature", "series", "play", "other"];
+const projectKindSchema = z.enum(PROJECT_KINDS);
+const DOCUMENT_LABELS_MAX = 20;
+const DOCUMENT_LABEL_MAX_CHARS = 40;
+const documentLabelsSchema = z.array(z.string().trim().min(1).max(DOCUMENT_LABEL_MAX_CHARS)).max(DOCUMENT_LABELS_MAX);
+const projectCreateSchema = z.object({
+  name: z.string().trim().min(1).max(200),
+  description: z.string().max(2e3).optional(),
+  coverAssetId: z.string().optional(),
+  color: z.string().max(32).optional(),
+  kind: projectKindSchema.optional(),
+  logline: z.string().max(2e3).optional()
+});
+const projectUpdateSchema = z.object({
+  name: z.string().trim().min(1).max(200).optional(),
+  description: z.string().max(2e3).nullable().optional(),
+  coverAssetId: z.string().nullable().optional(),
+  color: z.string().max(32).nullable().optional(),
+  kind: projectKindSchema.optional(),
+  logline: z.string().max(2e3).nullable().optional(),
+  workspaceId: z.string().optional()
+});
+const projectListQuerySchema = z.object({
+  trashed: z.enum(["true", "false"]).transform((v) => v === "true").optional(),
+  q: z.string().optional(),
+  sort: z.enum(SORT_OPTIONS).optional()
+});
+const documentCreateSchema = z.object({
+  /** Client-generated `doc_...`; creation is idempotent on it. */
+  id: z.string().startsWith("doc_").optional(),
+  title: z.string().trim().min(1).max(200),
+  kind: documentKindSchema,
+  folderId: z.string().optional(),
+  templateId: z.string().optional(),
+  templateVersion: z.number().int().positive().optional(),
+  language: z.string().max(16).optional(),
+  labels: documentLabelsSchema.optional(),
+  season: z.number().int().min(0).max(9999).optional(),
+  episode: z.number().int().min(0).max(99999).optional()
+});
+const documentUpdateSchema = z.object({
+  title: z.string().trim().min(1).max(200).optional(),
+  folderId: z.string().nullable().optional(),
+  position: z.number().optional(),
+  color: z.string().max(32).nullable().optional(),
+  language: z.string().max(16).optional(),
+  logline: z.string().max(2e3).nullable().optional(),
+  excludeFromAi: z.boolean().optional(),
+  labels: documentLabelsSchema.optional(),
+  season: z.number().int().min(0).max(9999).nullable().optional(),
+  episode: z.number().int().min(0).max(99999).nullable().optional()
+});
+const documentListQuerySchema = z.object({
+  trashed: z.enum(["true", "false"]).transform((v) => v === "true").optional(),
+  folderId: z.string().optional(),
+  kind: documentKindSchema.optional(),
+  /** `episode` = `(season, episode)` with unnumbered documents last; the default for a `series` project. */
+  order: z.enum(["position", "episode"]).optional()
+});
+const TRASH_RETENTION_DAYS = 30;
+const FOLDER_MAX_DEPTH = 8;
+const projectFolderCreateSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  parentFolderId: z.string().min(1).optional()
+});
+const projectFolderUpdateSchema = z.object({
+  name: z.string().trim().min(1).max(120).optional(),
+  /** `null` moves the folder to the project root. */
+  parentFolderId: z.string().min(1).nullable().optional(),
+  position: z.number().finite().optional()
+});
+const projectFolderDeleteQuerySchema = z.object({
+  moveContentsTo: z.string().min(1).optional()
+});
+const projectPurgeSchema = z.object({ confirmName: z.string() });
+const projectDuplicateSchema = z.object({
+  name: z.string().trim().min(1).max(200),
+  targetWorkspaceId: z.string().min(1).optional(),
+  includeSnapshots: z.boolean().default(false),
+  /** Re-links the source's asset links onto the copy (B11); a no-op when the target is a different workspace. */
+  includeAssets: z.boolean().default(false)
+});
+const documentMoveSchema = z.object({
+  targetProjectId: z.string().min(1),
+  folderId: z.string().min(1).nullable().optional()
+});
+const documentDuplicateSchema = z.object({
+  title: z.string().trim().min(1).max(200),
+  targetProjectId: z.string().min(1).optional(),
+  includeSnapshots: z.boolean().default(false),
+  includeAssets: z.boolean().default(false)
+});
+const documentApplyTemplateSchema = z.object({
+  templateId: z.string().min(1),
+  templateVersion: z.number().int().min(1).optional(),
+  /** Old style id -> style id of the new template, for styles the new template has no counterpart of. */
+  mapping: z.record(z.string(), z.string()).optional(),
+  dryRun: z.boolean().optional()
+});
+const boolQuery$2 = z.enum(["true", "false"]).transform((v) => v === "true");
+const workspaceDocumentsQuerySchema = cursorQuerySchema.extend({
+  q: z.string().max(200).optional(),
+  kind: documentKindSchema.optional(),
+  trashed: boolQuery$2.optional(),
+  starred: boolQuery$2.optional(),
+  label: z.string().max(40).optional()
+});
+const TRASH_ITEM_TYPES = ["project", "document", "asset"];
+const trashEmptySchema = z.object({ confirm: z.string() });
+const purgeInputSchema = z.object({
+  workspaceId: z.string().optional(),
+  projectId: z.string().optional(),
+  documentId: z.string().optional()
+});
+const PROJECT_BIN_ITEM_MAX_BYTES = 2 * 1024 * 1024;
+const projectBinCreateSchema = z.object({
+  id: z.string().startsWith("bin_").optional(),
+  title: z.string().trim().min(1).max(200).optional(),
+  elements: z.array(z.record(z.string(), z.unknown())).min(1),
+  sourceDocumentId: z.string().min(1).optional()
+});
+const DEFAULT_PROJECT_ROLES = [
+  "admin",
+  "writer",
+  "commenter",
+  "viewer"
+];
+const looseItems = (max2) => z.array(z.looseObject({})).max(max2);
+const workspaceDefaultsSchema = z.object({
+  tagCategories: looseItems(200).default([]),
+  revisionColourSets: looseItems(100).default([]),
+  noteTypes: looseItems(100).default([]),
+  worksheets: looseItems(200).default([]),
+  /** The role newly created projects grant workspace members who have none (F-SET-009). */
+  defaultProjectRole: z.enum(DEFAULT_PROJECT_ROLES).nullable().default(null)
+});
+const WORKSPACE_DEFAULTS_MAX_BYTES = 256 * 1024;
+const workspaceDefaultsPutSchema = workspaceDefaultsSchema.extend({
+  baseUpdatedAt: z.string().min(1)
+});
+const WORKSPACE_CONTACTS_BATCH_MAX = 500;
+const contactFields = {
+  name: z.string().trim().min(1).max(200),
+  company: z.string().trim().max(200).nullable().optional(),
+  email: z.string().trim().max(320).nullable().optional()
+};
+const workspaceContactInputSchema = z.object({
+  id: z.string().startsWith("ctc_").optional(),
+  ...contactFields
+});
+const workspaceContactsCreateSchema = z.object({
+  contacts: z.array(workspaceContactInputSchema).min(1)
+});
+const workspaceContactPatchSchema = z.object({
+  name: contactFields.name.optional(),
+  company: contactFields.company,
+  email: contactFields.email
+});
+const workspaceContactsQuerySchema = cursorQuerySchema.extend({
+  q: z.string().max(200).optional()
+});
+const projectDuplicateJobInputSchema = z.object({
+  projectId: z.string().min(1),
+  name: z.string().min(1),
+  targetWorkspaceId: z.string().min(1),
+  includeSnapshots: z.boolean(),
+  includeAssets: z.boolean()
+});
+const applyTemplateJobInputSchema = z.object({
+  templateId: z.string().min(1),
+  templateVersion: z.number().int().min(1),
+  mapping: z.record(z.string(), z.string()).optional()
+});
+const templateThumbnailInputSchema = z.object({
+  templateId: z.string().min(1),
+  version: z.number().int().min(1)
+});
+const UI_LANGUAGES = [
+  "en",
+  "es",
+  "fr",
+  "de",
+  "pt",
+  "it",
+  "ja",
+  "zh"
+];
+const meUpdateSchema = z.object({
+  displayName: z.string().trim().min(1).max(120).optional(),
+  avatarAssetId: z.string().nullable().optional(),
+  locale: z.string().min(2).max(35).optional(),
+  uiLanguage: z.enum(UI_LANGUAGES).optional(),
+  timeZone: z.string().min(1).max(64).optional()
+});
+const USER_PREFERENCES_VERSION = 1;
+const USER_PREFERENCES_MAX_BYTES = 256 * 1024;
+const AUTOCORRECT_MAX_PAIRS = 5e3;
+const RECENT_SEARCHES_MAX = 20;
+const DEVICE_CLASSES = ["phone", "tablet", "desktop"];
+const section = z.looseObject({});
+const appearanceSchema = z.looseObject({
+  theme: z.enum(["system", "light", "dark"]).optional(),
+  pageTheme: z.enum(["paper", "night", "midnight", "sepia", "custom"]).optional(),
+  custom: section.optional(),
+  density: z.string().max(40).optional(),
+  largeIcons: z.boolean().optional(),
+  reducedMotion: z.boolean().optional()
+});
+const keymapSchema = z.looseObject({
+  preset: z.enum(["fadewright", "finalDraft", "fadeIn"]).optional(),
+  overrides: z.record(z.string(), z.string().nullable()).optional(),
+  byPlatform: section.optional()
+});
+const autocorrectSchema = z.looseObject({
+  options: section.optional(),
+  pairs: z.array(
+    z.object({ from: z.string().min(1).max(200), to: z.string().max(200) })
+  ).max(AUTOCORRECT_MAX_PAIRS).optional()
+});
+const languageSchema = z.looseObject({
+  scriptDefault: z.string().max(35).optional(),
+  installedDictionaries: z.array(z.string().max(35)).max(50).optional(),
+  ignoreLists: section.optional(),
+  lookups: z.array(z.object({ label: z.string().max(80), url: z.string().max(500) })).max(50).optional()
+});
+const tableReadSchema = z.looseObject({
+  narratorVoiceByLanguage: z.record(z.string(), section).optional(),
+  rate: z.number().optional(),
+  actors: z.array(z.looseObject({ id: z.string(), name: z.string() })).max(200).optional()
+});
+const userPreferencesSchema = z.strictObject({
+  version: z.number().int().min(1).max(1e3).default(USER_PREFERENCES_VERSION),
+  appearance: appearanceSchema.optional(),
+  editor: section.optional(),
+  deviceClasses: z.strictObject({
+    phone: section.optional(),
+    tablet: section.optional(),
+    desktop: section.optional()
+  }).optional(),
+  keymap: keymapSchema.optional(),
+  autocorrect: autocorrectSchema.optional(),
+  language: languageSchema.optional(),
+  tableRead: tableReadSchema.optional(),
+  toolbar: section.optional(),
+  recentSearches: z.array(z.string().max(500)).max(RECENT_SEARCHES_MAX).optional(),
+  revisionColourSets: z.array(section).max(100).optional(),
+  offline: section.optional()
+});
+const USER_PREFERENCES_KEYS = [
+  "version",
+  "appearance",
+  "editor",
+  "deviceClasses",
+  "keymap",
+  "autocorrect",
+  "language",
+  "tableRead",
+  "toolbar",
+  "recentSearches",
+  "revisionColourSets",
+  "offline"
+];
+const userPreferencesPutSchema = userPreferencesSchema.extend({
+  baseUpdatedAt: z.string().min(1).max(40)
+});
+const DICTIONARY_MAX_WORDS = 5e4;
+const dictionaryWord = z.string().trim().min(1).max(100);
+const dictionaryUpdateSchema = z.object({
+  add: z.array(dictionaryWord).max(5e3).optional(),
+  remove: z.array(dictionaryWord).max(5e3).optional()
+});
+const USER_MACRO_MAX = 500;
+const MACRO_TRIGGER_KINDS = ["shortcut", "alias"];
+const macroOptionFields = {
+  smartReplace: z.boolean(),
+  confirm: z.boolean(),
+  wordOnly: z.boolean(),
+  matchCase: z.boolean(),
+  activeInStyles: z.array(z.string().max(80)).max(100)
+};
+const macroOptionsSchema = z.object({
+  smartReplace: macroOptionFields.smartReplace.default(false),
+  confirm: macroOptionFields.confirm.default(false),
+  wordOnly: macroOptionFields.wordOnly.default(true),
+  matchCase: macroOptionFields.matchCase.default(false),
+  activeInStyles: macroOptionFields.activeInStyles.default([])
+});
+const macroOptionsPatchSchema = z.object(macroOptionFields).partial();
+const userMacroSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  trigger: z.object({
+    kind: z.enum(MACRO_TRIGGER_KINDS),
+    value: z.string().trim().min(1).max(80)
+  }),
+  insertText: z.string().max(1e4),
+  setElementStyle: z.string().max(80).nullable().optional(),
+  nextElementStyle: z.string().max(80).nullable().optional(),
+  options: macroOptionsSchema.prefault({})
+});
+const userMacroPatchSchema = z.object({
+  name: userMacroSchema.shape.name.optional(),
+  trigger: z.object({
+    kind: z.enum(MACRO_TRIGGER_KINDS).optional(),
+    value: userMacroSchema.shape.trigger.shape.value.optional()
+  }).optional(),
+  insertText: userMacroSchema.shape.insertText.optional(),
+  setElementStyle: userMacroSchema.shape.setElementStyle,
+  nextElementStyle: userMacroSchema.shape.nextElementStyle,
+  options: macroOptionsPatchSchema.optional()
+});
+const WRITING_GOAL_KINDS = [
+  "wordsPerDay",
+  "pagesPerDay",
+  "minutesPerDay",
+  "wordsPerWeek",
+  "documentTarget"
+];
+const WRITING_GOALS_MAX = 50;
+const WRITING_STATS_GRANULARITIES = [
+  "day",
+  "week",
+  "month",
+  "year"
+];
+const isoInstant = z.iso.datetime({ offset: true });
+const writingSessionSchema = z.object({
+  clientSessionId: z.string().min(8).max(64).regex(/^[A-Za-z0-9_-]+$/),
+  documentId: z.string().min(1).max(100).nullable().optional(),
+  startedAt: isoInstant,
+  endedAt: isoInstant,
+  activeSeconds: z.number().int().min(0).max(86400),
+  wordsAdded: z.number().int().min(0).max(1e6),
+  wordsRemoved: z.number().int().min(0).max(1e6),
+  netPagesEighths: z.number().int().min(-1e5).max(1e5),
+  sprint: z.object({
+    targetWords: z.number().int().min(1).max(1e6).optional(),
+    targetMinutes: z.number().int().min(1).max(1440).optional()
+  }).optional()
+}).refine((s) => Date.parse(s.endedAt) >= Date.parse(s.startedAt), {
+  message: "endedAt is before startedAt",
+  path: ["endedAt"]
+});
+const localDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+const writingStatsQuerySchema = z.object({
+  from: localDate.optional(),
+  to: localDate.optional(),
+  granularity: z.enum(WRITING_STATS_GRANULARITIES).default("day"),
+  documentId: z.string().min(1).max(100).optional()
+});
+const writingGoalInputSchema = z.object({
+  id: z.string().min(4).max(64).regex(/^[A-Za-z0-9_-]+$/).optional(),
+  kind: z.enum(WRITING_GOAL_KINDS),
+  documentId: z.string().min(1).max(100).nullable().optional(),
+  target: z.number().int().min(1).max(1e7),
+  daysOfWeek: z.array(z.number().int().min(0).max(6)).max(7).optional(),
+  idleTimeoutSec: z.number().int().min(5).max(3600).optional()
+}).refine((g) => g.kind !== "documentTarget" || !!g.documentId, {
+  message: "documentTarget needs documentId",
+  path: ["documentId"]
+});
+const writingGoalsPutSchema = z.object({
+  goals: z.array(writingGoalInputSchema)
+});
+const ACCOUNT_DELETE_CONFIRM = "DELETE";
+const accountDeleteSchema = z.object({
+  confirm: z.literal(ACCOUNT_DELETE_CONFIRM)
+});
+const accountExportInputSchema = z.object({}).default({});
+const ACCOUNT_EXPORT_FILENAME = "fadewright-export.zip";
+const DOCUMENT_VIEW_STATE_MAX_BYTES = 64 * 1024;
+const deviceViewSchema = z.looseObject({
+  view: z.string().max(40).optional(),
+  zoom: z.number().optional(),
+  invisibles: z.boolean().optional(),
+  ruler: z.boolean().optional()
+});
+const documentViewStateSchema = z.strictObject({
+  navigator: z.looseObject({
+    tabs: z.array(z.looseObject({})).max(50).optional(),
+    activeTab: z.string().max(80).nullable().optional()
+  }).optional(),
+  layout: z.looseObject({
+    split: z.union([z.string().max(40), z.number(), z.null()]).optional(),
+    panes: z.array(z.unknown()).max(20).optional()
+  }).optional(),
+  views: z.strictObject({
+    phone: deviceViewSchema.optional(),
+    tablet: deviceViewSchema.optional(),
+    desktop: deviceViewSchema.optional()
+  }).optional()
+});
+const documentViewStatePutSchema = documentViewStateSchema.extend({
+  baseUpdatedAt: z.string().min(1).max(40).nullable().optional()
+});
+const templateListQuerySchema = z.object({
+  category: z.string().optional(),
+  workspaceId: z.string().optional(),
+  scope: z.enum(["builtin", "user", "workspace"]).optional()
+});
+const templateGetQuerySchema = z.object({
+  version: z.coerce.number().int().min(1).optional()
+});
+const templateBody = z.custom(
+  (v) => typeof v === "object" && v !== null && !Array.isArray(v),
+  {
+    message: "template must be an object"
+  }
+);
+const templateCreateSchema = z.object({
+  scope: z.enum(["user", "workspace"]),
+  workspaceId: z.string().min(1).optional(),
+  template: templateBody
+}).refine((v) => v.scope !== "workspace" || !!v.workspaceId, {
+  message: "workspaceId is required for a workspace template",
+  path: ["workspaceId"]
+});
+const templateVersionCreateSchema = z.object({ template: templateBody });
+const templateUpdateSchema = z.object({
+  name: z.string().trim().min(1).max(120).optional(),
+  description: z.string().max(2e3).nullable().optional(),
+  category: z.string().min(1).max(40).optional()
+});
+const TEMPLATE_FILE_FORMATS = [
+  "fwtemplate",
+  "fadein-template",
+  "fdxt"
+];
+const FWTEMPLATE_FORMAT = "fadewright-template";
+const FWTEMPLATE_FORMAT_VERSION = 1;
+const templateImportSchema = z.object({
+  scope: z.enum(["user", "workspace"]),
+  workspaceId: z.string().min(1).optional(),
+  filename: z.string().min(1).max(255),
+  contentB64: z.string().min(1)
+}).refine((v) => v.scope !== "workspace" || !!v.workspaceId, {
+  message: "workspaceId is required for a workspace template",
+  path: ["workspaceId"]
+});
+const templateImportByIdSchema = z.object({
+  importId: z.string().min(1)
+});
+const templateExportQuerySchema = z.object({
+  format: z.enum(["fwtemplate", "json", "fadein-template", "fdxt"]).default("fwtemplate"),
+  version: z.coerce.number().int().min(1).optional()
+});
+const SNAPSHOT_AUTO_REASONS = [
+  "pre-ai-polish",
+  "pre-import",
+  "pre-template",
+  "pre-open",
+  "pre-restore",
+  "pre-cherry-pick-bulk",
+  "pre-clear-revisions",
+  "pre-delete-revision-set",
+  "pre-unlock-all-pages",
+  "pre-bulk-change-decision",
+  "pre-account-transfer",
+  "offline-edits",
+  "access-revoked"
+];
+const CLIENT_AUTO_REASONS = ["offline-edits", "access-revoked"];
+const SNAPSHOT_KINDS = ["manual", "auto"];
+const VERSION_REASONS = [
+  "interval",
+  "session-end",
+  "pre-epoch",
+  "pre-restore",
+  "daily",
+  "reconnect"
+];
+const snapshotCreateSchema = z.object({
+  /** Idempotency key, unique per document. */
+  clientSnapshotId: z.string().min(1).max(64).optional(),
+  name: z.string().trim().min(1).max(120),
+  note: z.string().max(2e3).optional(),
+  kind: z.enum(SNAPSHOT_KINDS).optional(),
+  autoReason: z.enum(SNAPSHOT_AUTO_REASONS).optional(),
+  sourceEpoch: z.number().int().min(0).optional(),
+  assumedParentId: z.string().nullable().optional(),
+  createdAt: z.string().optional(),
+  createdOnDevice: z.string().max(200).optional(),
+  /**
+   * Client-provided state for offline creation (spec 03 §10.2, spec 05 §6.11): exactly what the writer saw, uploaded through
+   * `POST /uploads/state`. With it, `sourceEpoch` may be older than the live epoch (an offline-edits snapshot after an epoch bump).
+   */
+  state: z.object({ uploadKey: z.string().min(1).max(128) }).optional()
+});
+const snapshotOpenSchema = z.object({
+  confirm: z.literal(true),
+  dryRun: z.boolean().optional()
+});
+const snapshotForkSchema = z.object({
+  title: z.string().trim().min(1).max(200),
+  targetProjectId: z.string().optional()
+});
+const sourceRefSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("live"), documentId: z.string() }),
+  z.object({ kind: z.literal("snapshot"), snapshotId: z.string() }),
+  z.object({
+    kind: z.literal("version"),
+    documentId: z.string(),
+    versionId: z.string()
+  })
+]);
+const versionRestoreAsCopySchema = z.object({
+  title: z.string().trim().min(1).max(200),
+  targetProjectId: z.string().optional()
+});
+const snapshotPrefsSchema = z.object({ hidden: z.boolean() });
+const SNAPSHOT_NOTES_MAX = 200;
+const snapshotNoteCreateSchema = z.object({
+  body: z.string().trim().min(1).max(2e3)
+});
+const snapshotCommentAnchorSchema = z.object({
+  elementId: z.string().min(1),
+  offset: z.number().int().min(0),
+  length: z.number().int().min(0)
+});
+const snapshotCommentCreateSchema = z.object({
+  anchor: snapshotCommentAnchorSchema,
+  body: z.string().trim().min(1).max(1e4),
+  /** User ids mentioned in the body (notifications are B12). */
+  mentions: z.array(z.string().min(1)).max(50).optional()
+});
+const snapshotCommentResolveSchema = z.object({ resolved: z.boolean() });
+const snapshotCommentsQuerySchema = cursorQuerySchema;
+const COMPARE_GRANULARITIES = ["scene", "element", "word"];
+const TRACKED_CHANGE_MODES = [
+  "accept-all",
+  "reject-all",
+  "as-marked"
+];
+const compareRequestSchema = z.object({
+  base: sourceRefSchema,
+  target: sourceRefSchema,
+  granularity: z.enum(COMPARE_GRANULARITIES).default("element"),
+  ignoreFormatting: z.boolean().default(false),
+  ignoreRevisionMarks: z.boolean().default(false),
+  ignoreTrackedChanges: z.enum(TRACKED_CHANGE_MODES).default("as-marked")
+});
+const COMPARE_MAX_PAGES = 400;
+const elementHistoryQuerySchema = cursorQuerySchema;
+const COMMAND_BATCH_MAX = 500;
+const commandBatchRequestSchema = z.object({
+  commands: z.array(z.record(z.string(), z.unknown())).min(1).max(COMMAND_BATCH_MAX),
+  baseEpoch: z.number().int().min(0),
+  expectedHashes: z.record(z.string(), z.string()).optional(),
+  dryRun: z.boolean().optional()
+});
+const SCENE_BATCH_MAX = 20;
+const ELEMENT_BATCH_MAX = 500;
+const elementsBatchRequestSchema = z.object({
+  elementIds: z.array(z.string().min(1)).min(1).max(ELEMENT_BATCH_MAX)
+});
+const scenesBatchRequestSchema = z.object({
+  sceneIds: z.array(z.string().min(1)).min(1).max(SCENE_BATCH_MAX)
+});
+const IMPORT_FORMAT_IDS = ["fountain", "fdx", "fadein"];
+const EXPORT_FORMAT_IDS = ["fountain", "fdx", "json"];
+const IMPORT_MAX_BYTES_DEFAULT = 100 * 1024 * 1024;
+const documentImportSchema = z.object({
+  /** Client-generated `doc_...`; import is idempotent on it. */
+  id: z.string().startsWith("doc_").optional(),
+  /** Only a hint: the format is detected from the content. */
+  filename: z.string().min(1).max(500),
+  /** Base64 of the file bytes. */
+  contentB64: z.string(),
+  /** Defaults to the file's title page title, then the filename. */
+  title: z.string().trim().min(1).max(200).optional(),
+  kind: documentKindSchema.optional(),
+  templateId: z.string().optional(),
+  language: z.string().max(16).optional()
+});
+const documentExportSchema = z.object({
+  format: z.string().min(1).max(32)
+});
+const sourceParamSchema = z.string().regex(
+  /^(live|snapshot:[A-Za-z0-9_-]+|version:[A-Za-z0-9_-]+)$/,
+  "source must be live, snapshot:<id> or version:<id>"
+);
+const docSourceSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("live") }),
+  z.object({ kind: z.literal("snapshot"), snapshotId: z.string().min(1) }),
+  z.object({ kind: z.literal("version"), versionId: z.string().min(1) })
+]);
+const sourceQuerySchema = z.object({
+  source: sourceParamSchema.optional()
+});
+function sourceParamOf(ref) {
+  if (!ref || ref.kind === "live") return void 0;
+  return ref.kind === "snapshot" ? `snapshot:${ref.snapshotId}` : `version:${ref.versionId}`;
+}
+const entityListQuerySchema = cursorQuerySchema.extend({
+  kind: z.string().min(1).optional(),
+  q: z.string().min(1).max(200).optional(),
+  source: sourceParamSchema.optional()
+});
+const entityUsageQuerySchema = z.object({
+  variantId: z.string().min(1).optional(),
+  source: sourceParamSchema.optional()
+});
+const entityDialogueQuerySchema = z.object({
+  sceneIds: z.string().optional(),
+  source: sourceParamSchema.optional()
+});
+const tagsQuerySchema = z.object({
+  sceneId: z.string().optional(),
+  categoryId: z.string().optional(),
+  entityId: z.string().optional(),
+  source: sourceParamSchema.optional()
+});
+const notesQuerySchema = z.object({
+  sceneId: z.string().optional(),
+  type: z.string().optional(),
+  status: z.enum(["open", "resolved"]).optional(),
+  source: sourceParamSchema.optional()
+});
+const changesQuerySchema = z.object({
+  authorId: z.string().optional(),
+  sceneId: z.string().optional(),
+  source: sourceParamSchema.optional()
+});
+const fountainQuerySchema = z.object({
+  sceneIds: z.string().optional(),
+  fromSceneId: z.string().optional(),
+  source: sourceParamSchema.optional()
+});
+const FOUNTAIN_MAX_BYTES = 1e6;
+const LOCATOR_KINDS = [
+  "scene",
+  "element",
+  "shot",
+  "entity",
+  "page"
+];
+const RESOLVE_BATCH_MAX = 200;
+const resolveBatchSchema = z.object({
+  locators: z.array(z.string().min(1).max(500)).min(1).max(RESOLVE_BATCH_MAX),
+  snapshotId: z.string().min(1).optional()
+});
+const resolveOneQuerySchema = z.object({
+  ref: z.string().min(1).max(500),
+  snapshotId: z.string().min(1).optional()
+});
+const SEARCH_HIT_TYPES = [
+  "document",
+  "scene",
+  "element",
+  "entity",
+  "note",
+  "asset"
+];
+const csv = (v) => typeof v === "string" ? v.split(",").map((s) => s.trim()).filter(Boolean) : v;
+const searchQuerySchema = cursorQuerySchema.extend({
+  q: z.string().min(1).max(200),
+  workspaceId: z.string().min(1).optional(),
+  projectId: z.string().min(1).optional(),
+  documentId: z.string().min(1).optional(),
+  types: z.preprocess(csv, z.array(z.enum(SEARCH_HIT_TYPES)).min(1)).optional(),
+  styleIds: z.preprocess(csv, z.array(z.string()).min(1)).optional(),
+  characterId: z.string().min(1).optional(),
+  language: z.string().min(2).max(35).optional()
+});
+const documentSearchQuerySchema = z.object({
+  q: z.string().min(1).max(500),
+  mode: z.enum(["text", "regex"]).default("text"),
+  styles: z.preprocess(csv, z.array(z.string()).min(1)).optional(),
+  characters: z.preprocess(csv, z.array(z.string()).min(1)).optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  source: sourceParamSchema.optional()
+});
+const JOB_IMPORT_FORMATS = ["fountain", "fdx", "fadein"];
+const JOB_EXPORT_FORMATS = ["fountain", "fdx", "json"];
+const COMBINED_EXPORT_FORMATS = ["fdx", "fountain"];
+const COMBINED_EXPORT_MAX_DOCUMENTS = 20;
+const BATCH_WATERMARK_MAX_RECIPIENTS = 500;
+const UPLOAD_PURPOSES = ["state", "watermark_lookup", "import"];
+const sha256HexSchema$1 = z.string().regex(/^[0-9a-fA-F]{64}$/, "sha256Hex must be 64 hex characters");
+const uploadStateRequestSchema = z.object({
+  sizeBytes: z.number().int().min(1),
+  sha256Hex: sha256HexSchema$1,
+  purpose: z.enum(["state", "watermark_lookup"]).default("state")
+});
+const importOptionsSchema = z.object({
+  templateId: z.string().min(1).optional(),
+  /** `auto`: OCR a PDF without a text layer; `force`; `off`. No OCR exists yet: `force` is `OCR_UNAVAILABLE`. */
+  ocr: z.enum(["auto", "force", "off"]).default("auto"),
+  ocrLanguage: z.string().min(2).max(16).optional(),
+  title: z.string().trim().min(1).max(200).optional(),
+  kind: documentKindSchema.optional(),
+  language: z.string().max(16).optional()
+});
+const importFileFields = {
+  filename: z.string().min(1).max(500),
+  sizeBytes: z.number().int().min(1),
+  sha256Hex: sha256HexSchema$1,
+  /** Auto-detected from the uploaded bytes when omitted. */
+  format: z.string().min(1).max(32).optional(),
+  options: importOptionsSchema.optional()
+};
+const importCreateSchema = z.object({
+  targetProjectId: z.string().min(1).optional(),
+  templateTarget: z.object({
+    scope: z.enum(["user", "workspace"]),
+    workspaceId: z.string().min(1).optional()
+  }).refine((v) => v.scope !== "workspace" || !!v.workspaceId, {
+    message: "workspaceId is required for a workspace template",
+    path: ["workspaceId"]
+  }).optional(),
+  ...importFileFields
+}).refine(
+  (v) => (v.targetProjectId ? 1 : 0) + (v.templateTarget ? 1 : 0) === 1,
+  {
+    message: "Send exactly one of targetProjectId and templateTarget",
+    path: ["targetProjectId"]
+  }
+);
+const importOverSchema = z.object(importFileFields);
+const importJobInputSchema = z.object({
+  importId: z.string().min(1),
+  targetProjectId: z.string().min(1),
+  newDocumentId: z.string().min(1),
+  filename: z.string().min(1).max(500),
+  options: importOptionsSchema.optional()
+});
+const importOverJobInputSchema = z.object({
+  importId: z.string().min(1),
+  documentId: z.string().min(1),
+  filename: z.string().min(1).max(500),
+  options: importOptionsSchema.optional()
+});
+const CONVERSION_REPORT_OUTPUT = "conversion-report.json";
+const watermarkStyleSchema = z.object({
+  text: z.string().min(1).max(200).default("{recipient}"),
+  opacity: z.number().min(0.05).max(1).optional(),
+  position: z.enum(["diagonalAscending", "diagonalDescending", "horizontal"]).optional()
+});
+const batchWatermarkSchema = z.object({
+  recipients: z.array(
+    z.object({
+      name: z.string().trim().min(1).max(200),
+      email: z.string().trim().min(1).max(320).optional(),
+      company: z.string().trim().min(1).max(200).optional()
+    })
+  ).min(1).max(BATCH_WATERMARK_MAX_RECIPIENTS),
+  visible: watermarkStyleSchema.optional(),
+  /** Forensic mark. Only a PDF writer can embed one; text formats carry the export code as a visible note (see the API notes). */
+  invisible: z.boolean().default(false),
+  /** `email` needs the notification slice (B12): refused with `VALIDATION` until then. */
+  deliver: z.enum(["download", "email"]).default("download"),
+  emailMessage: z.string().max(2e3).optional()
+});
+const exportOptionsSchema = z.object({
+  /** Download name without extension (default: the document title). */
+  filename: z.string().trim().min(1).max(120).optional(),
+  batchWatermark: batchWatermarkSchema.optional()
+});
+const exportCreateSchema = z.object({
+  format: z.string().min(1).max(32),
+  source: docSourceSchema.optional(),
+  options: exportOptionsSchema.optional()
+});
+const exportCombinedSchema = z.object({
+  documentIds: z.array(z.string().min(1)).min(1).max(COMBINED_EXPORT_MAX_DOCUMENTS),
+  format: z.string().min(1).max(32),
+  options: exportOptionsSchema.omit({ batchWatermark: true }).optional()
+});
+const exportJobInputSchema = z.object({
+  format: z.enum(JOB_EXPORT_FORMATS),
+  documentIds: z.array(z.string().min(1)).max(COMBINED_EXPORT_MAX_DOCUMENTS).optional(),
+  source: docSourceSchema.optional(),
+  options: exportOptionsSchema.optional()
+});
+const EXPORT_CODE_PREFIX = "FWX-";
+const watermarkLookupSchema = z.object({
+  exportId: z.string().trim().min(8).max(64).optional(),
+  pdfUploadKey: z.string().min(1).max(100).optional()
+}).refine((v) => (v.exportId ? 1 : 0) + (v.pdfUploadKey ? 1 : 0) === 1, {
+  message: "Send exactly one of exportId and pdfUploadKey",
+  path: ["exportId"]
+});
+const AI_TASKS = ["coverage", "polish.dialogue"];
+const aiTaskSchema = z.enum(AI_TASKS);
+const AI_ENDPOINTS = [
+  "coverage-review",
+  "polish",
+  "summarize-chunk"
+];
+const AI_JOB_STATUSES = [
+  "queued",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+const AI_LIMITS = {
+  noteTitleMax: 80,
+  noteBodyMax: 1200,
+  noteAnchorsMax: 8,
+  strengthsMax: 8,
+  weaknessesMax: 12,
+  sceneNotesMax: 20,
+  loglineMax: 300,
+  summaryMax: 4e3,
+  genreMax: 3,
+  verdictRationaleMax: 800,
+  polishSuggestionsMax: 200,
+  polishTextMax: 4e3,
+  rationaleMax: 400,
+  chunkSummaryMax: 1200,
+  sceneSummaryMax: 280,
+  polishMaxScenes: 8,
+  instructionsMax: 500
+};
+const REVIEW_CATEGORIES = [
+  "premise",
+  "structure",
+  "character",
+  "dialogue",
+  "pacing",
+  "tone",
+  "theme",
+  "worldbuilding",
+  "format",
+  "marketability",
+  "clarity",
+  "continuity"
+];
+const SEVERITIES = ["praise", "minor", "moderate", "major"];
+const COVERAGE_VERDICTS = ["recommend", "consider", "pass"];
+const anchorRefSchema = z.object({
+  sceneId: z.string(),
+  elementId: z.string().nullable()
+});
+const noteSchema = z.object({
+  category: z.enum(REVIEW_CATEGORIES),
+  severity: z.enum(SEVERITIES),
+  title: z.string().min(1).max(AI_LIMITS.noteTitleMax),
+  body: z.string().min(1).max(AI_LIMITS.noteBodyMax),
+  anchors: z.array(anchorRefSchema).max(AI_LIMITS.noteAnchorsMax)
+});
+const coverageResponseSchema = z.object({
+  logline: z.string().max(AI_LIMITS.loglineMax),
+  summary: z.string().max(AI_LIMITS.summaryMax),
+  genre: z.array(z.string()).max(AI_LIMITS.genreMax),
+  strengths: z.array(noteSchema).max(AI_LIMITS.strengthsMax),
+  weaknesses: z.array(noteSchema).max(AI_LIMITS.weaknessesMax),
+  /** Notes about specific scenes: each must anchor at least one scene. */
+  sceneNotes: z.array(noteSchema).max(AI_LIMITS.sceneNotesMax),
+  verdict: z.enum(COVERAGE_VERDICTS),
+  verdictRationale: z.string().max(AI_LIMITS.verdictRationaleMax)
+});
+const polishResponseSchema = z.object({
+  suggestions: z.array(
+    z.object({
+      elementId: z.string(),
+      after: z.string().max(AI_LIMITS.polishTextMax),
+      rationale: z.string().max(AI_LIMITS.rationaleMax)
+    })
+  ).max(AI_LIMITS.polishSuggestionsMax)
+});
+const chunkSummaryResponseSchema = z.object({
+  scenes: z.array(
+    z.object({
+      sceneId: z.string(),
+      summary: z.string().max(AI_LIMITS.sceneSummaryMax),
+      intensity: z.number().int().min(1).max(5)
+    })
+  ),
+  chunkSummary: z.string().max(AI_LIMITS.chunkSummaryMax)
+});
+const aiEndpointInputSchema = z.object({
+  context: z.string(),
+  brief: z.string(),
+  max_output_tokens: z.number().int().positive(),
+  locale: z.string(),
+  script_language: z.string()
+});
+const AI_ENDPOINT_OUTPUT_SCHEMAS = {
+  "coverage-review": coverageResponseSchema,
+  polish: polishResponseSchema,
+  "summarize-chunk": chunkSummaryResponseSchema
+};
+const aiScopeSchema = z.object({
+  sceneIds: z.array(z.string().min(1)).max(200).optional(),
+  elementIds: z.array(z.string().min(1)).max(2e3).optional()
+});
+const aiJobOptionsSchema = z.object({
+  /** Writer's own request, fenced separately from the script. Fixture failure markers only work in test mode. */
+  instructions: z.string().max(AI_LIMITS.instructionsMax).optional(),
+  intensity: z.enum(["light", "medium", "bold"]).optional(),
+  locale: z.string().min(2).max(20).optional()
+});
+const aiJobCreateSchema = z.object({
+  task: aiTaskSchema,
+  scope: aiScopeSchema.optional(),
+  options: aiJobOptionsSchema.optional()
+});
+const SUGGESTION_STATUSES = [
+  "pending",
+  "accepted",
+  "rejected",
+  "stale"
+];
+const SUGGESTION_SET_STATUSES = [
+  "pending",
+  "partiallyAccepted",
+  "accepted",
+  "rejected",
+  "stale",
+  "expired"
+];
+const suggestionAcceptSchema = z.object({
+  suggestionIds: z.array(z.string().min(1)).min(1).max(200)
+});
+const suggestionRejectSchema = z.object({
+  suggestionIds: z.array(z.string().min(1)).min(1).max(200).optional()
+});
+const AI_CONSENT_VERSION = 1;
+const aiConsentAcceptSchema = z.object({ version: z.number().int() });
+const aiEstimateRequestSchema = z.object({
+  task: aiTaskSchema,
+  scope: z.object({
+    sceneIds: z.array(z.string()).optional(),
+    elementIds: z.array(z.string()).optional()
+  }).optional(),
+  options: z.record(z.string(), z.unknown()).optional()
+});
+const suggestionDecideSchema = z.object({
+  accept: z.union([z.array(z.string().min(1)), z.literal("allPending")]),
+  reject: z.union([z.array(z.string().min(1)), z.literal("allPending")]),
+  expectedHashes: z.record(z.string(), z.string()).optional(),
+  dryRun: z.boolean().optional()
+});
+const JOB_STATUSES = [
+  "queued",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+const TERMINAL_JOB_STATUSES = [
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+const isTerminalJobStatus = (s) => TERMINAL_JOB_STATUSES.includes(s);
+const JOB_LANES = [
+  "ai",
+  "interactive",
+  "bulk",
+  "system",
+  "provider"
+];
+const JOB_KINDS = [
+  "ai.review",
+  "ai.polish",
+  "ai.describe",
+  "export.pdf",
+  "export.fdx",
+  "export.fountain",
+  "export.fadein",
+  "export.fadewright",
+  "export.json",
+  "export.docx",
+  "watermark.batch",
+  "import.fdx",
+  "import.fountain",
+  "import.fadein",
+  "import.pdf",
+  "import.ocr",
+  "import.celtx",
+  "import.scrivener",
+  "import.fdxt",
+  "report.render",
+  "doc.applyTemplate",
+  "doc.importOver",
+  "doc.snapshotOpen",
+  "doc.versionRestore",
+  "doc.compare",
+  "doc.normalize",
+  "doc.renormalize",
+  "doc.compact",
+  "snapshot.project",
+  "project.duplicate",
+  "asset.derive",
+  "account.export",
+  "system.emailSend",
+  "system.emailDigest",
+  "system.writingReminder",
+  "system.pushSend",
+  "system.purge",
+  "system.retentionSweep",
+  "template.thumbnail",
+  // reserved for media adapters (spec 11 §6.2): registered, seeded disabled
+  "image.generate",
+  "image.edit",
+  "image.upscale",
+  "image.turnaround",
+  "video.generate",
+  "video.extend",
+  "video.upscale",
+  "video.lipSync",
+  "voice.tts",
+  "voice.cloneProfile",
+  "voice.change",
+  "music.generate",
+  "sfx.generate",
+  "audio.isolate",
+  "model3d.generate",
+  "model3d.convert",
+  "model3d.rig",
+  "storyboard.generate",
+  "animatic.assemble",
+  "timeline.export",
+  // framework tests
+  "test.echo",
+  "test.flaky"
+];
+const jobKindSchema = z.enum(JOB_KINDS);
+function aiKindForTask(task) {
+  return task.startsWith("polish") ? "ai.polish" : "ai.review";
+}
+const isAiKind = (kind) => kind.startsWith("ai.");
+const jobSourceSchema = z.object({
+  documentId: z.string().min(1),
+  snapshotId: z.string().min(1).optional(),
+  targetKind: z.string().min(1).max(40),
+  targetId: z.string().min(1).max(100)
+});
+const jobCreateSchema = z.object({
+  kind: jobKindSchema,
+  input: z.record(z.string(), z.unknown()).default({}),
+  sources: z.array(jobSourceSchema).max(20).default([]),
+  idempotencyKey: z.string().min(1).max(128).optional(),
+  maxCredits: z.number().int().min(0).optional(),
+  dryRun: z.boolean().optional()
+});
+const jobListQuerySchema = cursorQuerySchema.extend({
+  documentId: z.string().min(1).optional(),
+  kind: z.string().regex(/^[A-Za-z0-9]+(\.[A-Za-z0-9]*)?$/).optional(),
+  status: z.enum(JOB_STATUSES).optional()
+});
+const JOB_WAIT_MAX_S = 120;
+const jobGetQuerySchema = z.object({
+  wait: z.coerce.number().int().min(0).max(JOB_WAIT_MAX_S).optional()
+});
+const JOB_WEBHOOK_SIGNATURE_HEADER = "X-Webhook-Signature";
+const IDEMPOTENCY_HEADER = "Idempotency-Key";
+const IDEMPOTENT_REPLAY_HEADER = "Idempotent-Replayed";
+const idempotencyKeySchema = z.string().min(1).max(128);
+const REPORT_KINDS = [
+  "scene",
+  "location",
+  "character",
+  "cast",
+  "dialogue",
+  "script",
+  "text",
+  "notes",
+  "synopsis",
+  "revisions",
+  "tags",
+  "statistics",
+  "inclusivity",
+  "presentProgressive",
+  "dayOutOfDays",
+  "shotList",
+  "structure",
+  "characterArcs"
+];
+const REPORT_FORMATS = ["json", "csv", "pdf", "html"];
+const REPORT_SYNC_MAX_PAGES = 200;
+const col = (id, label, align) => ({
+  id,
+  label,
+  ...align ? { align } : {}
+});
+const bool = (name, def, description) => ({
+  name,
+  type: "boolean",
+  default: def,
+  ...{}
+});
+const list = (name, description) => ({
+  name,
+  type: "stringList",
+  default: [],
+  ...description ? { description } : {}
+});
+const en = (name, values, def) => ({ name, type: "enum", values, default: def });
+const REPORT_DEFS = {
+  scene: {
+    featureId: "F-RPT-001",
+    title: "Scene report",
+    options: [
+      en(
+        "sort",
+        ["scriptOrder", "sceneNumber", "location", "scriptDay"],
+        "scriptOrder"
+      ),
+      bool("includeOmitted", false)
+    ],
+    columns: [
+      col("number", "Scene"),
+      col("intro", "Intro"),
+      col("location", "Location"),
+      col("time", "Time"),
+      col("heading", "Heading"),
+      col("page", "Page"),
+      col("length", "Length"),
+      col("estTime", "Est. time", "right"),
+      col("synopsis", "Synopsis"),
+      col("colour", "Colour"),
+      col("speaking", "Speaking"),
+      col("nonSpeaking", "Non-speaking"),
+      col("scriptDay", "Script day")
+    ]
+  },
+  location: {
+    featureId: "F-RPT-002",
+    title: "Location report",
+    options: [en("sort", ["name", "firstAppearance", "length"], "name")],
+    columns: [
+      col("location", "Location"),
+      col("intExt", "INT/EXT"),
+      col("times", "Times of day"),
+      col("scenes", "Scenes"),
+      col("pages", "Pages"),
+      col("eighths", "Length"),
+      col("sceneCount", "Scene count", "right")
+    ]
+  },
+  character: {
+    featureId: "F-RPT-003",
+    title: "Character report",
+    options: [
+      list("characters", "Entity ids or names; empty means every character"),
+      bool("includeNonSpeaking", false),
+      {
+        name: "monologueWords",
+        type: "number",
+        default: 100,
+        min: 1,
+        max: 1e4
+      },
+      bool("includeDialogue", false)
+    ],
+    columns: [
+      col("character", "Character"),
+      col("scenes", "Speaking scenes"),
+      col("nonSpeakingScenes", "Non-speaking scenes"),
+      col("extensions", "Extensions"),
+      col("parentheticals", "Parentheticals", "right"),
+      col("monologues", "Monologues", "right"),
+      col("dialogue", "Dialogue")
+    ]
+  },
+  cast: {
+    featureId: "F-RPT-004",
+    title: "Cast report",
+    options: [
+      en(
+        "sort",
+        ["alphabetical", "scriptOrder", "dialogueCount", "words"],
+        "alphabetical"
+      )
+    ],
+    columns: [
+      col("character", "Character"),
+      col("dialogues", "Dialogues", "right"),
+      col("words", "Words", "right"),
+      col("lines", "Lines", "right"),
+      col("speakingScenes", "Speaking scenes", "right"),
+      col("totalScenes", "Total scenes", "right"),
+      col("pagesPresent", "Pages present"),
+      col("firstAppearance", "First appearance"),
+      col("gender", "Gender"),
+      col("role", "Role"),
+      col("age", "Age")
+    ]
+  },
+  dialogue: {
+    featureId: "F-RPT-005",
+    title: "Dialogue report",
+    options: [
+      list("characters", "Entity ids or names; empty means every character"),
+      bool("includeParentheticals", false)
+    ],
+    columns: [
+      col("number", "#", "right"),
+      col("scene", "Scene"),
+      col("page", "Page"),
+      col("character", "Character"),
+      col("text", "Dialogue")
+    ]
+  },
+  script: {
+    featureId: "F-RPT-006",
+    title: "Script report",
+    options: [list("styles", "Style ids or roles; empty means every element")],
+    columns: [
+      col("page", "Page"),
+      col("scene", "Scene"),
+      col("style", "Style"),
+      col("text", "Text")
+    ]
+  },
+  text: {
+    featureId: "F-RPT-007",
+    title: "Text report",
+    options: [
+      {
+        name: "q",
+        type: "string",
+        required: true,
+        description: "Text to find"
+      },
+      en("mode", ["text", "regex"], "text"),
+      list("styles", "Restrict to these style ids")
+    ],
+    columns: [
+      col("page", "Page"),
+      col("scene", "Scene"),
+      col("style", "Style"),
+      col("snippet", "Context")
+    ]
+  },
+  notes: {
+    featureId: "F-RPT-008",
+    title: "Notes report",
+    options: [
+      list("types"),
+      list("authors"),
+      en("status", ["any", "open", "resolved"], "any"),
+      list("colours")
+    ],
+    columns: [
+      col("order", "#", "right"),
+      col("colour", "Colour"),
+      col("type", "Type"),
+      col("title", "Title"),
+      col("body", "Note"),
+      col("author", "Author"),
+      col("created", "Created"),
+      col("modified", "Modified"),
+      col("page", "Page"),
+      col("scene", "Scene"),
+      col("status", "Status"),
+      col("replies", "Replies", "right")
+    ]
+  },
+  synopsis: {
+    featureId: "F-RPT-009",
+    title: "Synopsis report",
+    options: [bool("includeEmpty", true)],
+    columns: [
+      col("number", "Scene"),
+      col("heading", "Heading"),
+      col("synopsis", "Synopsis"),
+      col("colour", "Colour")
+    ]
+  },
+  revisions: {
+    featureId: "F-RPT-010",
+    title: "Revisions report",
+    options: [list("sets", "Revision set ids; empty means every set")],
+    columns: [
+      col("set", "Revision"),
+      col("colour", "Colour"),
+      col("mark", "Mark"),
+      col("date", "Date"),
+      col("pages", "Pages"),
+      col("scenes", "Scenes"),
+      col("revisedElements", "Revised elements", "right")
+    ]
+  },
+  tags: {
+    featureId: "F-RPT-011",
+    title: "Tags report",
+    options: [
+      en("mode", ["byScene", "byCategory"], "byScene"),
+      list("categories", "Tag category ids; empty means all")
+    ],
+    columns: [
+      col("scene", "Scene"),
+      col("heading", "Heading"),
+      col("page", "Page"),
+      col("length", "Length"),
+      col("scriptDay", "Script day"),
+      col("category", "Category"),
+      col("entities", "Entities")
+    ]
+  },
+  statistics: {
+    featureId: "F-RPT-012",
+    title: "Statistics report",
+    options: [
+      { name: "topWords", type: "number", default: 20, min: 0, max: 200 },
+      { name: "longestScenes", type: "number", default: 5, min: 0, max: 50 }
+    ],
+    columns: [col("metric", "Metric"), col("value", "Value", "right")]
+  },
+  inclusivity: {
+    featureId: "F-RPT-013",
+    title: "Inclusivity and gender analysis",
+    options: [en("by", ["gender", "role"], "gender")],
+    columns: [
+      col("group", "Group"),
+      col("characters", "Characters", "right"),
+      col("dialogues", "Dialogues", "right"),
+      col("words", "Words", "right"),
+      col("scenesSpeaking", "Scenes speaking", "right"),
+      col("wordsPct", "Words %", "right")
+    ]
+  },
+  presentProgressive: {
+    featureId: "F-RPT-014",
+    title: "Present progressive check",
+    options: [],
+    columns: [
+      col("page", "Page"),
+      col("scene", "Scene"),
+      col("match", "Match"),
+      col("text", "Action line")
+    ]
+  },
+  dayOutOfDays: {
+    featureId: "F-RPT-015",
+    title: "Day out of days",
+    options: [],
+    columns: [
+      col("character", "Character"),
+      col("workDays", "Work days", "right"),
+      col("holds", "Holds", "right")
+    ]
+  },
+  shotList: {
+    featureId: "F-RPT-016",
+    title: "Shot list",
+    options: [],
+    columns: [
+      col("scene", "Scene"),
+      col("shot", "Shot"),
+      col("label", "Label"),
+      col("description", "Description"),
+      col("size", "Size"),
+      col("angle", "Angle"),
+      col("movement", "Movement"),
+      col("lens", "Lens"),
+      col("durationSec", "Duration (s)", "right")
+    ]
+  },
+  structure: {
+    featureId: "F-RPT-017",
+    title: "Structure report",
+    options: [],
+    columns: [
+      col("node", "Act / sequence / beat"),
+      col("goal", "Goal pages"),
+      col("actual", "Actual pages"),
+      col("delta", "Delta", "right")
+    ],
+    unavailable: "Outline page goals are not modelled in writing_core yet (spec 01 §5.13 goals), so there is nothing to compare actual pages with"
+  },
+  characterArcs: {
+    featureId: "F-RPT-018",
+    title: "Character arcs",
+    options: [
+      list("characters", "Entity ids or names; empty means every character")
+    ],
+    columns: [
+      col("character", "Character"),
+      col("scene", "Scene"),
+      col("heading", "Heading"),
+      col("note", "Arc note")
+    ]
+  }
+};
+function reportKindInfos() {
+  return REPORT_KINDS.map((kind) => {
+    const d = REPORT_DEFS[kind];
+    return {
+      kind,
+      featureId: d.featureId,
+      title: d.title,
+      available: !d.unavailable,
+      ...d.unavailable ? { unavailableReason: d.unavailable } : {},
+      options: d.options,
+      columns: d.columns,
+      formats: REPORT_FORMATS
+    };
+  });
+}
+const isReportKind = (v) => typeof v === "string" && REPORT_KINDS.includes(v);
+function parseReportOptions(kind, raw) {
+  const defs = REPORT_DEFS[kind].options;
+  const issues = [];
+  if (raw === void 0 || raw === null) raw = {};
+  if (typeof raw !== "object" || Array.isArray(raw))
+    return {
+      ok: false,
+      issues: [{ path: "", message: "options must be an object" }]
+    };
+  const input = raw;
+  const known = new Set(defs.map((d) => d.name));
+  for (const k of Object.keys(input))
+    if (!known.has(k)) issues.push({ path: k, message: "unknown option" });
+  const out = {};
+  for (const d of defs) {
+    const v = input[d.name];
+    if (v === void 0) {
+      if (d.required) issues.push({ path: d.name, message: "required" });
+      else if (d.default !== void 0)
+        out[d.name] = Array.isArray(d.default) ? [...d.default] : d.default;
+      continue;
+    }
+    switch (d.type) {
+      case "boolean":
+        if (typeof v !== "boolean")
+          issues.push({ path: d.name, message: "must be a boolean" });
+        else out[d.name] = v;
+        break;
+      case "number":
+        if (typeof v !== "number" || !Number.isFinite(v) || d.min !== void 0 && v < d.min || d.max !== void 0 && v > d.max) {
+          issues.push({
+            path: d.name,
+            message: `must be a number${d.min !== void 0 ? ` from ${d.min}` : ""}${d.max !== void 0 ? ` to ${d.max}` : ""}`
+          });
+        } else out[d.name] = v;
+        break;
+      case "string":
+        if (typeof v !== "string" || d.required && v.length === 0 || v.length > 500)
+          issues.push({
+            path: d.name,
+            message: "must be a non-empty string of at most 500 characters"
+          });
+        else out[d.name] = v;
+        break;
+      case "enum":
+        if (typeof v !== "string" || !d.values.includes(v))
+          issues.push({
+            path: d.name,
+            message: `must be one of ${d.values.join(", ")}`
+          });
+        else out[d.name] = v;
+        break;
+      case "stringList":
+        if (!Array.isArray(v) || v.length > 500 || v.some((x) => typeof x !== "string"))
+          issues.push({ path: d.name, message: "must be an array of strings" });
+        else out[d.name] = v;
+        break;
+    }
+  }
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, options: out };
+}
+const reportGetQuerySchema = z.object({
+  source: sourceParamSchema.optional(),
+  options: z.string().max(2e4).optional()
+});
+const reportCreateSchema = z.object({
+  kind: z.enum(REPORT_KINDS),
+  source: docSourceSchema.optional(),
+  options: z.record(z.string(), z.unknown()).default({}),
+  format: z.enum(REPORT_FORMATS).default("json")
+});
+const reportRenderInputSchema = z.object({
+  kind: z.enum(REPORT_KINDS),
+  source: z.string().default("live"),
+  options: z.record(z.string(), z.unknown()).default({}),
+  format: z.enum(REPORT_FORMATS).default("csv")
+});
+const cellText = (v) => v === null || v === void 0 ? "" : String(v);
+const csvField = (s) => /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+function reportToCsv(result) {
+  const blocks = result.tables.map((t) => {
+    const lines = [];
+    if (result.tables.length > 1 && t.title) lines.push(csvField(t.title));
+    lines.push(t.columns.map((c) => csvField(c.label)).join(","));
+    for (const r2 of t.rows)
+      lines.push(
+        t.columns.map((c) => csvField(cellText(r2[c.id] ?? null))).join(",")
+      );
+    if (t.footer)
+      lines.push(
+        t.columns.map((c) => csvField(cellText(t.footer[c.id] ?? null))).join(",")
+      );
+    return lines.join("\r\n");
+  });
+  return blocks.join("\r\n\r\n") + "\r\n";
+}
+const PACKET_VERSION = 1;
+const PACKET_INCLUDE_FLAGS = [
+  "assets",
+  "assetUrls",
+  "script",
+  "neighbors",
+  "pages"
+];
+const packetQuerySchema = z.object({
+  snapshotId: z.string().min(1).optional(),
+  include: z.preprocess(
+    (v) => typeof v === "string" ? v.split(",").map((s) => s.trim()).filter(Boolean) : v,
+    z.array(
+      z.enum([
+        "assets",
+        "assetUrls=original",
+        "script",
+        "neighbors",
+        "pages",
+        "-assets",
+        "-script"
+      ])
+    )
+  ).optional()
+});
+const PACKET_MAX_BYTES = 2 * 1024 * 1024;
+const envelope = (kind, body) => z.object({
+  packetVersion: z.literal(PACKET_VERSION),
+  kind: z.literal(kind),
+  documentId: z.string(),
+  documentTitle: z.string(),
+  snapshotId: z.string().nullable(),
+  templateId: z.string(),
+  language: z.string(),
+  generatedAt: z.string(),
+  /** `packetHash` of the packet without `generatedAt`, `hash` and signed-URL fields (spec 11 §4.2). */
+  hash: z.string(),
+  truncated: z.boolean().optional(),
+  body
+});
+const assetSummary = z.object({
+  assetId: z.string(),
+  role: z.string(),
+  kind: z.string(),
+  title: z.string()
+}).passthrough();
+const pages = z.object({ start: z.string(), end: z.string(), eighths: z.number().int() }).nullable();
+const packetElementSchema = z.union([
+  z.object({
+    id: z.string(),
+    type: z.literal("character"),
+    text: z.string(),
+    speakerEntityId: z.string().nullable(),
+    extension: z.string().nullable()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("parenthetical"),
+    text: z.string(),
+    speakerEntityId: z.string().nullable()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("dialogue"),
+    text: z.string(),
+    speakerEntityId: z.string().nullable(),
+    dual: z.boolean(),
+    lineIndex: z.number().int()
+  }),
+  // every other role: sceneHeading, action, transition, shot, normal, ...
+  z.object({
+    id: z.string(),
+    type: z.string().refine((t) => !["character", "parenthetical", "dialogue"].includes(t)),
+    text: z.string()
+  })
+]);
+const shotSummary = z.object({
+  id: z.string(),
+  number: z.string().nullable(),
+  label: z.string().nullable(),
+  status: z.string(),
+  camera: z.record(z.string(), z.unknown()),
+  estimatedDurationMs: z.number().nullable(),
+  description: z.string().nullable(),
+  elementIds: z.array(z.string()),
+  contentHash: z.string(),
+  assets: z.array(assetSummary)
+});
+const sceneRef = z.object({
+  id: z.string(),
+  number: z.string().nullable(),
+  heading: z.string(),
+  synopsis: z.string()
+});
+const sceneHeader = z.object({
+  id: z.string(),
+  number: z.string().nullable(),
+  ordinal: z.number().int(),
+  omitted: z.boolean(),
+  heading: z.object({
+    raw: z.string(),
+    intro: z.string().nullable(),
+    location: z.string().nullable(),
+    time: z.string().nullable()
+  }),
+  locationEntityId: z.string().nullable(),
+  synopsis: z.string(),
+  color: z.string().nullable(),
+  pages,
+  estimatedDurationMs: z.number(),
+  folders: z.array(
+    z.object({ id: z.string(), kind: z.string(), title: z.string() })
+  ),
+  contentHash: z.string(),
+  scriptDay: z.string().nullable()
+});
+const locationBlock = z.object({
+  entityId: z.string(),
+  name: z.string(),
+  fields: z.record(z.string(), z.unknown()),
+  description: z.string(),
+  assets: z.array(assetSummary)
+}).nullable();
+const scenePacketBodySchema = z.object({
+  scene: sceneHeader,
+  script: z.array(packetElementSchema),
+  cast: z.array(
+    z.object({
+      entityId: z.string(),
+      name: z.string(),
+      speaking: z.boolean(),
+      lineCount: z.number().int(),
+      wordCount: z.number().int(),
+      firstAppearance: z.boolean(),
+      summary: z.string(),
+      fields: z.record(z.string(), z.unknown()),
+      traits: z.record(z.string(), z.union([z.string(), z.number()])),
+      assets: z.array(assetSummary)
+    })
+  ),
+  location: locationBlock,
+  elements: z.array(
+    z.object({
+      entityId: z.string(),
+      kind: z.string(),
+      name: z.string(),
+      description: z.string(),
+      tagCount: z.number().int(),
+      assets: z.array(assetSummary)
+    })
+  ),
+  shots: z.array(shotSummary),
+  notes: z.array(
+    z.object({
+      id: z.string(),
+      type: z.string(),
+      text: z.string(),
+      anchorElementId: z.string().nullable()
+    })
+  ),
+  sceneAssets: z.array(assetSummary),
+  neighbors: z.object({ previous: sceneRef.nullable(), next: sceneRef.nullable() }).optional()
+});
+const scenePacketSchema = envelope("scene", scenePacketBodySchema);
+const characterPacketBodySchema = z.object({
+  character: z.object({
+    id: z.string(),
+    name: z.string(),
+    aliases: z.array(z.string()),
+    description: z.string(),
+    fields: z.record(z.string(), z.unknown()),
+    traits: z.record(z.string(), z.union([z.string(), z.number()])),
+    attributes: z.record(z.string(), z.unknown()),
+    contentHash: z.string()
+  }),
+  ages: z.array(
+    z.object({
+      id: z.string(),
+      label: z.string(),
+      ageValue: z.number().nullable(),
+      description: z.string(),
+      skeleton: z.array(
+        z.object({
+          section: z.string().nullable(),
+          label: z.string(),
+          answer: z.string()
+        })
+      ),
+      appearances: z.array(
+        z.object({
+          id: z.string(),
+          label: z.string(),
+          description: z.string(),
+          assetIds: z.array(z.string())
+        })
+      ),
+      sceneCount: z.number().int()
+    })
+  ),
+  skeleton: z.array(
+    z.object({
+      section: z.string().nullable(),
+      label: z.string(),
+      answer: z.string()
+    })
+  ),
+  stats: z.object({
+    sceneCount: z.number().int(),
+    speakingSceneCount: z.number().int(),
+    lineCount: z.number().int(),
+    wordCount: z.number().int(),
+    firstSceneId: z.string().nullable(),
+    lastSceneId: z.string().nullable()
+  }),
+  scenes: z.array(
+    z.object({
+      id: z.string(),
+      number: z.string().nullable(),
+      heading: z.string(),
+      speaking: z.boolean(),
+      lineCount: z.number().int(),
+      ageId: z.string().nullable(),
+      appearanceId: z.string().nullable()
+    })
+  ),
+  sampleDialogue: z.array(
+    z.object({ elementId: z.string(), sceneId: z.string(), text: z.string() })
+  ),
+  relationships: z.array(
+    z.object({
+      entityId: z.string(),
+      name: z.string(),
+      sharedSceneCount: z.number().int()
+    })
+  ),
+  props: z.array(z.object({ entityId: z.string(), name: z.string() })),
+  assets: z.array(assetSummary)
+});
+const characterPacketSchema = envelope(
+  "character",
+  characterPacketBodySchema
+);
+const locationPacketBodySchema = z.object({
+  location: z.object({
+    id: z.string(),
+    name: z.string(),
+    aliases: z.array(z.string()),
+    description: z.string(),
+    fields: z.record(z.string(), z.unknown()),
+    parent: z.object({ id: z.string(), name: z.string() }).nullable(),
+    children: z.array(z.object({ id: z.string(), name: z.string() })),
+    contentHash: z.string()
+  }),
+  versions: z.array(
+    z.object({
+      id: z.string(),
+      label: z.string(),
+      description: z.string(),
+      setting: z.string().nullable(),
+      sceneCount: z.number().int()
+    })
+  ),
+  scenes: z.array(
+    z.object({
+      id: z.string(),
+      number: z.string().nullable(),
+      heading: z.string(),
+      time: z.string().nullable(),
+      pages,
+      cast: z.array(z.string()),
+      versionId: z.string().nullable()
+    })
+  ),
+  totals: z.object({
+    sceneCount: z.number().int(),
+    eighths: z.number().int(),
+    timesOfDay: z.record(z.string(), z.number().int())
+  }),
+  setElements: z.array(
+    z.object({ entityId: z.string(), kind: z.string(), name: z.string() })
+  ),
+  assets: z.array(assetSummary)
+});
+const locationPacketSchema = envelope(
+  "location",
+  locationPacketBodySchema
+);
+const shotPacketBodySchema = z.object({
+  shot: shotSummary.extend({
+    sceneId: z.string(),
+    range: z.object({
+      startElementId: z.string(),
+      endElementId: z.string(),
+      text: z.string()
+    }).nullable()
+  }),
+  scene: z.object({
+    id: z.string(),
+    number: z.string().nullable(),
+    heading: z.object({
+      raw: z.string(),
+      intro: z.string().nullable(),
+      location: z.string().nullable(),
+      time: z.string().nullable()
+    }),
+    locationEntityId: z.string().nullable(),
+    contentHash: z.string()
+  }),
+  script: z.array(packetElementSchema),
+  subjects: z.array(
+    z.object({
+      entityId: z.string(),
+      kind: z.string(),
+      name: z.string(),
+      fields: z.record(z.string(), z.unknown()),
+      assets: z.array(assetSummary)
+    })
+  ),
+  location: locationBlock,
+  previousShot: shotSummary.nullable(),
+  nextShot: shotSummary.nullable()
+});
+const shotPacketSchema = envelope("shot", shotPacketBodySchema);
+const ASSET_KINDS = [
+  "image",
+  "video",
+  "audio",
+  "model3d",
+  "document",
+  "archive",
+  "data"
+];
+const assetKindSchema = z.enum(ASSET_KINDS);
+const ASSET_ROLES = [
+  // launch
+  "reference",
+  "headshot",
+  "photo",
+  "logo",
+  "beat_image",
+  "inline_image",
+  "panel_reference",
+  "location_scout",
+  "mood_board",
+  "attachment",
+  // future production (valid now, unused by launch UI)
+  "turnaround",
+  "expression_sheet",
+  "costume_design",
+  "set_concept",
+  "set_plan",
+  "storyboard_frame",
+  "animatic",
+  "previz",
+  "rendered_video",
+  "rendered_shot",
+  "dialogue_audio",
+  "voice_sample",
+  "voice_profile",
+  "music_cue",
+  "sound_effect",
+  "lip_sync",
+  "captions",
+  "model3d",
+  "model3d_rig",
+  "texture",
+  "lora",
+  "timeline"
+];
+const assetRoleSchema = z.enum(ASSET_ROLES);
+const ASSET_ROLE_GROUPS = {
+  reference: "reference",
+  headshot: "reference",
+  photo: "reference",
+  logo: "other",
+  beat_image: "other",
+  inline_image: "other",
+  panel_reference: "storyboard",
+  location_scout: "reference",
+  mood_board: "reference",
+  attachment: "other",
+  turnaround: "design",
+  expression_sheet: "design",
+  costume_design: "design",
+  set_concept: "design",
+  set_plan: "design",
+  storyboard_frame: "storyboard",
+  animatic: "video",
+  previz: "video",
+  rendered_video: "video",
+  rendered_shot: "video",
+  dialogue_audio: "audio",
+  voice_sample: "audio",
+  voice_profile: "audio",
+  music_cue: "audio",
+  sound_effect: "audio",
+  lip_sync: "video",
+  captions: "other",
+  model3d: "3d",
+  model3d_rig: "3d",
+  texture: "3d",
+  lora: "other",
+  timeline: "other"
+};
+const ASSET_TARGET_KINDS = [
+  "document",
+  "scene",
+  "element",
+  "shot",
+  "entity",
+  "beat",
+  "title_page",
+  "snapshot"
+];
+const assetTargetKindSchema = z.enum(ASSET_TARGET_KINDS);
+const ASSET_ROLE_TARGETS = {
+  headshot: ["entity"],
+  turnaround: ["entity"],
+  expression_sheet: ["entity"],
+  costume_design: ["entity"],
+  voice_sample: ["entity"],
+  voice_profile: ["entity"],
+  set_concept: ["entity", "scene"],
+  set_plan: ["entity", "scene"],
+  location_scout: ["entity", "scene"],
+  beat_image: ["beat"],
+  inline_image: ["element"],
+  panel_reference: ["element", "scene", "shot"],
+  logo: ["title_page", "document"],
+  storyboard_frame: ["shot", "scene"],
+  animatic: ["shot", "scene", "document"],
+  previz: ["shot", "scene", "document"],
+  rendered_video: ["shot", "scene", "document"],
+  rendered_shot: ["shot"],
+  dialogue_audio: ["element", "shot", "scene"],
+  music_cue: ["scene", "shot", "document"],
+  sound_effect: ["scene", "shot", "element"],
+  lip_sync: ["shot", "element"],
+  captions: ["scene", "shot", "document"],
+  timeline: ["document", "scene"]
+};
+const ASSET_ROLE_ENTITY_KINDS = {
+  headshot: ["character"],
+  turnaround: ["character"],
+  expression_sheet: ["character"],
+  costume_design: ["character"],
+  voice_sample: ["character"],
+  voice_profile: ["character"],
+  set_concept: ["location"],
+  set_plan: ["location"],
+  location_scout: ["location"]
+};
+const ASSET_ORIGINS = [
+  "upload",
+  "import",
+  "generated",
+  "external_tool"
+];
+const ASSET_VERSION_STATUSES = [
+  "uploading",
+  "processing",
+  "ready",
+  "failed"
+];
+const STALENESS_VALUES = [
+  "fresh",
+  "stale",
+  "target_deleted",
+  "unknown"
+];
+const ASSET_PART_SIZE_BYTES = 8 * 1024 * 1024;
+const ASSET_UPLOAD_CONCURRENCY = 3;
+const ASSET_UPLOAD_TTL_S = 3600;
+const ASSET_URL_TTL_S = 300;
+const ASSET_MAX_BYTES = {
+  image: 100 * 1024 ** 2,
+  video: 10 * 1024 ** 3,
+  audio: 2 * 1024 ** 3,
+  model3d: 5 * 1024 ** 3,
+  document: 200 * 1024 ** 2,
+  archive: 10 * 1024 ** 3,
+  data: 50 * 1024 ** 2
+};
+const ASSET_EXTENSIONS = {
+  ".png": { kind: "image", mimes: ["image/png"] },
+  ".jpg": { kind: "image", mimes: ["image/jpeg"] },
+  ".jpeg": { kind: "image", mimes: ["image/jpeg"] },
+  ".webp": { kind: "image", mimes: ["image/webp"] },
+  ".avif": { kind: "image", mimes: ["image/avif"] },
+  ".gif": { kind: "image", mimes: ["image/gif"] },
+  ".heic": { kind: "image", mimes: ["image/heic"] },
+  ".heif": { kind: "image", mimes: ["image/heif"] },
+  ".svg": { kind: "image", mimes: ["image/svg+xml"] },
+  ".tif": { kind: "image", mimes: ["image/tiff"] },
+  ".tiff": { kind: "image", mimes: ["image/tiff"] },
+  ".exr": { kind: "image", mimes: ["image/x-exr"] },
+  ".psd": { kind: "image", mimes: ["image/vnd.adobe.photoshop"] },
+  ".mp4": { kind: "video", mimes: ["video/mp4"] },
+  ".mov": { kind: "video", mimes: ["video/quicktime"] },
+  ".webm": { kind: "video", mimes: ["video/webm"] },
+  ".mkv": { kind: "video", mimes: ["video/x-matroska"] },
+  ".wav": { kind: "audio", mimes: ["audio/wav", "audio/x-wav", "audio/wave"] },
+  ".aif": { kind: "audio", mimes: ["audio/x-aiff", "audio/aiff"] },
+  ".aiff": { kind: "audio", mimes: ["audio/x-aiff", "audio/aiff"] },
+  ".flac": { kind: "audio", mimes: ["audio/flac"] },
+  ".mp3": { kind: "audio", mimes: ["audio/mpeg"] },
+  ".aac": { kind: "audio", mimes: ["audio/aac"] },
+  ".m4a": { kind: "audio", mimes: ["audio/mp4", "audio/x-m4a"] },
+  ".ogg": { kind: "audio", mimes: ["audio/ogg"] },
+  ".opus": { kind: "audio", mimes: ["audio/ogg", "audio/opus"] },
+  ".glb": { kind: "model3d", mimes: ["model/gltf-binary"] },
+  ".gltf": { kind: "model3d", mimes: ["model/gltf+json"] },
+  ".usdz": { kind: "model3d", mimes: ["model/vnd.usdz+zip"] },
+  ".blend": {
+    kind: "model3d",
+    mimes: ["application/x-blender", "application/octet-stream"]
+  },
+  ".fbx": {
+    kind: "model3d",
+    mimes: ["model/vnd.fbx", "application/octet-stream"]
+  },
+  ".obj": { kind: "model3d", mimes: ["model/obj", "text/plain"] },
+  ".stl": {
+    kind: "model3d",
+    mimes: ["model/stl", "application/sla", "application/octet-stream"]
+  },
+  ".usda": { kind: "model3d", mimes: ["model/vnd.usda", "text/plain"] },
+  ".usdc": {
+    kind: "model3d",
+    mimes: ["model/vnd.usda", "application/octet-stream"]
+  },
+  ".pdf": { kind: "document", mimes: ["application/pdf"] },
+  ".txt": { kind: "document", mimes: ["text/plain"] },
+  ".md": { kind: "document", mimes: ["text/markdown"] },
+  ".docx": {
+    kind: "document",
+    mimes: [
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    ]
+  },
+  ".zip": {
+    kind: "archive",
+    mimes: ["application/zip", "application/x-zip-compressed"]
+  },
+  ".json": { kind: "data", mimes: ["application/json"] },
+  ".csv": { kind: "data", mimes: ["text/csv"] },
+  ".srt": { kind: "data", mimes: ["application/x-subrip", "text/plain"] },
+  ".vtt": { kind: "data", mimes: ["text/vtt"] },
+  ".otio": {
+    kind: "data",
+    mimes: ["application/otio+json", "application/json"]
+  },
+  ".fcpxml": {
+    kind: "data",
+    mimes: ["application/x-fcpxml", "application/xml", "text/xml"]
+  },
+  ".edl": { kind: "data", mimes: ["application/edl", "text/plain"] }
+};
+const assetExtension = (filename) => {
+  const m = /(\.[A-Za-z0-9]{1,10})$/.exec(filename);
+  return m ? m[1].toLowerCase() : "";
+};
+function checkAssetFile(filename, mimeType, sizeBytes, kind) {
+  const spec = ASSET_EXTENSIONS[assetExtension(filename)];
+  if (!spec) return "type";
+  if (spec.kind !== kind) return "kind";
+  if (!spec.mimes.includes(mimeType.toLowerCase().split(";")[0].trim()))
+    return "mime";
+  if (sizeBytes > ASSET_MAX_BYTES[kind]) return "size";
+  return null;
+}
+const assetRightsSchema = z.object({
+  ownership: z.enum(["owned", "licensed", "public_domain", "generated", "unknown"]).default("unknown"),
+  license: z.string().max(500).optional(),
+  attribution: z.string().max(500).optional(),
+  sourceUrl: z.string().max(2e3).optional(),
+  restrictions: z.string().max(1e3).optional(),
+  expiresAt: z.string().optional(),
+  containsLikenessOf: z.array(z.string().max(200)).max(50).optional(),
+  consentAssetId: z.string().optional(),
+  aiTrainingAllowed: z.boolean().default(false)
+});
+const assetSourceRefSchema = z.object({
+  documentId: z.string(),
+  snapshotId: z.string().optional(),
+  targetKind: z.enum([
+    "document",
+    "scene",
+    "element",
+    "shot",
+    "entity",
+    "beat",
+    "title_page"
+  ]),
+  targetId: z.string(),
+  sourceHash: z.string()
+});
+const assetProvenanceInputSchema = z.discriminatedUnion("origin", [
+  z.object({
+    origin: z.literal("external_tool"),
+    tool: z.string().min(1).max(100),
+    toolVersion: z.string().max(100).optional(),
+    description: z.string().max(2e3).optional(),
+    sourceRefs: z.array(assetSourceRefSchema).max(100).default([]),
+    createdVia: z.enum(["mcp", "api", "app"]).default("api")
+  }),
+  z.object({
+    origin: z.literal("generated"),
+    jobId: z.string().optional(),
+    adapter: z.string().min(1).max(100),
+    provider: z.string().min(1).max(100),
+    model: z.string().max(200).optional(),
+    prompt: z.string().max(2e4).optional(),
+    negativePrompt: z.string().max(2e4).optional(),
+    parameters: z.record(z.string(), z.unknown()).default({}),
+    inputs: z.array(
+      z.object({
+        assetVersionId: z.string().optional(),
+        packetHash: z.string().optional(),
+        role: z.string()
+      })
+    ).max(100).default([]),
+    sourceRefs: z.array(assetSourceRefSchema).max(100).default([]),
+    costCredits: z.number().optional(),
+    providerJobId: z.string().optional(),
+    createdVia: z.enum(["mcp", "api", "app"]).default("api")
+  })
+]);
+const sha256HexSchema = z.string().regex(/^[0-9a-fA-F]{64}$/, "sha256Hex must be 64 hex characters");
+const assetUploadRequestSchema = z.object({
+  /** Client-minted `asset_...` id for offline staging; accepted when unused (`ID_CONFLICT` otherwise). */
+  assetId: z.string().regex(/^asset_[0-9A-Za-z]{10,40}$/).optional(),
+  filename: z.string().min(1).max(500),
+  mimeType: z.string().min(1).max(200),
+  sizeBytes: z.number().int().min(1),
+  sha256Hex: sha256HexSchema.optional(),
+  kind: assetKindSchema,
+  title: z.string().trim().min(1).max(200).optional(),
+  /** A new version of an existing asset: the version it derives from. */
+  parentVersionId: z.string().min(1).optional(),
+  provenance: assetProvenanceInputSchema.optional(),
+  rights: assetRightsSchema.partial().optional()
+});
+const assetPartsRequestSchema = z.object({
+  partNumbers: z.array(z.number().int().min(1).max(1e4)).min(1).max(100)
+});
+const assetCompleteSchema = z.object({
+  parts: z.array(
+    z.object({
+      partNumber: z.number().int().min(1),
+      etag: z.string().min(1).max(200)
+    })
+  ).max(1e4),
+  sha256Hex: sha256HexSchema.optional()
+});
+const linkedToSchema = z.string().regex(
+  /^(entity|scene|shot|element):[A-Za-z0-9_-]+$/,
+  "linkedTo is <entity|scene|shot|element>:<id>"
+);
+const assetListQuerySchema = cursorQuerySchema.extend({
+  workspaceId: z.string().min(1).optional(),
+  documentId: z.string().min(1).optional(),
+  linkedTo: linkedToSchema.optional(),
+  role: assetRoleSchema.optional(),
+  kind: assetKindSchema.optional(),
+  q: z.string().trim().min(1).max(200).optional(),
+  origin: z.enum(ASSET_ORIGINS).optional()
+});
+const assetUpdateSchema = z.object({
+  title: z.string().trim().min(1).max(200).optional(),
+  description: z.string().max(5e3).optional(),
+  rights: assetRightsSchema.partial().optional()
+}).refine((v) => Object.keys(v).length > 0, "Nothing to update");
+const ASSET_URL_VARIANTS = [
+  "original",
+  "thumb_256",
+  "thumb_512",
+  "preview_1600",
+  "poster",
+  "proxy_720p",
+  "proxy_1080p",
+  "preview",
+  "waveform",
+  "sprite"
+];
+const assetUrlQuerySchema = z.object({
+  variant: z.string().regex(/^[a-z0-9_]{1,40}$/).default("original")
+});
+const assetLinkCreateSchema = z.object({
+  assetId: z.string().min(1),
+  pinnedVersionId: z.string().min(1).optional(),
+  /** Null/omitted = a workspace-level link: the target must then be `{kind: 'document', id: <the workspace id>}`. */
+  documentId: z.string().min(1).nullable().optional(),
+  target: z.object({
+    kind: assetTargetKindSchema,
+    id: z.string().min(1).max(200)
+  }),
+  role: assetRoleSchema,
+  sortOrder: z.number().int().min(0).max(1e6).optional(),
+  /** Version-prefixed content hash of the target when the asset was derived from it (spec 11 §4.2). */
+  sourceHash: z.string().min(1).max(200).optional(),
+  sourceSnapshotId: z.string().min(1).optional(),
+  note: z.string().max(2e3).optional()
+});
+const assetLinkUpdateSchema = z.object({
+  role: assetRoleSchema.optional(),
+  sortOrder: z.number().int().min(0).max(1e6).optional(),
+  /** `null` unpins (follow the current version). */
+  pinnedVersionId: z.string().min(1).nullable().optional(),
+  note: z.string().max(2e3).optional()
+}).refine((v) => Object.keys(v).length > 0, "Nothing to update");
+const boolQuery$1 = z.enum(["true", "false"]).transform((v) => v === "true");
+const documentAssetLinksQuerySchema = z.object({
+  targetKind: assetTargetKindSchema.optional(),
+  targetId: z.string().min(1).optional(),
+  role: assetRoleSchema.optional(),
+  withStaleness: boolQuery$1.optional()
+});
+const STALENESS_TARGET_KINDS = [
+  "scene",
+  "element",
+  "shot",
+  "entity"
+];
+const documentStalenessQuerySchema = z.object({
+  targetKind: z.enum(STALENESS_TARGET_KINDS).optional()
+});
+const assetDeriveInputSchema = z.object({
+  assetVersionId: z.string().min(1)
+});
+const NOTIFICATION_KINDS = [
+  "mention",
+  "note_reply",
+  "note_on_my_document",
+  "snapshot_comment",
+  "chat_mention",
+  "invitation",
+  "share_granted",
+  "snapshot_opened_by_collaborator",
+  "job_finished",
+  "job_failed",
+  "ai_suggestions_ready",
+  "ai_refunded",
+  "export_ready",
+  "watermark_batch_sent",
+  "writing_reminder",
+  "credits_low",
+  "purchase_completed",
+  "account_deletion_scheduled"
+];
+const NOTIFICATION_EMAIL_MODES = ["immediate", "digest", "off"];
+const DEFAULT_IMMEDIATE_EMAIL = /* @__PURE__ */ new Set([
+  "mention",
+  "note_reply",
+  "chat_mention",
+  "invitation",
+  "share_granted",
+  "job_failed",
+  "export_ready",
+  "watermark_batch_sent",
+  "credits_low",
+  "purchase_completed",
+  "account_deletion_scheduled"
+]);
+const DEFAULT_DIGEST_EMAIL = /* @__PURE__ */ new Set([
+  "snapshot_comment",
+  "note_on_my_document",
+  "ai_suggestions_ready",
+  "ai_refunded",
+  "snapshot_opened_by_collaborator"
+]);
+const DEFAULT_QUIET = /* @__PURE__ */ new Set([
+  "job_finished",
+  "writing_reminder"
+]);
+function defaultNotificationKindPrefs(kind) {
+  const email = DEFAULT_IMMEDIATE_EMAIL.has(kind) ? "immediate" : DEFAULT_DIGEST_EMAIL.has(kind) ? "digest" : "off";
+  return { inApp: true, push: !DEFAULT_QUIET.has(kind), email };
+}
+function defaultNotificationPrefs() {
+  return {
+    kinds: Object.fromEntries(
+      NOTIFICATION_KINDS.map((k) => [k, defaultNotificationKindPrefs(k)])
+    ),
+    writingReminderTime: null
+  };
+}
+const notificationKindPrefsPatchSchema = z.object({
+  inApp: z.boolean().optional(),
+  push: z.boolean().optional(),
+  email: z.enum(NOTIFICATION_EMAIL_MODES).optional()
+});
+const HHMM_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
+const notificationPrefsSchema = z.object({
+  kinds: z.record(z.string(), notificationKindPrefsPatchSchema).refine(
+    (obj) => Object.keys(obj).every(
+      (k) => NOTIFICATION_KINDS.includes(k)
+    ),
+    {
+      message: "unknown notification kind"
+    }
+  ).optional(),
+  writingReminderTime: z.string().regex(HHMM_RE, "writingReminderTime must be HH:MM (24h, local)").nullable().optional()
+});
+function mergeNotificationPrefs(current, update) {
+  const kinds = { ...current.kinds };
+  for (const [k, patch] of Object.entries(update.kinds ?? {})) {
+    const kind = k;
+    kinds[kind] = {
+      ...kinds[kind] ?? defaultNotificationKindPrefs(kind),
+      ...patch
+    };
+  }
+  return {
+    kinds,
+    writingReminderTime: update.writingReminderTime === void 0 ? current.writingReminderTime : update.writingReminderTime
+  };
+}
+const boolQuery = z.enum(["true", "false"]).transform((v) => v === "true");
+const notificationsQuerySchema = cursorQuerySchema.extend({
+  unread: boolQuery.optional()
+});
+const notificationsReadSchema = z.object({
+  ids: z.array(z.string().min(1)).max(200).optional(),
+  all: z.literal(true).optional(),
+  before: z.iso.datetime({ offset: true }).optional()
+}).refine(
+  (v) => v.ids !== void 0 || v.all !== void 0 || v.before !== void 0,
+  {
+    message: "one of ids, all or before is required"
+  }
+);
+const CHAT_BODY_MAX = 4e3;
+const CHAT_EDIT_WINDOW_MINUTES = 15;
+const mentionRefSchema = z.object({
+  userId: z.string().min(1),
+  offset: z.number().int().min(0).optional(),
+  length: z.number().int().min(1).optional()
+});
+const chatMessageCreateSchema = z.object({
+  clientMessageId: z.string().min(8).max(64).regex(/^msg_[0-9A-Za-z]+$/, "clientMessageId must be a msg_ prefixed id"),
+  body: z.string().trim().min(1).max(CHAT_BODY_MAX),
+  mentions: z.array(mentionRefSchema).max(50).optional()
+});
+const chatMessageUpdateSchema = z.object({
+  body: z.string().trim().min(1).max(CHAT_BODY_MAX)
+});
+const chatQuerySchema = cursorQuerySchema.extend({
+  before: z.iso.datetime({ offset: true }).optional()
+});
+const ACTIVITY_KINDS = [
+  "document.created",
+  "document.renamed",
+  "document.moved",
+  "document.trashed",
+  "document.restored",
+  "session.edited",
+  "snapshot.created",
+  "snapshot.opened",
+  "snapshot.forked",
+  "version.restored",
+  "template.applied",
+  "import.over",
+  "revision.setCreated",
+  "locks.changed",
+  "changes.decided",
+  "ai.jobCompleted",
+  "ai.suggestionsDecided",
+  "share.granted",
+  "share.linkCreated",
+  "member.joined",
+  "member.left",
+  "mcp.commandsApplied"
+];
+const ACTOR_KINDS = ["user", "mcp", "api", "ai", "system"];
+const csvList = (v) => typeof v === "string" ? v.split(",").map((s) => s.trim()).filter(Boolean) : v;
+const activityQuerySchema = cursorQuerySchema.extend({
+  kinds: z.preprocess(csvList, z.array(z.string())).optional()
+});
+const workspaceActivityQuerySchema = cursorQuerySchema.extend({
+  projectId: z.string().min(1).optional()
+});
+const DEVICE_PLATFORMS = [
+  "web",
+  "ios",
+  "ipados",
+  "android",
+  "macos",
+  "windows"
+];
+const PUSH_PLATFORMS = ["apns", "fcm", "wns", "webpush"];
+const deviceCreateSchema = z.object({
+  id: z.string().min(8).max(64).regex(/^dev_[0-9A-Za-z]+$/, "id must be a dev_ prefixed id"),
+  installId: z.string().min(1).max(128),
+  displayName: z.string().trim().min(1).max(80),
+  platform: z.enum(DEVICE_PLATFORMS),
+  appVersion: z.string().min(1).max(40)
+});
+const deviceUpdateSchema = z.object({
+  displayName: z.string().trim().min(1).max(80)
+});
+const pushTokenSetSchema = z.object({
+  platform: z.enum(PUSH_PLATFORMS),
+  token: z.string().min(1).max(4096),
+  environment: z.enum(["production", "sandbox"]).optional()
+});
+const CONSUMABLE_SOURCES = ["web", "apple", "google", "free"];
+const purchaseHandoffRequestSchema = z.object({
+  productId: z.string().optional(),
+  returnTo: z.string().min(1).max(2e3)
+});
+const purchaseHandoffRedeemSchema = z.object({
+  token: z.string().min(1)
+});
+const telemetryEventSchema = z.object({
+  name: z.string().min(1).max(120),
+  ts: z.string(),
+  /** Allow-listed, flat properties only: no script text, no free-form nesting. */
+  properties: z.record(
+    z.string(),
+    z.union([z.string().max(500), z.number(), z.boolean(), z.null()])
+  ).optional()
+});
+const clientErrorReportSchema = z.object({
+  message: z.string().min(1).max(2e3),
+  stack: z.string().max(8e3).optional(),
+  context: z.record(
+    z.string(),
+    z.union([z.string().max(500), z.number(), z.boolean(), z.null()])
+  ).optional()
+});
+const telemetryRequestSchema = z.object({
+  events: z.array(telemetryEventSchema).max(100),
+  errors: z.array(clientErrorReportSchema).max(20).optional()
+});
+const adminJobListQuerySchema = cursorQuerySchema.extend({
+  status: z.enum(JOB_STATUSES).optional(),
+  kind: z.string().optional()
+});
+const adminJobKindPatchSchema = z.object({
+  enabled: z.boolean().optional(),
+  maxAttempts: z.number().int().min(1).max(10).optional(),
+  maxRetries: z.number().int().min(0).max(10).optional(),
+  maxConcurrentPerUser: z.number().int().min(1).nullable().optional(),
+  maxConcurrentGlobal: z.number().int().min(1).nullable().optional(),
+  timeoutMs: z.number().int().min(1e3).optional()
+});
+const adminJobRefundSchema = z.object({
+  credits: z.number().int().positive().optional()
+});
+const COMMENTER_WRITABLE_KEYS = ["notes"];
+const isCommenterMark = (name) => name === "hl" || name.startsWith("n:");
+function markPermissionsFor(role) {
+  const edit = role === "owner" || role === "admin" || role === "writer";
+  const comment = edit || role === "commenter";
+  return { edit, comment, highlight: comment };
+}
+const canSendUpdates = (role) => role !== "viewer";
+const SYNC_PROTOCOL_VERSION = 1;
+const SYNC_SUBPROTOCOL = "fadewright-sync.v1";
+const SYNC_PATH = "/api/v1/sync";
+const SYNC_HEARTBEAT_MS = 25e3;
+const SYNC_MAX_FRAME_BYTES = 1048576;
+const SYNC_AUTH_TIMEOUT_MS = 5e3;
+const SYNC_MESSAGE_TYPES = {
+  auth: 0,
+  authOk: 1,
+  authError: 2,
+  reauth: 3,
+  ping: 4,
+  pong: 4,
+  subscribe: 10,
+  subscribed: 11,
+  subscribeError: 12,
+  unsubscribe: 13,
+  syncStep1: 20,
+  syncStep2: 21,
+  update: 22,
+  ack: 23,
+  reject: 24,
+  awareness: 30,
+  epochChanged: 40,
+  roleChanged: 41,
+  documentDeleted: 42,
+  normalized: 43,
+  serverShutdown: 50
+};
+const SYNC_CLOSE_CODES = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  MALFORMED_FRAME: 4400,
+  AUTH_TIMEOUT_OR_INVALID: 4401,
+  ACCOUNT_DISABLED_OR_DEVICE_REVOKED: 4403,
+  PROTOCOL_UNSUPPORTED: 4406,
+  HEARTBEAT_TIMEOUT: 4408,
+  /** Document epoch changed (snapshot open / version restore): resubscribe at the new epoch. */
+  EPOCH_CHANGED: 4409,
+  FRAME_TOO_LARGE: 4413,
+  RATE_LIMITED: 4429
+};
+const SYNC_AUTH_SCHEMES = ["firebase", "apikey", "link"];
+const SYNC_AUTH_ERROR_CODES = [
+  "UNAUTHENTICATED",
+  "ACCOUNT_DISABLED",
+  "DEVICE_REVOKED",
+  "LINK_EXPIRED",
+  "CLIENT_TOO_OLD",
+  "SERVER_TOO_OLD"
+];
+const SYNC_SUBSCRIBE_ERROR_CODES = [
+  "NOT_FOUND",
+  "FORBIDDEN",
+  "DOCUMENT_DELETED",
+  "EPOCH_MISMATCH",
+  "DOCUMENT_LOCKED",
+  "CLIENT_TOO_OLD"
+];
+const SYNC_REJECT_CODES = [
+  "FORBIDDEN",
+  "EPOCH_MISMATCH",
+  "UPDATE_INVALID",
+  "PAYLOAD_TOO_LARGE",
+  "SCHEMA_VIOLATION"
+];
+const SYNC_SUBSCRIBE_MODES = ["edit", "view"];
+const SYNC_EPOCH_REASONS = [
+  "snapshot-open",
+  "import-over",
+  "version-restore",
+  "schema-migration"
+];
+const roleOrNone = z.enum([
+  "owner",
+  "admin",
+  "writer",
+  "commenter",
+  "viewer",
+  "none"
+]);
+const bytes = z.instanceof(Uint8Array);
+const uint = z.number().int().min(0);
+const authPayloadSchema = z.object({
+  scheme: z.enum(SYNC_AUTH_SCHEMES),
+  token: z.string(),
+  deviceId: z.string(),
+  installId: z.string(),
+  clientVersion: z.string(),
+  schemaVersion: uint,
+  /** Unlock-session token (`POST /documents/:did/unlock-session`) for opening locked documents. */
+  unlockToken: z.string().optional()
+});
+const authOkPayloadSchema = z.object({
+  userId: z.string(),
+  sessionId: z.string(),
+  serverSchemaVersion: uint,
+  heartbeatMs: uint,
+  maxFrameBytes: uint
+});
+const authErrorPayloadSchema = z.object({
+  code: z.enum(SYNC_AUTH_ERROR_CODES),
+  message: z.string()
+});
+const reauthPayloadSchema = z.object({ token: z.string() });
+const pingPayloadSchema = z.object({ t: z.number() });
+const subscribePayloadSchema = z.object({
+  channelId: uint.min(1),
+  documentId: z.string(),
+  epoch: uint,
+  /** base64 state vector */
+  stateVector: z.string().optional(),
+  mode: z.enum(SYNC_SUBSCRIBE_MODES),
+  snapshotId: z.string().optional()
+});
+const subscribedPayloadSchema = z.object({
+  documentId: z.string(),
+  role: roleOrNone,
+  epoch: uint,
+  markPermissions: z.unknown(),
+  schemaVersion: uint
+});
+const subscribeErrorPayloadSchema = z.object({
+  code: z.enum(SYNC_SUBSCRIBE_ERROR_CODES),
+  detail: z.unknown().optional()
+});
+const unsubscribePayloadSchema = z.object({ channelId: uint.min(1) });
+const ackPayloadSchema = z.object({
+  clientSeq: uint,
+  serverSeq: uint
+});
+const rejectPayloadSchema = z.object({
+  clientSeq: uint,
+  code: z.enum(SYNC_REJECT_CODES),
+  detail: z.unknown().optional()
+});
+const epochChangedPayloadSchema = z.object({
+  newEpoch: uint,
+  reason: z.enum(SYNC_EPOCH_REASONS),
+  byUserId: z.string(),
+  snapshotId: z.string().optional()
+});
+const roleChangedPayloadSchema = z.object({
+  role: roleOrNone,
+  markPermissions: z.unknown()
+});
+const documentDeletedPayloadSchema = z.object({
+  byUserId: z.string(),
+  recoverableUntil: z.string()
+});
+const normalizedPayloadSchema = z.object({
+  serverSeq: uint,
+  contentHashes: z.record(z.string(), z.string())
+});
+const serverShutdownPayloadSchema = z.object({
+  reconnectAfterMs: uint
+});
+const ctl = z.literal(0);
+const chan = uint.min(1);
+const syncFrameSchema = z.discriminatedUnion("type", [
+  z.object({
+    channelId: ctl,
+    type: z.literal("auth"),
+    payload: authPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("authOk"),
+    payload: authOkPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("authError"),
+    payload: authErrorPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("reauth"),
+    payload: reauthPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("ping"),
+    payload: pingPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("pong"),
+    payload: pingPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("subscribe"),
+    payload: subscribePayloadSchema
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("subscribed"),
+    payload: subscribedPayloadSchema
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("subscribeError"),
+    payload: subscribeErrorPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("unsubscribe"),
+    payload: unsubscribePayloadSchema
+  }),
+  z.object({ channelId: chan, type: z.literal("syncStep1"), payload: bytes }),
+  z.object({ channelId: chan, type: z.literal("syncStep2"), payload: bytes }),
+  z.object({
+    channelId: chan,
+    type: z.literal("update"),
+    payload: z.object({ epoch: uint, clientSeq: uint, update: bytes })
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("ack"),
+    payload: ackPayloadSchema
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("reject"),
+    payload: rejectPayloadSchema
+  }),
+  z.object({ channelId: chan, type: z.literal("awareness"), payload: bytes }),
+  z.object({
+    channelId: chan,
+    type: z.literal("epochChanged"),
+    payload: epochChangedPayloadSchema
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("roleChanged"),
+    payload: roleChangedPayloadSchema
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("documentDeleted"),
+    payload: documentDeletedPayloadSchema
+  }),
+  z.object({
+    channelId: chan,
+    type: z.literal("normalized"),
+    payload: normalizedPayloadSchema
+  }),
+  z.object({
+    channelId: ctl,
+    type: z.literal("serverShutdown"),
+    payload: serverShutdownPayloadSchema
+  })
+]);
+const BIT8 = 128;
+const BITS7 = 127;
+const floor = Math.floor;
+const min = (a, b) => a < b ? a : b;
+const max = (a, b) => a > b ? a : b;
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const _encodeUtf8Polyfill = (str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = /** @type {number} */
+    encodedString.codePointAt(i);
+  }
+  return buf;
+};
+const utf8TextEncoder = (
+  /** @type {TextEncoder} */
+  typeof TextEncoder !== "undefined" ? new TextEncoder() : null
+);
+const _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
+const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+const _decodeUtf8Polyfill = (buf) => {
+  let remainingLen = buf.length;
+  let encodedString = "";
+  let bufPos = 0;
+  while (remainingLen > 0) {
+    const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+    const bytes2 = buf.subarray(bufPos, bufPos + nextLen);
+    bufPos += nextLen;
+    encodedString += String.fromCodePoint.apply(
+      null,
+      /** @type {any} */
+      bytes2
+    );
+    remainingLen -= nextLen;
+  }
+  return decodeURIComponent(escape(encodedString));
+};
+let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
+  utf8TextDecoder = null;
+}
+const _decodeUtf8Native = (buf) => (
+  /** @type {TextDecoder} */
+  utf8TextDecoder.decode(buf)
+);
+const decodeUtf8 = utf8TextDecoder ? _decodeUtf8Native : _decodeUtf8Polyfill;
+const create = (s) => new Error(s);
+class Encoder {
+  constructor() {
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    this.bufs = [];
+  }
+}
+const createEncoder = () => new Encoder();
+const length = (encoder) => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len;
+};
+const toUint8Array = (encoder) => {
+  const uint8arr = new Uint8Array(length(encoder));
+  let curPos = 0;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    const d = encoder.bufs[i];
+    uint8arr.set(d, curPos);
+    curPos += d.length;
+  }
+  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+  return uint8arr;
+};
+const write = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
+  }
+  encoder.cbuf[encoder.cpos++] = num;
+};
+const writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | BITS7 & num);
+    num = floor(num / 128);
+  }
+  write(encoder, BITS7 & num);
+};
+const _strBuffer = new Uint8Array(3e4);
+const _maxStrBSize = _strBuffer.length / 3;
+const _writeVarStringNative = (encoder, str) => {
+  if (str.length < _maxStrBSize) {
+    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+    writeVarUint(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write(encoder, _strBuffer[i]);
+    }
+  } else {
+    writeVarUint8Array(encoder, encodeUtf8(str));
+  }
+};
+const _writeVarStringPolyfill = (encoder, str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  writeVarUint(encoder, len);
+  for (let i = 0; i < len; i++) {
+    write(
+      encoder,
+      /** @type {number} */
+      encodedString.codePointAt(i)
+    );
+  }
+};
+utf8TextEncoder && /** @type {any} */
+utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
+const writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const rightCopyLen = uint8Array.length - leftCopyLen;
+  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+  encoder.cpos += leftCopyLen;
+  if (rightCopyLen > 0) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
+const errorUnexpectedEndOfArray = create("Unexpected end of array");
+const errorIntegerOutOfRange = create("Integer out of Range");
+class Decoder {
+  /**
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
+   */
+  constructor(uint8Array) {
+    this.arr = uint8Array;
+    this.pos = 0;
+  }
+}
+const createDecoder = (uint8Array) => new Decoder(uint8Array);
+const hasContent = (decoder) => decoder.pos !== decoder.arr.length;
+const readUint8Array = (decoder, len) => {
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view;
+};
+const readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
+const readTailAsUint8Array = (decoder) => readUint8Array(decoder, decoder.arr.length - decoder.pos);
+const readVarUint = (decoder) => {
+  let num = 0;
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    const r2 = decoder.arr[decoder.pos++];
+    num = num + (r2 & BITS7) * mult;
+    mult *= 128;
+    if (r2 < BIT8) {
+      return num;
+    }
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange;
+    }
+  }
+  throw errorUnexpectedEndOfArray;
+};
+class SyncCodecError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SyncCodecError";
+  }
+}
+const BINARY_TYPES = /* @__PURE__ */ new Set(["syncStep1", "syncStep2", "awareness"]);
+const NAME_BY_CODE = /* @__PURE__ */ new Map();
+for (const [name, code] of Object.entries(SYNC_MESSAGE_TYPES)) {
+  if (!NAME_BY_CODE.has(code))
+    NAME_BY_CODE.set(code, name);
+}
+function encodeFrame(frame) {
+  const enc = createEncoder();
+  writeVarUint(enc, frame.channelId);
+  writeVarUint(enc, SYNC_MESSAGE_TYPES[frame.type]);
+  if (BINARY_TYPES.has(frame.type)) {
+    writeVarUint8Array(enc, frame.payload);
+  } else if (frame.type === "update") {
+    writeVarUint(enc, frame.payload.epoch);
+    writeVarUint(enc, frame.payload.clientSeq);
+    writeVarUint8Array(enc, frame.payload.update);
+  } else {
+    writeUint8Array(
+      enc,
+      encodeUtf8(JSON.stringify(frame.payload))
+    );
+  }
+  return toUint8Array(enc);
+}
+function decodeFrame(bytes2) {
+  let candidate;
+  try {
+    const dec = createDecoder(bytes2);
+    const channelId = readVarUint(dec);
+    const code = readVarUint(dec);
+    const type = NAME_BY_CODE.get(code);
+    if (!type) throw new SyncCodecError(`unknown message type ${code}`);
+    let payload;
+    if (BINARY_TYPES.has(type)) {
+      payload = readVarUint8Array(dec);
+      if (hasContent(dec)) throw new SyncCodecError("trailing bytes");
+    } else if (type === "update") {
+      const epoch = readVarUint(dec);
+      const clientSeq = readVarUint(dec);
+      const update = readVarUint8Array(dec);
+      if (hasContent(dec)) throw new SyncCodecError("trailing bytes");
+      payload = { epoch, clientSeq, update };
+    } else {
+      const rest = readTailAsUint8Array(dec);
+      payload = JSON.parse(decodeUtf8(rest));
+    }
+    candidate = { channelId, type, payload };
+  } catch (e) {
+    if (e instanceof SyncCodecError) throw e;
+    throw new SyncCodecError(
+      `malformed frame: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  const parsed = syncFrameSchema.safeParse(candidate);
+  if (!parsed.success)
+    throw new SyncCodecError(`invalid frame: ${parsed.error.message}`);
+  return parsed.data;
+}
+export {
+  ACCOUNT_DELETE_CONFIRM,
+  ACCOUNT_EXPORT_FILENAME,
+  ACTIVITY_KINDS,
+  ACTOR_KINDS,
+  AI_CONSENT_VERSION,
+  AI_ENDPOINTS,
+  AI_ENDPOINT_OUTPUT_SCHEMAS,
+  AI_JOB_STATUSES,
+  AI_LIMITS,
+  AI_TASKS,
+  API_BASE_PATH,
+  API_ERROR_CODES,
+  API_KEY_FORMAT_RE,
+  API_KEY_MAX_ACTIVE,
+  API_KEY_SCOPES,
+  API_ROUTES,
+  ASSET_EXTENSIONS,
+  ASSET_KINDS,
+  ASSET_MAX_BYTES,
+  ASSET_ORIGINS,
+  ASSET_PART_SIZE_BYTES,
+  ASSET_ROLES,
+  ASSET_ROLE_ENTITY_KINDS,
+  ASSET_ROLE_GROUPS,
+  ASSET_ROLE_TARGETS,
+  ASSET_TARGET_KINDS,
+  ASSET_UPLOAD_CONCURRENCY,
+  ASSET_UPLOAD_TTL_S,
+  ASSET_URL_TTL_S,
+  ASSET_URL_VARIANTS,
+  ASSET_VERSION_STATUSES,
+  AUDIT_CSV_COLUMNS,
+  AUDIT_MAX_RANGE_DAYS,
+  AUTOCORRECT_MAX_PAIRS,
+  BATCH_WATERMARK_MAX_RECIPIENTS,
+  CHAT_BODY_MAX,
+  CHAT_EDIT_WINDOW_MINUTES,
+  CLIENT_AUTO_REASONS,
+  CLIENT_HEADER,
+  COMBINED_EXPORT_FORMATS,
+  COMBINED_EXPORT_MAX_DOCUMENTS,
+  COMMAND_BATCH_MAX,
+  COMMENTER_WRITABLE_KEYS,
+  COMPARE_GRANULARITIES,
+  COMPARE_MAX_PAGES,
+  CONSUMABLE_SOURCES,
+  CONVERSION_REPORT_OUTPUT,
+  COVERAGE_VERDICTS,
+  DEFAULT_PROJECT_ROLES,
+  DEVICE_CLASSES,
+  DEVICE_PLATFORMS,
+  DICTIONARY_MAX_WORDS,
+  DOCUMENT_KINDS2 as DOCUMENT_KINDS,
+  DOCUMENT_LABELS_MAX,
+  DOCUMENT_LABEL_MAX_CHARS,
+  DOCUMENT_VIEW_STATE_MAX_BYTES,
+  ELEMENT_BATCH_MAX,
+  ERROR_STATUS,
+  EXPORT_CODE_PREFIX,
+  EXPORT_FORMAT_IDS,
+  FOLDER_MAX_DEPTH,
+  FOUNTAIN_MAX_BYTES,
+  FWTEMPLATE_FORMAT,
+  FWTEMPLATE_FORMAT_VERSION,
+  IDEMPOTENCY_HEADER,
+  IDEMPOTENT_REPLAY_HEADER,
+  ID_PREFIXES,
+  IMPORT_FORMAT_IDS,
+  IMPORT_MAX_BYTES_DEFAULT,
+  INVITATION_STATUSES,
+  INVITATION_TARGETS,
+  INVITATION_TTL_DAYS,
+  JOB_EXPORT_FORMATS,
+  JOB_IMPORT_FORMATS,
+  JOB_KINDS,
+  JOB_LANES,
+  JOB_STATUSES,
+  JOB_WAIT_MAX_S,
+  JOB_WEBHOOK_SIGNATURE_HEADER,
+  LINK_SESSION_PREFIX,
+  LINK_SESSION_TTL_S,
+  LOCATOR_KINDS,
+  MACRO_TRIGGER_KINDS,
+  MCP_CLIENT_NAME,
+  NOTIFICATION_EMAIL_MODES,
+  NOTIFICATION_KINDS,
+  PACKET_INCLUDE_FLAGS,
+  PACKET_MAX_BYTES,
+  PACKET_VERSION,
+  PERMISSIONS,
+  PERMISSION_MIN_ROLE,
+  PROJECT_BIN_ITEM_MAX_BYTES,
+  PROJECT_KINDS,
+  PUSH_PLATFORMS,
+  REAUTH_MAX_AGE_S,
+  RECENT_SEARCHES_MAX,
+  REPORT_DEFS,
+  REPORT_FORMATS,
+  REPORT_KINDS,
+  REPORT_SYNC_MAX_PAGES,
+  RESOLVE_BATCH_MAX,
+  REVIEW_CATEGORIES,
+  ROLES,
+  ROLE_PERMISSIONS,
+  SCENE_BATCH_MAX,
+  SEARCH_HIT_TYPES,
+  SEVERITIES,
+  SHARE_LINK_ACCESS,
+  SHARE_LINK_GENERAL_ACCESS,
+  SHARE_LINK_TARGETS,
+  SHARE_LINK_TOKEN_PREFIX,
+  SHARE_ROLES,
+  SNAPSHOT_AUTO_REASONS,
+  SNAPSHOT_KINDS,
+  SNAPSHOT_NOTES_MAX,
+  SORT_OPTIONS,
+  STALENESS_TARGET_KINDS,
+  STALENESS_VALUES,
+  SUGGESTION_SET_STATUSES,
+  SUGGESTION_STATUSES,
+  SYNC_AUTH_ERROR_CODES,
+  SYNC_AUTH_SCHEMES,
+  SYNC_AUTH_TIMEOUT_MS,
+  SYNC_CLOSE_CODES,
+  SYNC_EPOCH_REASONS,
+  SYNC_HEARTBEAT_MS,
+  SYNC_MAX_FRAME_BYTES,
+  SYNC_MESSAGE_TYPES,
+  SYNC_PATH,
+  SYNC_PROTOCOL_VERSION,
+  SYNC_REJECT_CODES,
+  SYNC_SUBPROTOCOL,
+  SYNC_SUBSCRIBE_ERROR_CODES,
+  SYNC_SUBSCRIBE_MODES,
+  SyncCodecError,
+  TEAM_WORKSPACE_LIMIT,
+  TEMPLATE_FILE_FORMATS,
+  TERMINAL_JOB_STATUSES,
+  TRACKED_CHANGE_MODES,
+  TRASH_ITEM_TYPES,
+  TRASH_RETENTION_DAYS,
+  UI_LANGUAGES,
+  UNLOCK_SESSION_TTL_S,
+  UPLOAD_PURPOSES,
+  USER_MACRO_MAX,
+  USER_PREFERENCES_KEYS,
+  USER_PREFERENCES_MAX_BYTES,
+  USER_PREFERENCES_VERSION,
+  VERSION_REASONS,
+  WORKSPACE_CONTACTS_BATCH_MAX,
+  WORKSPACE_DEFAULTS_MAX_BYTES,
+  WORKSPACE_KINDS,
+  WRITING_GOALS_MAX,
+  WRITING_GOAL_KINDS,
+  WRITING_STATS_GRANULARITIES,
+  accountDeleteSchema,
+  accountExportInputSchema,
+  ackPayloadSchema,
+  activityQuerySchema,
+  adminJobKindPatchSchema,
+  adminJobListQuerySchema,
+  adminJobRefundSchema,
+  aiConsentAcceptSchema,
+  aiEndpointInputSchema,
+  aiEstimateRequestSchema,
+  aiJobCreateSchema,
+  aiJobOptionsSchema,
+  aiKindForTask,
+  aiScopeSchema,
+  aiTaskSchema,
+  anchorRefSchema,
+  apiKeyCreateSchema,
+  apiKeyScopeSchema,
+  apiKeyUpdateSchema,
+  applyTemplateJobInputSchema,
+  assetCompleteSchema,
+  assetDeriveInputSchema,
+  assetExtension,
+  assetKindSchema,
+  assetLinkCreateSchema,
+  assetLinkUpdateSchema,
+  assetListQuerySchema,
+  assetPartsRequestSchema,
+  assetProvenanceInputSchema,
+  assetRightsSchema,
+  assetRoleSchema,
+  assetSourceRefSchema,
+  assetTargetKindSchema,
+  assetUpdateSchema,
+  assetUploadRequestSchema,
+  assetUrlQuerySchema,
+  authErrorPayloadSchema,
+  authOkPayloadSchema,
+  authPayloadSchema,
+  batchWatermarkSchema,
+  canSendUpdates,
+  cellText,
+  changesQuerySchema,
+  characterPacketBodySchema,
+  characterPacketSchema,
+  chatMessageCreateSchema,
+  chatMessageUpdateSchema,
+  chatQuerySchema,
+  checkAssetFile,
+  chunkSummaryResponseSchema,
+  clientErrorReportSchema,
+  commandBatchRequestSchema,
+  compareRequestSchema,
+  coverageResponseSchema,
+  cursorQuerySchema,
+  decodeFrame,
+  defaultNotificationKindPrefs,
+  defaultNotificationPrefs,
+  deviceCreateSchema,
+  deviceUpdateSchema,
+  dictionaryUpdateSchema,
+  docSourceSchema,
+  documentApplyTemplateSchema,
+  documentAssetLinksQuerySchema,
+  documentCreateSchema,
+  documentDeletedPayloadSchema,
+  documentDuplicateSchema,
+  documentExportSchema,
+  documentImportSchema,
+  documentKindSchema,
+  documentLabelsSchema,
+  documentListQuerySchema,
+  documentMoveSchema,
+  documentSearchQuerySchema,
+  documentStalenessQuerySchema,
+  documentUpdateSchema,
+  documentViewStatePutSchema,
+  documentViewStateSchema,
+  elementHistoryQuerySchema,
+  elementsBatchRequestSchema,
+  encodeFrame,
+  entityDialogueQuerySchema,
+  entityListQuerySchema,
+  entityUsageQuerySchema,
+  epochChangedPayloadSchema,
+  errorResponse,
+  exportCombinedSchema,
+  exportCreateSchema,
+  exportJobInputSchema,
+  exportOptionsSchema,
+  fountainQuerySchema,
+  grantUpdateSchema,
+  hasPermission,
+  idKind,
+  idempotencyKeySchema,
+  importCreateSchema,
+  importJobInputSchema,
+  importOptionsSchema,
+  importOverJobInputSchema,
+  importOverSchema,
+  invitationAcceptSchema,
+  invitationCreateSchema,
+  isAiKind,
+  isCommenterMark,
+  isId,
+  isReportKind,
+  isTerminalJobStatus,
+  jobCreateSchema,
+  jobGetQuerySchema,
+  jobKindSchema,
+  jobListQuerySchema,
+  jobSourceSchema,
+  locationPacketBodySchema,
+  locationPacketSchema,
+  markPermissionsFor,
+  maxRole,
+  meUpdateSchema,
+  memberUpdateSchema,
+  mentionRefSchema,
+  mergeNotificationPrefs,
+  minRole,
+  newId,
+  normalizedPayloadSchema,
+  noteSchema,
+  notesQuerySchema,
+  notificationPrefsSchema,
+  notificationsQuerySchema,
+  notificationsReadSchema,
+  packetElementSchema,
+  packetQuerySchema,
+  parseReportOptions,
+  pingPayloadSchema,
+  polishResponseSchema,
+  projectBinCreateSchema,
+  projectCreateSchema,
+  projectDuplicateJobInputSchema,
+  projectDuplicateSchema,
+  projectFolderCreateSchema,
+  projectFolderDeleteQuerySchema,
+  projectFolderUpdateSchema,
+  projectKindSchema,
+  projectListQuerySchema,
+  projectPurgeSchema,
+  projectUpdateSchema,
+  purchaseHandoffRedeemSchema,
+  purchaseHandoffRequestSchema,
+  purgeInputSchema,
+  pushTokenSetSchema,
+  reauthPayloadSchema,
+  rejectPayloadSchema,
+  reportCreateSchema,
+  reportGetQuerySchema,
+  reportKindInfos,
+  reportRenderInputSchema,
+  reportToCsv,
+  requiredRoleFor,
+  resolveBatchSchema,
+  resolveOneQuerySchema,
+  roleAtLeast,
+  roleChangedPayloadSchema,
+  roleSchema,
+  scenePacketBodySchema,
+  scenePacketSchema,
+  scenesBatchRequestSchema,
+  searchQuerySchema,
+  serverShutdownPayloadSchema,
+  shareLinkCreateSchema,
+  shareLinkUpdateSchema,
+  shareUnlockSchema,
+  shotPacketBodySchema,
+  shotPacketSchema,
+  snapshotCommentAnchorSchema,
+  snapshotCommentCreateSchema,
+  snapshotCommentResolveSchema,
+  snapshotCommentsQuerySchema,
+  snapshotCreateSchema,
+  snapshotForkSchema,
+  snapshotNoteCreateSchema,
+  snapshotOpenSchema,
+  snapshotPrefsSchema,
+  sourceParamOf,
+  sourceParamSchema,
+  sourceQuerySchema,
+  sourceRefSchema,
+  subscribeErrorPayloadSchema,
+  subscribePayloadSchema,
+  subscribedPayloadSchema,
+  successResponse,
+  suggestionAcceptSchema,
+  suggestionDecideSchema,
+  suggestionRejectSchema,
+  syncFrameSchema,
+  tagsQuerySchema,
+  telemetryEventSchema,
+  telemetryRequestSchema,
+  templateCreateSchema,
+  templateExportQuerySchema,
+  templateGetQuerySchema,
+  templateImportByIdSchema,
+  templateImportSchema,
+  templateListQuerySchema,
+  templateThumbnailInputSchema,
+  templateUpdateSchema,
+  templateVersionCreateSchema,
+  trashEmptySchema,
+  unsubscribePayloadSchema,
+  uploadStateRequestSchema,
+  userMacroPatchSchema,
+  userMacroSchema,
+  userPreferencesPutSchema,
+  userPreferencesSchema,
+  versionRestoreAsCopySchema,
+  watermarkLookupSchema,
+  watermarkStyleSchema,
+  workspaceActivityQuerySchema,
+  workspaceAuditQuerySchema,
+  workspaceContactInputSchema,
+  workspaceContactPatchSchema,
+  workspaceContactsCreateSchema,
+  workspaceContactsQuerySchema,
+  workspaceCreateSchema,
+  workspaceDefaultsPutSchema,
+  workspaceDefaultsSchema,
+  workspaceDeleteSchema,
+  workspaceDocumentsQuerySchema,
+  workspaceKindSchema,
+  workspaceTransferSchema,
+  workspaceUpdateSchema,
+  writingGoalInputSchema,
+  writingGoalsPutSchema,
+  writingSessionSchema,
+  writingStatsQuerySchema
+};
+//# sourceMappingURL=index.js.map