deepspace 0.0.1 → 0.2.1

package/dist/worker.d.ts

@@ -0,0 +1,3173 @@
+import * as Y from 'yjs';
+import * as _ai_sdk_openai_compatible from '@ai-sdk/openai-compatible';
+import * as _ai_sdk_openai from '@ai-sdk/openai';
+import * as _ai_sdk_anthropic from '@ai-sdk/anthropic';
+import * as better_auth from 'better-auth';
+import * as better_auth_plugins from 'better-auth/plugins';
+
+/**
+ * Wire protocol constants.
+ *
+ * The JSON WebSocket protocol uses dotted string identifiers (e.g.
+ * `"game.input"`) as the `type` discriminator. All message types are
+ * grouped under a single `MSG` object so imports stay tidy:
+ *
+ *     import { MSG, dispatch, clientBuild } from 'deepspace'
+ *
+ *     dispatch<ServerMessage>(raw, {
+ *       [MSG.GAME_STATE]: (p) => { ... },
+ *       [MSG.GAME_TICK]:  (p) => { ... },
+ *     })
+ *
+ * Each key's value is the on-wire string — grep-friendly, self-
+ * documenting, and infinite per namespace. Adding a new message is one
+ * line here plus one arm in the discriminated union in `./messages.ts`.
+ *
+ * Yjs binary protocol constants (`MSG_YJS_SYNC`, `MSG_YJS_AWARENESS`) are
+ * intentionally kept numeric and separate from `MSG` — they ride a
+ * binary WebSocket frame format and aren't part of the JSON dispatcher.
+ */
+declare const MSG: {
+    readonly SUBSCRIBE: "core.subscribe";
+    readonly UNSUBSCRIBE: "core.unsubscribe";
+    readonly QUERY_RESULT: "core.query_result";
+    readonly RECORD_CHANGE: "core.record_change";
+    readonly PUT: "core.put";
+    readonly DELETE: "core.delete";
+    readonly ERROR: "core.error";
+    readonly USER_INFO: "user.info";
+    readonly USER_LIST: "user.list";
+    readonly SET_ROLE: "user.set_role";
+    readonly USER_UPDATE: "user.update";
+    readonly YJS_JOIN: "yjs.join";
+    readonly YJS_LEAVE: "yjs.leave";
+    readonly ACK: "records.ack";
+    readonly LIST_SCHEMAS: "records.list_schemas";
+    readonly RESUBSCRIBE: "records.resubscribe";
+    readonly GAME_STATE: "game.state";
+    readonly GAME_INPUT: "game.input";
+    readonly GAME_PLAYER_JOIN: "game.player_join";
+    readonly GAME_PLAYER_LEAVE: "game.player_leave";
+    readonly GAME_PLAYER_READY: "game.player_ready";
+    readonly GAME_START: "game.start";
+    readonly GAME_END: "game.end";
+    readonly GAME_TICK: "game.tick";
+    readonly CANVAS_SHAPES: "canvas.shapes";
+    readonly CANVAS_ADD: "canvas.add";
+    readonly CANVAS_MOVE: "canvas.move";
+    readonly CANVAS_RESIZE: "canvas.resize";
+    readonly CANVAS_DELETE: "canvas.delete";
+    readonly CANVAS_UPDATE: "canvas.update";
+    readonly CANVAS_VIEWPORT: "canvas.viewport";
+    readonly CANVAS_UNDO: "canvas.undo";
+    readonly CANVAS_REDO: "canvas.redo";
+    readonly CRON_TASKS: "cron.tasks";
+    readonly CRON_HISTORY: "cron.history";
+    readonly CRON_TRIGGER: "cron.trigger";
+    readonly CRON_PAUSE: "cron.pause";
+    readonly CRON_RESUME: "cron.resume";
+    readonly CRON_STATUS: "cron.status";
+    readonly PRESENCE_SYNC: "presence.sync";
+    readonly PRESENCE_JOIN: "presence.join";
+    readonly PRESENCE_LEAVE: "presence.leave";
+    readonly PRESENCE_UPDATE: "presence.update";
+    readonly GW_SCOPE_CONNECT: "gateway.scope_connect";
+    readonly GW_SCOPE_DISCONNECT: "gateway.scope_disconnect";
+    readonly GW_SCOPE_ERROR: "gateway.scope_error";
+    readonly GW_TOKEN_REFRESH: "gateway.token_refresh";
+    readonly GW_USER_UPDATE: "gateway.user_update";
+};
+/**
+ * Type of any message type constant — the union of every string literal
+ * stored in `MSG`. Useful when declaring functions that accept "any known
+ * message type" without enumerating all 54 strings by hand.
+ */
+type MsgType = (typeof MSG)[keyof typeof MSG];
+/** Outer envelope id for binary-framed yjs sync messages. Varuint-encoded. */
+declare const MSG_YJS_SYNC = 22;
+/** Outer envelope id for binary-framed yjs awareness messages. Varuint-encoded. */
+declare const MSG_YJS_AWARENESS = 23;
+/** Role assigned to unauthenticated WebSocket connections */
+declare const ROLE_ANONYMOUS = "viewer";
+/** Default role for newly registered authenticated users */
+declare const ROLE_DEFAULT = "member";
+/** Admin role */
+declare const ROLE_ADMIN = "admin";
+
+/**
+ * Typed wire-protocol layer — discriminated unions, typed builders, and a
+ * type-safe dispatcher for every `MSG.*` the SDK understands.
+ *
+ * Why this exists
+ * ---------------
+ *
+ * The string `MSG.*` constants in `./constants.ts` are the authoritative
+ * wire protocol, but using them directly is error-prone: a typo picks the
+ * wrong message with the wrong payload shape and fails silently at
+ * runtime. This module pairs every constant with its payload type, so
+ * that:
+ *
+ *   1. Building a message with `clientBuild.gameInput(...)` is payload-
+ *      checked at the call site — the compiler refuses to ship a wrong
+ *      shape.
+ *
+ *   2. Parsing an inbound message via `dispatch(raw, handlers)` narrows the
+ *      payload type inside each handler automatically, replacing the
+ *      unsafe `switch (msg.type) { case MSG.X: (payload as any).foo }`
+ *      pattern.
+ *
+ *   3. Tightening `BaseRoom.sendTo` / `BaseRoom.broadcast` /
+ *      `HandlerContext.send` / `SubscriptionContext.send` to accept
+ *      `ServerMessage` turns the type layer into enforcement: any room
+ *      that ships a payload inconsistent with its declared arm fails to
+ *      compile. Without that, the discriminated union is documentation,
+ *      not contract.
+ *
+ *   4. Adding a new `MSG.*` is localized: one entry in the discriminated
+ *      union, one builder function, one handler key in every dispatcher
+ *      that cares. No grep-and-fix across the codebase.
+ *
+ *   5. Apps can extend the SDK protocol without forking: `dispatch<M>` is
+ *      generic over any `M extends ProtocolMessage`, and builders are
+ *      plain objects so apps compose via spread (`{ ...clientBuild,
+ *      myMessage: ... }`).
+ *
+ * Direction split
+ * ---------------
+ *
+ * Some message types carry different payloads depending on who's sending.
+ * `MSG.GAME_START`, for example, is `{}` when the client requests a start
+ * but `{ state, tick }` when the server broadcasts the start event.
+ * `MSG.CANVAS_ADD` is a flat shape dict on the way in and a `{ shape }`
+ * wrapper on the way out. Modelling these with one union would force
+ * handlers to juggle a union payload — clunky and error-prone. Instead we
+ * split by direction:
+ *
+ *   - `ClientMessage` — what the client sends to the server
+ *   - `ServerMessage` — what the server sends to the client
+ *   - `ProtocolMessage = ClientMessage | ServerMessage` (for code that
+ *     really doesn't care — avoid when possible)
+ *
+ * Each side gets its own builder (`clientBuild` / `serverBuild`) and each
+ * side's dispatcher is parameterised with the union it expects.
+ *
+ * Payload strictness
+ * ------------------
+ *
+ * Where payload shapes are stable + narrow (ids, flags), we type them
+ * precisely. Where they're opaque or escape the protocol layer (record
+ * data blobs, Yjs binary frames, game-engine state), we use `unknown` and
+ * defer narrowing to the caller. This is intentional: over-typing opaque
+ * payloads would require the protocol layer to import application types
+ * and defeat the "thin wire contract" goal.
+ */
+
+/**
+ * The outer shape of every wire message. `T` is the string discriminator
+ * (e.g. `"game.input"`) — keeping it as a generic literal type lets the
+ * discriminated-union narrowing in `dispatch()` pick the right payload.
+ *
+ * Callers extending the protocol should pass a string-literal type for
+ * `T`, not the widened `string`. `BaseMessage<string, P>` collapses the
+ * discriminated union and handler-map key inference falls back to a
+ * single untyped `string` key, losing all narrowing.
+ */
+interface BaseMessage<T extends string, P> {
+    type: T;
+    payload: P;
+}
+/** Matches when a payload is intentionally empty — `{}` on the wire. */
+type EmptyPayload = Record<string, never>;
+/**
+ * Every message the client can legitimately send. Extend in app code with
+ * a string-literal union arm:
+ *
+ *     type MyClientMessage = ClientMessage | BaseMessage<'myapp.foo', { x: number }>
+ */
+type ClientMessage = BaseMessage<typeof MSG.SUBSCRIBE, {
+    subscriptionId: string;
+    query: unknown;
+}> | BaseMessage<typeof MSG.UNSUBSCRIBE, {
+    subscriptionId: string;
+}> | BaseMessage<typeof MSG.PUT, {
+    collection: string;
+    recordId: string;
+    data: Record<string, unknown>;
+    requestId?: string;
+}> | BaseMessage<typeof MSG.DELETE, {
+    collection: string;
+    recordId: string;
+    requestId?: string;
+}> | BaseMessage<typeof MSG.USER_LIST, EmptyPayload> | BaseMessage<typeof MSG.SET_ROLE, {
+    userId: string;
+    role: string;
+}> | BaseMessage<typeof MSG.USER_UPDATE, EmptyPayload> | BaseMessage<typeof MSG.LIST_SCHEMAS, EmptyPayload> | BaseMessage<typeof MSG.YJS_JOIN, {
+    collection: string;
+    recordId: string;
+    fieldName: string;
+}> | BaseMessage<typeof MSG.YJS_LEAVE, {
+    collection: string;
+    recordId: string;
+    fieldName: string;
+}> | BaseMessage<typeof MSG.GAME_INPUT, {
+    action: string;
+    data: Record<string, unknown>;
+}> | BaseMessage<typeof MSG.GAME_PLAYER_READY, EmptyPayload> | BaseMessage<typeof MSG.GAME_START, EmptyPayload> | BaseMessage<typeof MSG.GAME_END, EmptyPayload> | BaseMessage<typeof MSG.CANVAS_ADD, unknown> | BaseMessage<typeof MSG.CANVAS_MOVE, {
+    shapeId: string;
+    x: number;
+    y: number;
+}> | BaseMessage<typeof MSG.CANVAS_RESIZE, {
+    shapeId: string;
+    width: number;
+    height: number;
+    x?: number;
+    y?: number;
+}> | BaseMessage<typeof MSG.CANVAS_DELETE, {
+    shapeId: string;
+}> | BaseMessage<typeof MSG.CANVAS_UPDATE, {
+    shapeId: string;
+    props: Record<string, unknown>;
+}> | BaseMessage<typeof MSG.CANVAS_VIEWPORT, unknown> | BaseMessage<typeof MSG.CANVAS_UNDO, EmptyPayload> | BaseMessage<typeof MSG.CANVAS_REDO, EmptyPayload> | BaseMessage<typeof MSG.CRON_TRIGGER, {
+    taskName: string;
+}> | BaseMessage<typeof MSG.CRON_PAUSE, {
+    taskName: string;
+}> | BaseMessage<typeof MSG.CRON_RESUME, {
+    taskName: string;
+}> | BaseMessage<typeof MSG.PRESENCE_UPDATE, Record<string, unknown>> | BaseMessage<typeof MSG.GW_SCOPE_CONNECT, {
+    scopeType: string;
+    scopeId: string;
+}> | BaseMessage<typeof MSG.GW_SCOPE_DISCONNECT, {
+    scopeType: string;
+    scopeId: string;
+}> | BaseMessage<typeof MSG.GW_TOKEN_REFRESH, {
+    token: string;
+}>;
+/**
+ * Every message the server can send. Room and handler `send` / `broadcast`
+ * signatures are tightened to this union so outbound payloads are
+ * compile-checked against the wire contract. As with `ClientMessage`,
+ * extend via a string-literal union arm in app code when adding new
+ * server-side broadcasts.
+ */
+type ServerMessage = BaseMessage<typeof MSG.QUERY_RESULT, {
+    subscriptionId: string;
+    records: unknown[];
+}> | BaseMessage<typeof MSG.RECORD_CHANGE, {
+    collection: string;
+    record: unknown;
+    changeType: 'create' | 'update' | 'delete';
+}> | BaseMessage<typeof MSG.ERROR, {
+    error: string;
+    subscriptionId?: string;
+}> | BaseMessage<typeof MSG.ACK, {
+    requestId: string;
+    success: true;
+    recordId?: string;
+} | {
+    requestId: string;
+    success: false;
+    error: string;
+}> | BaseMessage<typeof MSG.RESUBSCRIBE, EmptyPayload> | BaseMessage<typeof MSG.LIST_SCHEMAS, {
+    schemas: unknown;
+}> | BaseMessage<typeof MSG.USER_INFO, unknown> | BaseMessage<typeof MSG.USER_LIST, {
+    users: unknown[];
+}> | BaseMessage<typeof MSG.YJS_JOIN, {
+    collection: string;
+    recordId: string;
+    fieldName: string;
+    canWrite: boolean;
+}> | BaseMessage<typeof MSG.GAME_STATE, {
+    state: unknown;
+    tick: number;
+    players: unknown[];
+    running: boolean;
+}> | BaseMessage<typeof MSG.GAME_TICK, {
+    state: unknown;
+    tick: number;
+}> | BaseMessage<typeof MSG.GAME_START, {
+    state: unknown;
+    tick: number;
+}> | BaseMessage<typeof MSG.GAME_END, {
+    state: unknown;
+    tick: number;
+}> | BaseMessage<typeof MSG.GAME_PLAYER_JOIN, {
+    player: unknown;
+}> | BaseMessage<typeof MSG.GAME_PLAYER_LEAVE, {
+    userId: string;
+}> | BaseMessage<typeof MSG.GAME_PLAYER_READY, {
+    userId: string;
+}> | BaseMessage<typeof MSG.CANVAS_SHAPES, {
+    shapes: unknown[];
+    viewports: unknown[];
+}> | BaseMessage<typeof MSG.CANVAS_ADD, {
+    shape: unknown;
+}> | BaseMessage<typeof MSG.CANVAS_MOVE, {
+    shapeId: string;
+    x: number;
+    y: number;
+}> | BaseMessage<typeof MSG.CANVAS_RESIZE, {
+    shapeId: string;
+    width: number;
+    height: number;
+    x?: number;
+    y?: number;
+}> | BaseMessage<typeof MSG.CANVAS_DELETE, {
+    shapeId: string;
+}> | BaseMessage<typeof MSG.CANVAS_UPDATE, {
+    shapeId: string;
+    props: Record<string, unknown>;
+}> | BaseMessage<typeof MSG.CANVAS_VIEWPORT, {
+    viewport: unknown;
+} | {
+    userId: string;
+    removed: true;
+}> | BaseMessage<typeof MSG.CRON_TASKS, {
+    tasks: unknown;
+}> | BaseMessage<typeof MSG.CRON_HISTORY, {
+    history: unknown;
+}> | BaseMessage<typeof MSG.CRON_STATUS, {
+    tasks: unknown;
+    recentHistory: unknown;
+}> | BaseMessage<typeof MSG.PRESENCE_SYNC, {
+    peers: unknown[];
+}> | BaseMessage<typeof MSG.PRESENCE_JOIN, {
+    peer: unknown;
+}> | BaseMessage<typeof MSG.PRESENCE_LEAVE, {
+    userId: string;
+}> | BaseMessage<typeof MSG.PRESENCE_UPDATE, {
+    userId: string;
+    state: Record<string, unknown>;
+}> | BaseMessage<typeof MSG.GW_SCOPE_ERROR, {
+    scopeType: string;
+    scopeId: string;
+    error: string;
+}> | BaseMessage<typeof MSG.GW_USER_UPDATE, unknown>;
+/**
+ * Any wire message, regardless of direction. Use this only when the code
+ * path genuinely doesn't care — otherwise pick `ClientMessage` or
+ * `ServerMessage` so the handler's payload type is narrower.
+ */
+type ProtocolMessage = ClientMessage | ServerMessage;
+/** Factories for every client → server message. */
+declare const clientBuild: {
+    subscribe: (subscriptionId: string, query: unknown) => {
+        readonly type: "core.subscribe";
+        readonly payload: {
+            readonly subscriptionId: string;
+            readonly query: unknown;
+        };
+    };
+    unsubscribe: (subscriptionId: string) => {
+        readonly type: "core.unsubscribe";
+        readonly payload: {
+            readonly subscriptionId: string;
+        };
+    };
+    put: (collection: string, recordId: string, data: Record<string, unknown>, requestId?: string) => {
+        readonly type: "core.put";
+        readonly payload: {
+            readonly collection: string;
+            readonly recordId: string;
+            readonly data: Record<string, unknown>;
+            readonly requestId: string | undefined;
+        };
+    };
+    remove: (collection: string, recordId: string, requestId?: string) => {
+        readonly type: "core.delete";
+        readonly payload: {
+            readonly collection: string;
+            readonly recordId: string;
+            readonly requestId: string | undefined;
+        };
+    };
+    userList: () => {
+        readonly type: "user.list";
+        readonly payload: EmptyPayload;
+    };
+    setRole: (userId: string, role: string) => {
+        readonly type: "user.set_role";
+        readonly payload: {
+            readonly userId: string;
+            readonly role: string;
+        };
+    };
+    userUpdate: () => {
+        readonly type: "user.update";
+        readonly payload: EmptyPayload;
+    };
+    listSchemas: () => {
+        readonly type: "records.list_schemas";
+        readonly payload: EmptyPayload;
+    };
+    yjsJoin: (collection: string, recordId: string, fieldName: string) => {
+        readonly type: "yjs.join";
+        readonly payload: {
+            readonly collection: string;
+            readonly recordId: string;
+            readonly fieldName: string;
+        };
+    };
+    yjsLeave: (collection: string, recordId: string, fieldName: string) => {
+        readonly type: "yjs.leave";
+        readonly payload: {
+            readonly collection: string;
+            readonly recordId: string;
+            readonly fieldName: string;
+        };
+    };
+    gameInput: (action: string, data?: Record<string, unknown>) => {
+        readonly type: "game.input";
+        readonly payload: {
+            readonly action: string;
+            readonly data: Record<string, unknown>;
+        };
+    };
+    gamePlayerReady: () => {
+        readonly type: "game.player_ready";
+        readonly payload: EmptyPayload;
+    };
+    gameStart: () => {
+        readonly type: "game.start";
+        readonly payload: EmptyPayload;
+    };
+    gameEnd: () => {
+        readonly type: "game.end";
+        readonly payload: EmptyPayload;
+    };
+    canvasAdd: (shape: Record<string, unknown>) => {
+        readonly type: "canvas.add";
+        readonly payload: Record<string, unknown>;
+    };
+    canvasMove: (shapeId: string, x: number, y: number) => {
+        readonly type: "canvas.move";
+        readonly payload: {
+            readonly shapeId: string;
+            readonly x: number;
+            readonly y: number;
+        };
+    };
+    canvasResize: (shapeId: string, width: number, height: number, x?: number, y?: number) => {
+        readonly type: "canvas.resize";
+        readonly payload: {
+            readonly shapeId: string;
+            readonly width: number;
+            readonly height: number;
+            readonly x: number | undefined;
+            readonly y: number | undefined;
+        };
+    };
+    canvasDelete: (shapeId: string) => {
+        readonly type: "canvas.delete";
+        readonly payload: {
+            readonly shapeId: string;
+        };
+    };
+    canvasUpdate: (shapeId: string, props: Record<string, unknown>) => {
+        readonly type: "canvas.update";
+        readonly payload: {
+            readonly shapeId: string;
+            readonly props: Record<string, unknown>;
+        };
+    };
+    canvasViewport: (viewport: Record<string, unknown>) => {
+        readonly type: "canvas.viewport";
+        readonly payload: Record<string, unknown>;
+    };
+    canvasUndo: () => {
+        readonly type: "canvas.undo";
+        readonly payload: EmptyPayload;
+    };
+    canvasRedo: () => {
+        readonly type: "canvas.redo";
+        readonly payload: EmptyPayload;
+    };
+    cronTrigger: (taskName: string) => {
+        readonly type: "cron.trigger";
+        readonly payload: {
+            readonly taskName: string;
+        };
+    };
+    cronPause: (taskName: string) => {
+        readonly type: "cron.pause";
+        readonly payload: {
+            readonly taskName: string;
+        };
+    };
+    cronResume: (taskName: string) => {
+        readonly type: "cron.resume";
+        readonly payload: {
+            readonly taskName: string;
+        };
+    };
+    presenceUpdate: (state: Record<string, unknown>) => {
+        readonly type: "presence.update";
+        readonly payload: Record<string, unknown>;
+    };
+    gwScopeConnect: (scopeType: string, scopeId: string) => {
+        readonly type: "gateway.scope_connect";
+        readonly payload: {
+            readonly scopeType: string;
+            readonly scopeId: string;
+        };
+    };
+    gwScopeDisconnect: (scopeType: string, scopeId: string) => {
+        readonly type: "gateway.scope_disconnect";
+        readonly payload: {
+            readonly scopeType: string;
+            readonly scopeId: string;
+        };
+    };
+    gwTokenRefresh: (token: string) => {
+        readonly type: "gateway.token_refresh";
+        readonly payload: {
+            readonly token: string;
+        };
+    };
+};
+/** Factories for every server → client message. Used by room DOs and
+ *  handler modules so server broadcasts are payload-checked too. Opaque
+ *  slots (`record`, `shape`, `peer`, etc.) take `unknown` so concrete
+ *  domain types — `RecordResult`, `CanvasShape`, `MediaPeer` — can be
+ *  passed without casts. */
+declare const serverBuild: {
+    queryResult: (subscriptionId: string, records: unknown[]) => {
+        readonly type: "core.query_result";
+        readonly payload: {
+            readonly subscriptionId: string;
+            readonly records: unknown[];
+        };
+    };
+    recordChange: (collection: string, record: unknown, changeType: "create" | "update" | "delete") => {
+        readonly type: "core.record_change";
+        readonly payload: {
+            readonly collection: string;
+            readonly record: unknown;
+            readonly changeType: "create" | "update" | "delete";
+        };
+    };
+    error: (error: string, subscriptionId?: string) => {
+        readonly type: "core.error";
+        readonly payload: {
+            readonly error: string;
+            readonly subscriptionId: string | undefined;
+        };
+    };
+    ackSuccess: (requestId: string, recordId?: string) => {
+        readonly type: "records.ack";
+        readonly payload: {
+            readonly requestId: string;
+            readonly success: true;
+            readonly recordId: string | undefined;
+        };
+    };
+    ackFailure: (requestId: string, error: string) => {
+        readonly type: "records.ack";
+        readonly payload: {
+            readonly requestId: string;
+            readonly success: false;
+            readonly error: string;
+        };
+    };
+    resubscribe: () => {
+        readonly type: "records.resubscribe";
+        readonly payload: EmptyPayload;
+    };
+    schemas: (schemas: unknown) => {
+        readonly type: "records.list_schemas";
+        readonly payload: {
+            readonly schemas: unknown;
+        };
+    };
+    userInfo: (user: unknown) => {
+        readonly type: "user.info";
+        readonly payload: unknown;
+    };
+    userList: (users: unknown[]) => {
+        readonly type: "user.list";
+        readonly payload: {
+            readonly users: unknown[];
+        };
+    };
+    yjsJoin: (collection: string, recordId: string, fieldName: string, canWrite: boolean) => {
+        readonly type: "yjs.join";
+        readonly payload: {
+            readonly collection: string;
+            readonly recordId: string;
+            readonly fieldName: string;
+            readonly canWrite: boolean;
+        };
+    };
+    gameState: (state: unknown, tick: number, players: unknown[], running: boolean) => {
+        readonly type: "game.state";
+        readonly payload: {
+            readonly state: unknown;
+            readonly tick: number;
+            readonly players: unknown[];
+            readonly running: boolean;
+        };
+    };
+    gameTick: (state: unknown, tick: number) => {
+        readonly type: "game.tick";
+        readonly payload: {
+            readonly state: unknown;
+            readonly tick: number;
+        };
+    };
+    gameStart: (state: unknown, tick: number) => {
+        readonly type: "game.start";
+        readonly payload: {
+            readonly state: unknown;
+            readonly tick: number;
+        };
+    };
+    gameEnd: (state: unknown, tick: number) => {
+        readonly type: "game.end";
+        readonly payload: {
+            readonly state: unknown;
+            readonly tick: number;
+        };
+    };
+    gamePlayerJoin: (player: unknown) => {
+        readonly type: "game.player_join";
+        readonly payload: {
+            readonly player: unknown;
+        };
+    };
+    gamePlayerLeave: (userId: string) => {
+        readonly type: "game.player_leave";
+        readonly payload: {
+            readonly userId: string;
+        };
+    };
+    gamePlayerReady: (userId: string) => {
+        readonly type: "game.player_ready";
+        readonly payload: {
+            readonly userId: string;
+        };
+    };
+    canvasShapes: (shapes: unknown[], viewports: unknown[]) => {
+        readonly type: "canvas.shapes";
+        readonly payload: {
+            readonly shapes: unknown[];
+            readonly viewports: unknown[];
+        };
+    };
+    canvasAdd: (shape: unknown) => {
+        readonly type: "canvas.add";
+        readonly payload: {
+            readonly shape: unknown;
+        };
+    };
+    canvasMove: (shapeId: string, x: number, y: number) => {
+        readonly type: "canvas.move";
+        readonly payload: {
+            readonly shapeId: string;
+            readonly x: number;
+            readonly y: number;
+        };
+    };
+    canvasResize: (shapeId: string, width: number, height: number, x?: number, y?: number) => {
+        readonly type: "canvas.resize";
+        readonly payload: {
+            readonly shapeId: string;
+            readonly width: number;
+            readonly height: number;
+            readonly x: number | undefined;
+            readonly y: number | undefined;
+        };
+    };
+    canvasDelete: (shapeId: string) => {
+        readonly type: "canvas.delete";
+        readonly payload: {
+            readonly shapeId: string;
+        };
+    };
+    canvasUpdate: (shapeId: string, props: Record<string, unknown>) => {
+        readonly type: "canvas.update";
+        readonly payload: {
+            readonly shapeId: string;
+            readonly props: Record<string, unknown>;
+        };
+    };
+    canvasViewport: (viewport: unknown) => {
+        readonly type: "canvas.viewport";
+        readonly payload: {
+            readonly viewport: unknown;
+        };
+    };
+    canvasViewportRemoved: (userId: string) => {
+        readonly type: "canvas.viewport";
+        readonly payload: {
+            readonly userId: string;
+            readonly removed: true;
+        };
+    };
+    cronTasks: (tasks: unknown) => {
+        readonly type: "cron.tasks";
+        readonly payload: {
+            readonly tasks: unknown;
+        };
+    };
+    cronHistory: (history: unknown) => {
+        readonly type: "cron.history";
+        readonly payload: {
+            readonly history: unknown;
+        };
+    };
+    cronStatus: (tasks: unknown, recentHistory: unknown) => {
+        readonly type: "cron.status";
+        readonly payload: {
+            readonly tasks: unknown;
+            readonly recentHistory: unknown;
+        };
+    };
+    presenceSync: (peers: unknown[]) => {
+        readonly type: "presence.sync";
+        readonly payload: {
+            readonly peers: unknown[];
+        };
+    };
+    presenceJoin: (peer: unknown) => {
+        readonly type: "presence.join";
+        readonly payload: {
+            readonly peer: unknown;
+        };
+    };
+    presenceLeave: (userId: string) => {
+        readonly type: "presence.leave";
+        readonly payload: {
+            readonly userId: string;
+        };
+    };
+    presenceUpdate: (userId: string, state: Record<string, unknown>) => {
+        readonly type: "presence.update";
+        readonly payload: {
+            readonly userId: string;
+            readonly state: Record<string, unknown>;
+        };
+    };
+    gwScopeError: (scopeType: string, scopeId: string, error: string) => {
+        readonly type: "gateway.scope_error";
+        readonly payload: {
+            readonly scopeType: string;
+            readonly scopeId: string;
+            readonly error: string;
+        };
+    };
+    gwUserUpdate: (user: unknown) => {
+        readonly type: "gateway.user_update";
+        readonly payload: unknown;
+    };
+};
+/**
+ * Handler map keyed by a message's string `type`. Every key maps to the
+ * payload type of the matching arm in `M`, so handlers get automatic
+ * payload narrowing with no runtime checks.
+ *
+ * Narrowing requires each `M` arm to use a string-literal `T`; widening
+ * `M` to `BaseMessage<string, unknown>` collapses all keys to a single
+ * untyped `string` and the map becomes a plain `Record<string, (p: unknown)
+ * => void>`.
+ */
+type MessageHandlers<M extends BaseMessage<string, unknown> = ProtocolMessage> = {
+    [K in M as K['type']]?: (payload: K['payload']) => void;
+};
+/**
+ * Parse and route an incoming wire message. Accepts either the raw JSON
+ * string (directly from `ws.onmessage`'s `event.data`) or an already-
+ * parsed object. Returns `true` if a handler ran, `false` otherwise
+ * (unrecognised type, parse failure, or malformed envelope).
+ *
+ * Defaults `M` to `ProtocolMessage` so callers who don't care about
+ * direction can just do `dispatch(raw, handlers)`; narrow with
+ * `dispatch<ClientMessage>` / `dispatch<ServerMessage>` to restrict which
+ * arms the handler map is allowed to cover.
+ */
+declare function dispatch<M extends BaseMessage<string, unknown> = ProtocolMessage>(raw: unknown, handlers: MessageHandlers<M>): boolean;
+/**
+ * Serialise a typed-built message for `ws.send`. A tiny wrapper around
+ * `JSON.stringify` kept around so call sites read as
+ * `ws.send(encode(clientBuild.gameInput(...)))` rather than paying
+ * attention to stringify arguments.
+ */
+declare function encode<M extends BaseMessage<string, unknown>>(message: M): string;
+
+/**
+ * BaseRoom — Abstract base class for all DeepSpace Durable Objects.
+ *
+ * Provides:
+ * - WebSocket upgrade with Cloudflare hibernation API
+ * - Connection tracking (WebSocket -> UserAttachment)
+ * - Auth: parse JWT-verified user info from URL search params
+ * - Presence: connected users list, awareness on connect/disconnect
+ * - Message routing: JSON parse -> dispatch by `type` field, binary hook
+ * - Raw SQLite access via this.sql
+ * - Broadcast helpers: broadcast(), sendTo()
+ * - HTTP fetch handler with WebSocket upgrade detection
+ *
+ * Subclasses implement lifecycle hooks:
+ *   onConnect, onMessage, onBinaryMessage, onDisconnect, onRequest, onAlarm
+ */
+
+interface UserAttachment {
+    userId: string;
+    userName: string;
+    userEmail: string;
+    userImageUrl?: string;
+    /** Subclass-specific data serialized alongside user info */
+    [key: string]: unknown;
+}
+declare abstract class BaseRoom {
+    protected state: DurableObjectState;
+    protected env: {
+        [key: string]: unknown;
+    };
+    protected sql: SqlStorage;
+    constructor(state: DurableObjectState, env: unknown);
+    fetch(request: Request): Promise<Response>;
+    private handleWebSocketUpgrade;
+    webSocketMessage(ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
+    webSocketClose(ws: WebSocket, code: number, reason: string): Promise<void>;
+    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+    alarm(): Promise<void>;
+    /**
+     * Called when a new WebSocket connects (after auth parsing).
+     * Return an augmented attachment to serialize on the WebSocket,
+     * or void to use the default attachment.
+     */
+    protected onConnect(ws: WebSocket, user: UserAttachment): UserAttachment | void | Promise<UserAttachment | void>;
+    /**
+     * Called for each parsed JSON message.
+     */
+    protected abstract onMessage(ws: WebSocket, user: UserAttachment, message: {
+        type: string;
+        [key: string]: unknown;
+    }): void | Promise<void>;
+    /**
+     * Called for binary messages (Yjs, custom protocols).
+     */
+    protected onBinaryMessage?(ws: WebSocket, user: UserAttachment, data: ArrayBuffer): void | Promise<void>;
+    /**
+     * Called when a WebSocket disconnects.
+     */
+    protected onDisconnect(ws: WebSocket, user: UserAttachment): void | Promise<void>;
+    /**
+     * Called for HTTP requests that are NOT WebSocket upgrades.
+     */
+    protected onRequest?(request: Request): Response | Promise<Response>;
+    /**
+     * Called on DO alarm.
+     */
+    protected onAlarm?(): void | Promise<void>;
+    /**
+     * Get all connected WebSockets.
+     */
+    protected getWebSockets(): WebSocket[];
+    /**
+     * Get the user attachment for a WebSocket.
+     */
+    protected getAttachment(ws: WebSocket): UserAttachment | null;
+    /**
+     * Get all currently connected users.
+     */
+    protected getConnectedUsers(): UserAttachment[];
+    /**
+     * Send a JSON message to a specific WebSocket.
+     *
+     * Typed as `ServerMessage` so every room's outbound traffic is
+     * compile-checked against the wire protocol contract. Passing
+     * `{ type: 'whatever', payload: {...} }` with a non-matching arm fails
+     * to compile — that's the whole point of the typed layer. Apps that
+     * need to send an app-specific message should override `sendTo` in
+     * their subclass with a widened union (`ServerMessage | MyAppMessage`).
+     */
+    protected sendTo(ws: WebSocket, message: ServerMessage): void;
+    /**
+     * Send binary data to a specific WebSocket.
+     */
+    protected sendBinaryTo(ws: WebSocket, data: Uint8Array | ArrayBuffer): void;
+    /**
+     * Broadcast a JSON message to all connected WebSockets.
+     * Optionally exclude a specific WebSocket (e.g. the sender).
+     *
+     * See `sendTo` for the reasoning behind typing as `ServerMessage`.
+     */
+    protected broadcast(message: ServerMessage, exclude?: WebSocket): void;
+    /**
+     * Broadcast binary data to all connected WebSockets.
+     */
+    protected broadcastBinary(data: Uint8Array | ArrayBuffer, exclude?: WebSocket): void;
+}
+
+interface Query {
+    collection: string;
+    where?: Record<string, unknown>;
+    orderBy?: string;
+    orderDir?: 'asc' | 'desc';
+    limit?: number;
+}
+interface Subscription {
+    id: string;
+    query: Query;
+}
+/** Key for Yjs doc: collection:recordId:fieldName */
+type YjsDocKey = string;
+interface YjsSubscription {
+    collection: string;
+    recordId: string;
+    fieldName: string;
+}
+interface DirectoryConversationData {
+    Name: string;
+    Description: string;
+    Type: string;
+    Visibility: string;
+    CreatedBy: string;
+    ParticipantHash: string;
+    ParticipantIds: string;
+    Status: string;
+    AssigneeId: string;
+    LinkedRef: string;
+    LastMessageAt: string;
+    LastMessagePreview: string;
+    LastMessageAuthor: string;
+    MessageCount: number;
+}
+interface ConversationStateData {
+    ConversationId: string;
+    UserId: string;
+    LastReadAt: string;
+    LastReadMessageCount: number;
+    Starred: number;
+    Archived: number;
+    Trashed: number;
+    Labels: string;
+    Folder: string;
+}
+interface DirectoryCommunityData {
+    Name: string;
+    Description: string;
+    CreatedBy: string;
+    Type: string;
+    Visibility: string;
+    MemberCount: number;
+    Rules: string;
+    IconUrl: string;
+    CoverUrl: string;
+}
+interface DirectoryMembershipData {
+    CommunityId: string;
+    UserId: string;
+    UserName: string;
+    Role: string;
+    JoinedAt: string;
+}
+interface DirectoryPostData {
+    Title: string;
+    Content: string;
+    AuthorId: string;
+    Type: string;
+    CommunityId: string;
+    ParentId: string;
+    ConversationId: string;
+    Status: string;
+    Tags: string;
+    LinkUrl: string;
+}
+interface ConvMessageData {
+    Content: string;
+    AuthorId: string;
+    ParentId: string;
+    Edited: number;
+    MessageType: string;
+    Metadata: string;
+}
+interface ConvReactionData {
+    MessageId: string;
+    Emoji: string;
+    UserId: string;
+}
+interface ConvMemberData {
+    UserId: string;
+    UserName: string;
+    Role: string;
+}
+interface ConvReadCursorData {
+    UserId: string;
+    LastReadAt: string;
+}
+interface ConvVoteData {
+    TargetId: string;
+    UserId: string;
+    Direction: number;
+}
+
+/**
+ * Server-specific protocol types
+ *
+ * These depend on Cloudflare Workers / Yjs imports and can't live in shared/types.
+ * All other protocol types (Query, payloads, etc.) live in shared/types/index.ts.
+ */
+
+/** Stored on WebSocket attachment (survives hibernation) */
+interface ConnectionAttachment extends UserAttachment {
+    role: string;
+    subscriptions: Subscription[];
+    /** Yjs docs this connection is editing */
+    yjsSubscriptions: YjsSubscription[];
+    /** Yjs client ID for awareness */
+    yjsClientId?: number;
+    /** Client-side Yjs awareness clientId (extracted from first awareness message) */
+    awarenessClientId?: number;
+}
+/**
+ * Context passed to handlers for accessing shared resources.
+ *
+ * `send` is typed against `ServerMessage` so every outbound message is
+ * compile-checked against the wire-protocol discriminated union. See
+ * `shared/protocol/messages.ts` for why.
+ */
+interface HandlerContext {
+    sql: SqlStorage;
+    state: DurableObjectState;
+    yjsDocs: Map<YjsDocKey, Y.Doc>;
+    getWebSockets(): Iterable<WebSocket>;
+    send(ws: WebSocket, message: ServerMessage): void;
+    sendBinary(ws: WebSocket, data: Uint8Array): void;
+}
+
+/**
+ * Collection Schema Definitions & Validation
+ *
+ * All collections use typed SQL columns. No document-mode / fields-based storage.
+ */
+type ColumnInterpretation = {
+    kind: 'plain';
+} | {
+    kind: 'currency';
+    symbol: string;
+    decimals: number;
+} | {
+    kind: 'date';
+    format?: string;
+} | {
+    kind: 'datetime';
+    format?: string;
+} | {
+    kind: 'boolean';
+    trueLabel?: string;
+    falseLabel?: string;
+} | {
+    kind: 'percent';
+    decimals?: number;
+} | {
+    kind: 'select';
+    options: string[];
+} | {
+    kind: 'multiselect';
+    options: string[];
+} | {
+    kind: 'url';
+} | {
+    kind: 'email';
+} | {
+    kind: 'json';
+} | {
+    kind: 'reference';
+    targetTable: string;
+    displayColumn: string;
+};
+interface ColumnDefinition {
+    /** Stable ID override (survives renames). Falls back to `col_{name}`. */
+    id?: string;
+    name: string;
+    storage: 'number' | 'text';
+    interpretation: ColumnInterpretation | string;
+    expression?: string;
+    /** Auto-populate with current user ID on create. */
+    userBound?: boolean;
+    /** Cannot be changed after initial creation. */
+    immutable?: boolean;
+    /** Must be provided on create (non-null). */
+    required?: boolean;
+    /** Default value if not provided on create. */
+    default?: unknown;
+    /** Auto-set ISO timestamp when the named field changes (optionally to a specific value). */
+    timestampTrigger?: {
+        field: string;
+        value?: unknown;
+    };
+}
+interface ResolvedColumn {
+    id: string;
+    name: string;
+    storage: 'number' | 'text';
+    interpretation: ColumnInterpretation;
+    expression?: string;
+    readonly: boolean;
+    userBound?: boolean;
+    immutable?: boolean;
+    required?: boolean;
+    default?: unknown;
+    timestampTrigger?: {
+        field: string;
+        value?: unknown;
+    };
+}
+declare function collectionTableName(name: string): string;
+declare function columnId(name: string): string;
+declare function resolveColumn(col: ColumnDefinition): ResolvedColumn;
+declare function rowToData(row: Record<string, unknown>, columns: ResolvedColumn[]): Record<string, unknown>;
+declare function dataToColumnValues(data: Record<string, unknown>, columns: ResolvedColumn[]): Record<string, unknown>;
+declare function coerceValue(value: unknown, storage: 'number' | 'text', interpretation: ColumnInterpretation): unknown;
+declare function buildTableSelect(collectionName: string, columns: ResolvedColumn[]): string;
+type PermissionLevel = boolean | 'own' | 'unclaimed-or-own' | 'collaborator' | 'team' | 'access' | 'published' | 'shared';
+interface RolePermissions {
+    read: PermissionLevel;
+    create: boolean;
+    update: PermissionLevel;
+    delete: PermissionLevel;
+    /** If set, only these columns can be updated by this role. */
+    writableFields?: string[];
+}
+interface CollectionSchema {
+    name: string;
+    /** Column definitions — every collection is stored in a typed SQL table. */
+    columns: ColumnDefinition[];
+    /** Composite uniqueness constraint (e.g., ['userId', 'taskId']). */
+    uniqueOn?: string[];
+    /** Column name used for ownership checks (default: `_created_by`). */
+    ownerField?: string;
+    /** Column containing JSON array of collaborator user IDs. */
+    collaboratorsField?: string;
+    /** Column containing team ID for team-based access. */
+    teamField?: string;
+    /**
+     * Column controlling per-record read visibility.
+     * String: visible when `data[field] === 'public'`.
+     * Object: visible when `data[field] === value`.
+     */
+    visibilityField?: string | {
+        field: string;
+        value: unknown;
+    };
+    /** Permissions per role. Use '*' for a catch-all fallback. */
+    permissions: Record<string, RolePermissions>;
+    /** Default role for new users (only on 'users' collection). */
+    defaultRole?: string;
+}
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    imageUrl?: string;
+    role: string;
+    createdAt: string;
+    lastSeenAt: string;
+}
+interface StoredRecord {
+    collection: string;
+    recordId: string;
+    data: Record<string, unknown>;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PermissionContext {
+    isTeamMember: (teamId: string, userId: string) => boolean;
+}
+declare const noopPermissionContext: PermissionContext;
+declare function getRolePermissions(schema: CollectionSchema, role: string): RolePermissions;
+declare function isOwner(schema: CollectionSchema, record: {
+    data: Record<string, unknown>;
+    createdBy: string;
+}, userId: string): boolean;
+declare function canRead(schema: CollectionSchema, role: string, record: {
+    data: Record<string, unknown>;
+    createdBy: string;
+    recordId?: string;
+}, userId: string, ctx?: PermissionContext): boolean;
+declare function canCreate(schema: CollectionSchema, role: string): boolean;
+declare function canUpdate(schema: CollectionSchema, role: string, record: {
+    data: Record<string, unknown>;
+    createdBy: string;
+    recordId?: string;
+}, userId: string, ctx?: PermissionContext): boolean;
+declare function canDelete(schema: CollectionSchema, role: string, record: {
+    data: Record<string, unknown>;
+    createdBy: string;
+    recordId?: string;
+}, userId: string, ctx?: PermissionContext): boolean;
+/** Check if a field update violates writableFields restrictions. */
+declare function checkFieldPermissions(schema: CollectionSchema, role: string, newData: Record<string, unknown>, existingData?: Record<string, unknown>): string | null;
+/** Names of columns managed by the system (registerUser), not client mutations. */
+declare const SYSTEM_MANAGED_COLUMNS: Set<string>;
+/** Standard user columns. Apps spread these into their users schema. */
+declare const USERS_COLUMNS: ColumnDefinition[];
+declare const BASE_USERS_SCHEMA: CollectionSchema;
+declare class SchemaRegistry {
+    private trusted;
+    constructor(schemas?: CollectionSchema[]);
+    registerTrusted(schema: CollectionSchema): void;
+    get(name: string): CollectionSchema | undefined;
+    has(name: string): boolean;
+    hasTrusted(name: string): boolean;
+    all(): CollectionSchema[];
+    names(): string[];
+}
+type PermissionSource = 'explicit' | 'wildcard' | 'default-deny';
+interface ResolvedPermission {
+    level: PermissionLevel | boolean;
+    source: PermissionSource;
+}
+interface CollectionPermissionSummary {
+    collection: string;
+    ownerField?: string;
+    collaboratorsField?: string;
+    teamField?: string;
+    columns: ColumnDefinition[];
+    permissions: Record<string, {
+        read: ResolvedPermission;
+        create: ResolvedPermission;
+        update: ResolvedPermission;
+        delete: ResolvedPermission;
+        writableFields?: string[];
+    }>;
+}
+interface PermissionAnalysis {
+    roles: string[];
+    collections: CollectionPermissionSummary[];
+}
+declare function analyzePermissions(schemas: CollectionSchema[]): PermissionAnalysis;
+
+/**
+ * RecordRoom Durable Object
+ *
+ * SQLite-based storage with query-based real-time subscriptions.
+ * Extends BaseRoom for WebSocket/connection infrastructure.
+ *
+ * Architecture:
+ * - Data stored in SQLite (single `records` table)
+ * - Clients subscribe to QUERIES, not collections
+ * - On record change, server evaluates which subscriptions match
+ * - Only matching subscribers receive updates
+ *
+ * Protocol:
+ * - SUBSCRIBE { subscriptionId, query } → QUERY_RESULT { subscriptionId, records }
+ * - UNSUBSCRIBE { subscriptionId }
+ * - PUT { collection, recordId, data } → broadcasts RECORD_CHANGE to matching
+ * - DELETE { collection, recordId } → broadcasts RECORD_CHANGE to matching
+ */
+
+/**
+ * RecordRoom configuration options
+ */
+interface RecordRoomConfig {
+    /**
+     * User ID of the app owner.
+     * This user automatically gets 'admin' role on connect.
+     */
+    ownerUserId?: string;
+}
+/**
+ * RecordRoom Durable Object
+ */
+declare class RecordRoom extends BaseRoom {
+    private schemaRegistry;
+    private initPromise;
+    /** Yjs docs loaded in memory (key: collection:recordId:fieldName) */
+    private yjsDocs;
+    /** Next Yjs client ID counter */
+    private nextYjsClientId;
+    /** Owner user ID — gets admin role automatically */
+    private ownerUserId;
+    /** True until the first fetch() completes — detects hibernation wake-up */
+    private freshConstruct;
+    constructor(state: DurableObjectState, env: unknown, schemas?: CollectionSchema[], config?: RecordRoomConfig);
+    private getPermissionContext;
+    fetch(request: Request): Promise<Response>;
+    /** Timing info from the current fetch(), used by onConnect for logging */
+    private _fetchTiming;
+    private ensureInitialized;
+    private initializeDatabase;
+    private migrateUsersTableIfExists;
+    private migrateRecordsTable;
+    private ensureCollectionTable;
+    private ensureAllCollectionTables;
+    protected onConnect(ws: WebSocket, user: UserAttachment): Promise<ConnectionAttachment>;
+    protected onMessage(ws: WebSocket, user: UserAttachment, msg: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    protected onBinaryMessage(ws: WebSocket, user: UserAttachment, data: ArrayBuffer): Promise<void>;
+    protected onDisconnect(ws: WebSocket, user: UserAttachment): void;
+    webSocketMessage(ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
+    webSocketClose(ws: WebSocket, code: number, reason: string): Promise<void>;
+    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+    private handleRecordMessage;
+    private handleListSchemas;
+    private createHandlerContext;
+    private createRecordContext;
+    private createUserContext;
+    private createYjsContext;
+    private send;
+    private sendBinaryHelper;
+}
+
+/**
+ * YjsRoom — Lightweight Durable Object for collaborative Yjs documents.
+ * Extends BaseRoom for WebSocket/connection infrastructure.
+ *
+ * Unlike RecordRoom (schemas, RBAC, queries, user state), YjsRoom is
+ * purpose-built for Yjs: sync, relay, persist. One DO per document.
+ *
+ * Architecture (SOTA for Yjs + Cloudflare DOs):
+ * - Auth verified at the worker edge, role passed to DO via URL params
+ * - DO is a thin Yjs sync relay: receive → apply → persist → broadcast
+ * - Viewers can observe but not write; members/admins can write
+ * - State persisted as a single binary blob in SQLite
+ *
+ * Uses the shared yjs-protocol.ts encoding utilities — no duplication.
+ */
+
+interface YjsAttachment extends UserAttachment {
+    role: string;
+    canWrite: boolean;
+    awarenessClientId: number | null;
+}
+declare class YjsRoom extends BaseRoom {
+    private doc;
+    private initialized;
+    constructor(state: DurableObjectState, env: unknown);
+    private ensureInitialized;
+    private getDoc;
+    private persistDoc;
+    protected onConnect(ws: WebSocket, user: UserAttachment): YjsAttachment;
+    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+    protected onBinaryMessage(ws: WebSocket, user: UserAttachment, data: ArrayBuffer): void;
+    protected onDisconnect(ws: WebSocket, user: UserAttachment): void;
+    private handleSync;
+    private handleAwareness;
+    private broadcastRaw;
+}
+
+/**
+ * GameRoom — Authoritative game loop Durable Object.
+ *
+ * Extends BaseRoom with:
+ * - Alarm-based tick loop with configurable interval
+ * - Player management (join, leave, ready state)
+ * - Input collection per tick, authoritative state computation
+ * - State broadcast to all connected players
+ *
+ * Subclasses implement game logic via lifecycle hooks:
+ *   onTick, onPlayerJoin, onPlayerLeave, onGameStart, onGameEnd
+ *
+ * Message types: game.*
+ */
+
+interface GameRoomConfig {
+    /** Ticks per second (default: 20) */
+    tickRate?: number;
+    /** Minimum players to start (default: 1) */
+    minPlayers?: number;
+    /** Maximum players (default: unlimited) */
+    maxPlayers?: number;
+}
+interface Player {
+    userId: string;
+    userName: string;
+    ready: boolean;
+    connectedAt: string;
+    data: Record<string, unknown>;
+}
+interface GameInput {
+    userId: string;
+    action: string;
+    data: Record<string, unknown>;
+    tick: number;
+}
+interface GameAttachment extends UserAttachment {
+    joinedAt: string;
+}
+declare abstract class GameRoom extends BaseRoom {
+    private config;
+    private players;
+    private inputBuffer;
+    private currentTick;
+    private gameState;
+    private running;
+    private initialized;
+    constructor(state: DurableObjectState, env: unknown, config?: GameRoomConfig);
+    private ensureInitialized;
+    private persistState;
+    protected onConnect(ws: WebSocket, user: UserAttachment): GameAttachment;
+    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    protected onDisconnect(ws: WebSocket, user: UserAttachment): void;
+    protected onAlarm(): Promise<void>;
+    private checkAutoStart;
+    private startGame;
+    private stopGame;
+    protected getGameState(): Record<string, unknown>;
+    protected setGameState(state: Record<string, unknown>): void;
+    protected getPlayers(): Player[];
+    protected isRunning(): boolean;
+    protected getCurrentTick(): number;
+    /**
+     * Called each tick with current state and collected inputs.
+     * Return the new game state, or undefined to keep current state.
+     */
+    protected abstract onTick(state: Record<string, unknown>, inputs: GameInput[], tick: number): Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined>;
+    /** Called when a player connects */
+    protected onPlayerJoin(player: Player): void;
+    /** Called when a player disconnects */
+    protected onPlayerLeave(player: Player): void;
+    /** Called when the game starts */
+    protected onGameStart(): void;
+    /** Called when the game ends */
+    protected onGameEnd(finalState: Record<string, unknown>): void;
+    /**
+     * Called once when the DO first hydrates persisted state from storage.
+     * Receives the parsed state blob as it was written by a previous build.
+     * Return the state object to install as `gameState`.
+     *
+     * Subclasses with evolving schemas should override this hook to:
+     *   - merge new fields onto a default template,
+     *   - upgrade shapes across versioned states,
+     *   - or discard stale blobs entirely by returning a fresh object.
+     *
+     * The default implementation is a pass-through, preserving the legacy
+     * "stored blob is gospel" behavior for subclasses that don't care.
+     *
+     * If JSON parsing of the stored blob fails this hook is NOT called — the
+     * DO starts with an empty state and the subclass's `onGameStart` (or
+     * first `onTick`) is responsible for initializing.
+     */
+    protected onHydrateState(stored: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * CanvasRoom — Spatial canvas Durable Object (tldraw-style).
+ *
+ * Extends BaseRoom with Yjs-backed spatial operations.
+ * Each shape is a Y.Map entry, enabling multi-user concurrent editing.
+ *
+ * Features:
+ * - Shape CRUD (add, move, resize, delete, update properties)
+ * - Viewport awareness (each user's visible region)
+ * - Per-user undo/redo stacks
+ *
+ * Message types: canvas.*
+ */
+
+interface CanvasShape {
+    id: string;
+    type: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    props: Record<string, unknown>;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Viewport {
+    userId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zoom: number;
+}
+interface CanvasAttachment extends UserAttachment {
+    viewport: Viewport | null;
+}
+declare class CanvasRoom extends BaseRoom {
+    private doc;
+    private initialized;
+    private viewports;
+    private undoStacks;
+    private redoStacks;
+    constructor(state: DurableObjectState, env: unknown);
+    private ensureInitialized;
+    private getDoc;
+    private persistDoc;
+    private getShapesMap;
+    fetch(request: Request): Promise<Response>;
+    protected onConnect(ws: WebSocket, user: UserAttachment): CanvasAttachment;
+    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    protected onDisconnect(ws: WebSocket, user: UserAttachment): void;
+    private pushUndo;
+    private clearRedo;
+    private handleUndo;
+    private handleRedo;
+    private getAllShapes;
+}
+
+/**
+ * PresenceRoom — Ephemeral presence-tracking Durable Object.
+ *
+ * Extends BaseRoom. No SQLite — purely in-memory presence state.
+ * Tracks who is present in a given scope (canvas, doc, thread, etc.)
+ * and broadcasts join/leave/state-update events to all connected peers.
+ *
+ * Each scope ID maps to its own DO instance. Clients connect via
+ * /ws/presence/:scopeId and receive real-time presence for that scope.
+ *
+ * Peers can attach arbitrary state (cursor position, typing indicator,
+ * viewport, selection, etc.) via MSG.PRESENCE_UPDATE.
+ *
+ * Message types: presence.*
+ */
+
+interface PresencePeer {
+    userId: string;
+    userName: string;
+    userEmail: string;
+    userImageUrl?: string;
+    joinedAt: string;
+    /** Arbitrary per-user state (cursor, typing, viewport, etc.) */
+    state: Record<string, unknown>;
+}
+interface PresenceAttachment extends UserAttachment {
+    joinedAt: string;
+}
+declare class PresenceRoom extends BaseRoom {
+    private peers;
+    private peerSockets;
+    constructor(state: DurableObjectState, env: unknown);
+    protected onConnect(ws: WebSocket, user: UserAttachment): PresenceAttachment;
+    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    protected onDisconnect(ws: WebSocket, user: UserAttachment): void;
+}
+
+/**
+ * CronRoom — Per-app scheduled task execution Durable Object.
+ *
+ * Extends BaseRoom. One DO per app shards cron work and avoids the
+ * dispatch-worker's global KV-poll bottleneck. The DO alarm triggers
+ * `onTask(name)` on the configured cadence; each execution is recorded
+ * to a per-app `cron_history` table. Subscribers (admin clients via the
+ * `useCronMonitor` hook) get pushes over the WebSocket.
+ *
+ * Tasks declare *either* `intervalMinutes` (run every N minutes) *or*
+ * `schedule` + `timezone` (5-field cron expression evaluated against an
+ * IANA timezone via `Intl.DateTimeFormat`). Cron mode is DST-aware
+ * because the wall-clock comparison happens after the timezone shift,
+ * not before.
+ *
+ * Message types: cron.*
+ */
+
+interface CronTask {
+    name: string;
+    /** Interval in minutes (interval mode) — mutually exclusive with `schedule`. */
+    intervalMinutes?: number;
+    /** 5-field cron expression (cron mode) — requires `timezone`. */
+    schedule?: string;
+    /** IANA timezone string (e.g. "America/New_York"). Required with `schedule`. */
+    timezone?: string;
+    /** Whether the task starts paused. */
+    paused?: boolean;
+}
+interface CronRoomConfig {
+    tasks: CronTask[];
+}
+interface CronExecution {
+    taskName: string;
+    startedAt: string;
+    completedAt: string | null;
+    success: boolean;
+    durationMs: number;
+    error?: string;
+}
+declare abstract class CronRoom extends BaseRoom {
+    private tasks;
+    private initialized;
+    constructor(state: DurableObjectState, env: unknown, config: CronRoomConfig);
+    private ensureInitialized;
+    fetch(request: Request): Promise<Response>;
+    protected onConnect(ws: WebSocket, user: UserAttachment): UserAttachment;
+    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    protected onAlarm(): Promise<void>;
+    private executeTask;
+    private scheduleNextAlarm;
+    private getTaskStates;
+    private getRecentHistory;
+    private broadcastStatus;
+    /**
+     * Execute a scheduled task by name.
+     * Called both by the alarm scheduler and manual trigger.
+     */
+    protected abstract onTask(taskName: string): void | Promise<void>;
+}
+
+/**
+ * DO Manifest — Dynamic Durable Object binding declarations.
+ *
+ * Apps export a `__DO_MANIFEST__` array in their worker.ts.
+ * The CLI extracts it and sends it to the deploy worker,
+ * which uses it to generate dynamic CF API bindings and migrations.
+ */
+interface DOManifestEntry {
+    /** CF binding name, e.g. 'RECORD_ROOMS' */
+    binding: string;
+    /** Exported class name, e.g. 'AppRecordRoom' */
+    className: string;
+    /** Whether this DO uses SQLite storage */
+    sqlite: boolean;
+}
+type DOManifest = DOManifestEntry[];
+/**
+ * Utility type: auto-generates Env bindings from a manifest.
+ *
+ * @example
+ * const manifest = [
+ *   { binding: 'RECORD_ROOMS', className: 'AppRecordRoom', sqlite: true },
+ *   { binding: 'GAME_ROOMS', className: 'AppGameRoom', sqlite: true },
+ * ] as const satisfies DOManifest
+ *
+ * type Env = BaseEnv & DOBindings<typeof manifest>
+ * // => { RECORD_ROOMS: DurableObjectNamespace; GAME_ROOMS: DurableObjectNamespace }
+ */
+type DOBindings<T extends readonly DOManifestEntry[]> = {
+    [K in T[number]['binding']]: DurableObjectNamespace;
+};
+/** Default manifest for apps that don't declare one */
+declare const DEFAULT_DO_MANIFEST: DOManifest;
+
+/**
+ * Messaging Schemas
+ *
+ * Pre-built collection schemas for messaging functionality.
+ * Any app can import these to add channels, messages, reactions, etc.
+ *
+ * @example
+ * ```typescript
+ * import { CHANNELS_SCHEMA, MESSAGES_SCHEMA, REACTIONS_SCHEMA } from 'deepspace/worker'
+ * export const schemas = [usersSchema, CHANNELS_SCHEMA, MESSAGES_SCHEMA, REACTIONS_SCHEMA]
+ * ```
+ */
+
+declare const CHANNELS_SCHEMA: CollectionSchema;
+declare const MESSAGES_SCHEMA: CollectionSchema;
+declare const REACTIONS_SCHEMA: CollectionSchema;
+declare const CHANNEL_MEMBERS_SCHEMA: CollectionSchema;
+declare const CHANNEL_INVITATIONS_SCHEMA: CollectionSchema;
+declare const READ_RECEIPTS_SCHEMA: CollectionSchema;
+
+/**
+ * Shared conversation schemas for RecordRoom-based conversations.
+ *
+ * These define the collections inside a per-conversation RecordRoom DO.
+ * Used by apps that have messaging/conversation features (slack-clone,
+ * helpdesk, mail, reddit-clone, etc.).
+ *
+ * Each conversation gets its own RecordRoom DO keyed by `conv:{id}`.
+ */
+
+declare const CONVERSATION_SCHEMAS: CollectionSchema[];
+/**
+ * Voting schemas for Reddit-style apps.
+ * Add these alongside CONVERSATION_SCHEMAS for apps that need voting.
+ */
+declare const VOTING_SCHEMAS: CollectionSchema[];
+
+/**
+ * Directory DO Schemas
+ *
+ * Purpose-built collections for the `dir:{appName}` global DO type.
+ * This is the cross-app-visible directory layer — any app can subscribe
+ * to another app's directory in real-time via SHARED_CONNECTIONS.
+ *
+ * Five collections covering all standard communication/social patterns:
+ * - conversations: channels, DMs, email threads, support chats
+ * - conversation_state: per-user metadata (read cursor, stars, labels, folders)
+ * - communities: groups, forums, boards, projects
+ * - memberships: user membership in communities
+ * - posts: feed items, tweets, Q&A questions, announcements
+ *
+ * Domain-specific data (tickets, CRM, procurement) stays in app DOs.
+ * Message content stays in conv:{id} DOs (CONVERSATION_SCHEMAS).
+ */
+
+/** All directory schemas for the `dir:{appName}` global DO type. */
+declare const DIRECTORY_SCHEMAS: CollectionSchema[];
+
+/**
+ * Workspace DO Schemas
+ *
+ * All collections for the workspace:default Durable Object.
+ * This DO consolidates shared, cross-app business data:
+ *
+ * - teams / team_members — workspace-wide team management (replaces built-in teams)
+ * - tasks / projects / tags — team-scoped task management
+ * - people — shared contacts directory
+ * - transactions / accounts — shared financial ledger
+ *
+ * Team-scoped collections use teamField RBAC: members see only
+ * their team's records; admins see everything.
+ */
+
+declare const workspaceTeamsSchema: CollectionSchema;
+declare const workspaceTeamMembersSchema: CollectionSchema;
+declare const workspaceTasksSchema: CollectionSchema;
+declare const workspaceProjectsSchema: CollectionSchema;
+declare const workspaceTagsSchema: CollectionSchema;
+declare const workspacePeopleSchema: CollectionSchema;
+declare const workspaceTransactionsSchema: CollectionSchema;
+declare const workspaceAccountsSchema: CollectionSchema;
+/**
+ * Universal sharing index. Any app can create share records for any content type.
+ *
+ * ContentType: 'document' | 'slide' | 'spreadsheet' | ... (extensible)
+ * ShareType:   'channel' | 'team' | 'direct' | 'link' | 'org' (extensible)
+ * ShareTarget: the ID of the target (channelId, teamId, userId, linkId, orgId)
+ * Permission:  'view' | 'edit' — what the share grants
+ *
+ * Content itself lives in the owner's app DO.
+ * This table is the discovery layer: "what has been shared, with whom, and how".
+ */
+declare const workspaceContentSharesSchema: CollectionSchema;
+declare const workspaceFormResponsesSchema: CollectionSchema;
+/**
+ * Maps DeepSpace users to their claimed @app.space email handles.
+ * Shared across all apps so any app can look up a user's email address.
+ * All handles are under the @app.space domain.
+ */
+declare const workspaceEmailHandlesSchema: CollectionSchema;
+declare const WORKSPACE_SCHEMAS: CollectionSchema[];
+
+/**
+ * Shared Durable Object Schemas
+ *
+ * Central registry of global DO types with fixed schemas.
+ * Apps connect to shared DOs via SHARED_CONNECTIONS in constants.ts.
+ * The ScopeRegistry resolves collection names to the correct scope automatically.
+ *
+ * Scope tiers:
+ * - App DO (app:{appHandle}) — private to each app, app defines tables
+ * - Dir DO (dir:{appHandle}) — cross-app directory (conversations, communities, posts)
+ * - Workspace DO (workspace:default) — shared business data (teams, tasks, people, ledger)
+ * - Conv DO (conv:{id}) — single conversation (messages, reactions, members)
+ */
+
+interface SharedConnection {
+    type: string;
+    instanceId?: string;
+}
+interface GlobalDOType {
+    name: string;
+    schemas: CollectionSchema[];
+    description: string;
+}
+declare const GLOBAL_DO_TYPES: GlobalDOType[];
+/** All valid global DO type names. */
+declare const GLOBAL_DO_TYPE_NAMES: string[];
+/** Look up a global DO type by name, returns null if not found. */
+declare function getGlobalDOType(name: string): GlobalDOType | null;
+/** Get the fixed schemas for a global DO type. Returns empty array if unknown type. */
+declare function getGlobalDOSchemas(typeName: string): CollectionSchema[];
+/** All collection names reserved by global DO types. Apps must not reuse these. */
+declare const RESERVED_COLLECTION_NAMES: Set<string>;
+
+/**
+ * Yjs Sync Protocol Implementation
+ *
+ * This implements the y-protocols sync and awareness protocols without
+ * depending on y-websocket internal paths. Makes it easier to bundle
+ * and template.
+ *
+ * Protocol spec: https://github.com/yjs/y-protocols
+ */
+
+declare const MSG_SYNC = 0;
+declare const MSG_AWARENESS = 1;
+declare const MSG_SYNC_STEP1 = 0;
+declare const MSG_SYNC_STEP2 = 1;
+declare const MSG_SYNC_UPDATE = 2;
+declare function createEncoder(): {
+    data: number[];
+};
+declare function toUint8Array(encoder: {
+    data: number[];
+}): Uint8Array;
+declare function writeVarUint(encoder: {
+    data: number[];
+}, num: number): void;
+declare function writeVarUint8Array(encoder: {
+    data: number[];
+}, arr: Uint8Array): void;
+declare function createDecoder(data: Uint8Array): {
+    data: Uint8Array;
+    pos: number;
+};
+declare function readVarUint(decoder: {
+    data: Uint8Array;
+    pos: number;
+}): number;
+declare function readVarUint8Array(decoder: {
+    data: Uint8Array;
+    pos: number;
+}): Uint8Array;
+declare function hasContent(decoder: {
+    data: Uint8Array;
+    pos: number;
+}): boolean;
+/**
+ * Encode sync step 1: our state vector
+ */
+declare function encodeSyncStep1(doc: Y.Doc): Uint8Array;
+/**
+ * Encode sync step 2: diff based on received state vector
+ */
+declare function encodeSyncStep2(doc: Y.Doc, stateVector: Uint8Array): Uint8Array;
+/**
+ * Encode an incremental update
+ */
+declare function encodeUpdate(update: Uint8Array): Uint8Array;
+interface SyncResult {
+    type: 'step1' | 'step2' | 'update';
+    response?: Uint8Array;
+    stateVector?: Uint8Array;
+    update?: Uint8Array;
+}
+/**
+ * Handle an incoming sync message
+ * Returns response to send (if any) and whether this was an update
+ */
+declare function handleSyncMessage(doc: Y.Doc, data: Uint8Array): SyncResult;
+interface AwarenessState {
+    [key: string]: unknown;
+}
+interface AwarenessStates {
+    [clientId: number]: AwarenessState;
+}
+/**
+ * Simple awareness implementation for presence/cursors
+ */
+declare class Awareness {
+    doc: Y.Doc;
+    clientID: number;
+    states: Map<number, AwarenessState>;
+    private meta;
+    private updateListeners;
+    private changeListeners;
+    constructor(doc: Y.Doc);
+    getStates(): Map<number, AwarenessState>;
+    getLocalState(): AwarenessState | null;
+    setLocalState(state: AwarenessState | null): void;
+    setLocalStateField(field: string, value: unknown): void;
+    on(event: 'update' | 'change', handler: (changes: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }) => void): void;
+    off(event: 'update' | 'change', handler: (changes: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }) => void): void;
+    private emit;
+    /**
+     * Encode awareness update for specific clients
+     */
+    encodeUpdate(clientIds?: number[]): Uint8Array;
+    /**
+     * Apply awareness update from another client
+     */
+    applyUpdate(data: Uint8Array): {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    };
+    /**
+     * Remove awareness states for disconnected clients
+     */
+    removeStates(clientIds: number[]): void;
+}
+/**
+ * Encode a full awareness message
+ */
+declare function encodeAwarenessMessage(awareness: Awareness, clientIds?: number[]): Uint8Array;
+/**
+ * Decode and apply awareness message
+ */
+declare function handleAwarenessMessage(awareness: Awareness, data: Uint8Array): {
+    added: number[];
+    updated: number[];
+    removed: number[];
+};
+/**
+ * Get message type from raw data
+ */
+declare function getMessageType(data: Uint8Array): number;
+
+/**
+ * Tools API Types and Definitions
+ *
+ * MCP-like interface for agent tool calls.
+ * Built-in tools for storage and backup operations.
+ */
+interface ToolSchema {
+    name: string;
+    description: string;
+    params: Record<string, {
+        type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+        description: string;
+        required?: boolean;
+        default?: unknown;
+    }>;
+}
+/**
+ * Discriminated union so callers don't have to guard on `error` being
+ * defined when `success` is false — TS enforces the invariant.
+ */
+type ToolResult = {
+    success: true;
+    data?: unknown;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Built-in tool definitions for storage, record, schema, user, and backup operations
+ */
+declare const BUILT_IN_TOOLS: ToolSchema[];
+
+/**
+ * Shared Scoped R2 Files Handler
+ *
+ * Provides a secure, prefix-scoped R2 files API that enforces:
+ *   1. All R2 keys are validated against the resolved prefix (no bypass)
+ *   2. Path traversal (`..`, `.`) is rejected
+ *   3. Mutations (upload/delete) require authentication by default
+ *
+ * Each worker provides a `resolvePrefix` callback for its scoping rules.
+ * The security invariants are enforced here once — not per-worker.
+ *
+ * Routes:
+ *   POST   /api/files/upload  → upload (prefix + generated key)
+ *   GET    /api/files          → list   (prefix + optional user prefix)
+ *   GET    /api/files/:key     → download (validated against prefix)
+ *   DELETE /api/files/:key     → delete   (validated against prefix)
+ */
+interface ScopeContext {
+    userId: string | null;
+    url: URL;
+}
+type PrefixResult = {
+    prefix: string;
+    error?: undefined;
+} | {
+    prefix?: undefined;
+    error: string;
+};
+interface ScopedR2Config {
+    /**
+     * Resolve the R2 key prefix for the given scope.
+     * Called with the `?scope=` query param value (default: 'self').
+     */
+    resolvePrefix: (scope: string, ctx: ScopeContext) => PrefixResult;
+    /**
+     * Require a non-null userId for upload and delete.
+     * @default true
+     */
+    requireAuthForMutations?: boolean;
+}
+interface ScopedR2Auth {
+    userId: string | null;
+}
+type ScopedR2Handler = (request: Request, url: URL, bucket: R2Bucket, auth: ScopedR2Auth) => Promise<Response>;
+/**
+ * Create a scoped R2 files handler.
+ *
+ * Security guarantees:
+ *   - Download/delete keys are validated to start with the resolved prefix
+ *   - Path traversal (`..`) is rejected at the entry point
+ *   - Mutations require a non-null userId by default
+ *
+ * @returns A handler function: `(request, url, bucket, auth) => Promise<Response>`
+ */
+declare function createScopedR2Handler(config: ScopedR2Config): ScopedR2Handler;
+
+/**
+ * Server Action Types
+ *
+ * Types for app-defined server actions that run in the site worker.
+ * Actions bypass user RBAC via the X-App-Action header — the app's
+ * server-side code IS the trust boundary.
+ */
+interface ActionResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+interface ActionTools {
+    create(collection: string, data: Record<string, unknown>): Promise<ActionResult>;
+    update(collection: string, recordId: string, data: Record<string, unknown>): Promise<ActionResult>;
+    remove(collection: string, recordId: string): Promise<ActionResult>;
+    get(collection: string, recordId: string): Promise<ActionResult>;
+    query(collection: string, options?: {
+        where?: Record<string, unknown>;
+        orderBy?: string;
+        orderDir?: 'asc' | 'desc';
+        limit?: number;
+    }): Promise<ActionResult>;
+    /** Call an integration endpoint (e.g. 'openai/completions') via the API worker */
+    integration(endpoint: string, data?: unknown): Promise<ActionResult>;
+}
+/**
+ * `TEnv` lets apps type the worker-scoped env object passed to the
+ * action handler. Defaults to a loose `Record<string, unknown>` so
+ * unparameterized handlers still compile; apps that want strict typing
+ * can do `ActionHandler<Env>` where Env is their own worker's bindings
+ * interface.
+ */
+interface ActionContext<TEnv = Record<string, unknown>> {
+    userId: string;
+    params: Record<string, unknown>;
+    tools: ActionTools;
+    /**
+     * The worker's env bindings. Used by actions that need access to
+     * secrets, bindings, or platform-injected values like `OWNER_USER_ID`
+     * (e.g. for owner-only action gating).
+     */
+    env: TEnv;
+}
+type ActionHandler<TEnv = Record<string, unknown>> = (ctx: ActionContext<TEnv>) => Promise<ActionResult>;
+
+/**
+ * Cron System — Server-Side Scheduled Tasks
+ *
+ * Provides CronContext for miniapp cron handlers and buildCronContext
+ * to construct it from worker environment bindings.
+ *
+ * CronContext gives handlers access to:
+ *   - records: Query/create/update/delete via RecordRoom tools API
+ *   - integrations: Call platform integration endpoints (billed to owner)
+ *   - ownerUserId: The app owner's user ID
+ */
+/** Context passed to cron handler functions */
+interface CronContext {
+    /** RecordRoom data access (queries the DO directly via tools API) */
+    records: {
+        query(collection: string, opts?: {
+            where?: Record<string, unknown>;
+            limit?: number;
+        }): Promise<any[]>;
+        create(collection: string, data: Record<string, unknown>): Promise<any>;
+        update(collection: string, recordId: string, data: Record<string, unknown>): Promise<any>;
+        delete(collection: string, recordId: string): Promise<any>;
+    };
+    /** Call platform integration endpoints, billed to owner */
+    integrations: {
+        call(endpoint: string, params: Record<string, unknown>): Promise<any>;
+    };
+    /** App owner's user ID */
+    ownerUserId: string;
+}
+/** Environment bindings needed by buildCronContext */
+interface CronEnv {
+    RECORD_ROOMS: DurableObjectNamespace;
+    INTERNAL_STORAGE_HMAC_SECRET?: string;
+    /** Override API base URL for local dev (defaults to https://api.deep.space) */
+    API_BASE_URL?: string;
+}
+/**
+ * Build a CronContext from worker environment bindings.
+ *
+ * @param env - Worker environment with RECORD_ROOMS DO namespace and HMAC secret
+ * @param ownerUserId - App owner's user ID (for RBAC and billing)
+ * @param roomId - RecordRoom ID (defaults to 'default')
+ */
+declare function buildCronContext(env: CronEnv, ownerUserId: string, roomId?: string): CronContext;
+
+/**
+ * Upstream worker proxy helpers.
+ *
+ * App workers reach the platform's other workers (api, platform, auth) through
+ * one of two transports:
+ *
+ *   1. **Service binding** (`env.API_WORKER` / `env.PLATFORM_WORKER`) — the
+ *      preferred path in production. Configured via wrangler `[[services]]`.
+ *      Cross-worker calls over plain `*.workers.dev` URLs return Cloudflare
+ *      error 1042 in production, so the binding is the only working path
+ *      in deployed apps.
+ *
+ *   2. **HTTPS URL** (`env.API_WORKER_URL` / `env.PLATFORM_WORKER_URL`) — the
+ *      fallback used in local development. `deepspace dev` writes these
+ *      into `.dev.vars`, which `wrangler dev` exposes as env vars. Service
+ *      bindings don't work cross-process under `wrangler dev` for SDK apps,
+ *      so the URL is the only working path in dev.
+ *
+ * The auth-worker has no service binding even in production — its responses
+ * carry `Set-Cookie` headers we want preserved verbatim, which we get for
+ * free over plain HTTPS. So `authWorkerFetch` is URL-only; the helper exists
+ * for surface consistency, not to switch transports.
+ *
+ * Each helper:
+ *   - Prefers the binding if present, falls back to the URL otherwise.
+ *   - Throws an actionable Error if neither is configured. No silent 502s.
+ *   - Forwards `init` (method/headers/body) verbatim to the upstream worker.
+ *
+ * History: a previous in-tree helper folded the binding/URL fallback into
+ * the AI module's `resolveTransport`. Inline call sites in the starter
+ * template (integrations, files, debug) used `c.env.X.fetch(...)` directly,
+ * which broke `npx deepspace dev` for any app calling those routes — the
+ * binding is undefined locally, so the fetch threw. These helpers
+ * standardize on the same shape `resolveTransport` had, so every upstream
+ * call works in both dev and prod.
+ */
+/**
+ * Env shape required by `apiWorkerFetch`. App workers should extend this
+ * (the starter template does) so the helper can be called with `c.env`.
+ */
+interface ApiWorkerEnv {
+    /** Cloudflare service binding for the api-worker. Preferred. */
+    API_WORKER?: Fetcher;
+    /** HTTPS URL for the api-worker. Used when the binding is absent (dev). */
+    API_WORKER_URL?: string;
+}
+/** Env shape required by `platformWorkerFetch`. */
+interface PlatformWorkerEnv {
+    /** Cloudflare service binding for the platform-worker. Preferred. */
+    PLATFORM_WORKER?: Fetcher;
+    /** HTTPS URL for the platform-worker. Used when the binding is absent. */
+    PLATFORM_WORKER_URL?: string;
+}
+/** Env shape required by `authWorkerFetch`. URL-only. */
+interface AuthWorkerEnv {
+    /** HTTPS URL for the auth-worker. Always required. */
+    AUTH_WORKER_URL?: string;
+}
+/**
+ * Fetch the api-worker. Prefers the `API_WORKER` service binding, falls
+ * back to `API_WORKER_URL` over HTTPS.
+ *
+ * `path` is treated as path-only — any host in a passed-in URL is
+ * stripped and replaced. This matches how `c.env.API_WORKER.fetch(...)`
+ * already worked in the starter template (the host was always a
+ * placeholder like `api-worker`).
+ */
+declare function apiWorkerFetch(env: ApiWorkerEnv, path: string, init?: RequestInit): Promise<Response>;
+/**
+ * Fetch the platform-worker. Prefers the `PLATFORM_WORKER` service binding,
+ * falls back to `PLATFORM_WORKER_URL` over HTTPS.
+ *
+ * Accepts a `Request` instance directly so callers can hand off
+ * `c.req.raw`-derived requests with their original method/headers/body
+ * intact. (`/api/files/*` does this — it forwards the caller's body
+ * stream verbatim.)
+ */
+declare function platformWorkerFetch(env: PlatformWorkerEnv, pathOrRequest: string | Request, init?: RequestInit): Promise<Response>;
+/**
+ * Fetch the auth-worker over HTTPS. URL-only — there is no auth-worker
+ * service binding, by design (we want plain-HTTP cookie semantics).
+ *
+ * Kept as a helper for surface symmetry with `apiWorkerFetch` /
+ * `platformWorkerFetch`. Throws if `AUTH_WORKER_URL` is unset.
+ */
+declare function authWorkerFetch(env: AuthWorkerEnv, path: string, init?: RequestInit): Promise<Response>;
+
+type Provider = 'anthropic' | 'openai' | 'cerebras';
+interface DeepSpaceAIEnv extends ApiWorkerEnv {
+    /**
+     * Long-lived owner-scoped JWT minted at deploy time (or by `deepspace dev`).
+     * Used as the default proxy auth token when `options.authToken` is absent.
+     * Bills the app owner.
+     */
+    APP_OWNER_JWT?: string;
+}
+interface DeepSpaceAIOptions {
+    /**
+     * Explicit auth token for this call. Use this for user-initiated flows
+     * where the caller's own JWT should be billed. If omitted, the helper
+     * falls back to `env.APP_OWNER_JWT` (bills the app owner).
+     *
+     * Billing is always against the JWT subject — to bill a different user,
+     * pass a JWT whose subject is that user. The proxy does not accept any
+     * client-supplied billing override.
+     */
+    authToken?: string;
+}
+/**
+ * Build an AI SDK provider that routes through the DeepSpace API worker.
+ *
+ * Resolves the transport (service binding or URL) and the auth token
+ * (explicit or `env.APP_OWNER_JWT`) automatically. Throws a clear error if
+ * either is unconfigured.
+ */
+declare function createDeepSpaceAI(env: DeepSpaceAIEnv, provider: Provider, options?: DeepSpaceAIOptions): _ai_sdk_anthropic.AnthropicProvider | _ai_sdk_openai.OpenAIProvider | _ai_sdk_openai_compatible.OpenAICompatibleProvider<string, string, string, string>;
+
+/**
+ * Auth types for the DeepSpace SDK.
+ *
+ * Provider-agnostic shapes for JWT verification (issuer, audience, azp
+ * matching, ES256 public key) and the HMAC-signed internal-request
+ * envelope used for worker-to-worker calls.
+ */
+interface JwtVerifierConfig {
+    /** PEM-encoded public key (ES256) for JWT verification */
+    publicKey: string;
+    /** Expected issuer (e.g. "https://auth.deep.space") */
+    issuer: string;
+    /** Expected audience (e.g. "https://api.deep.space") */
+    audience?: string | string[];
+    /** Allowed origins / authorized parties (supports wildcards like "https://*.app.space") */
+    authorizedParties?: string[];
+    /** Clock skew tolerance in milliseconds (default: 5000) */
+    clockSkewMs?: number;
+}
+interface JwtClaims {
+    sub: string;
+    iss?: string;
+    aud?: string | string[];
+    azp?: string;
+    exp?: number;
+    iat?: number;
+    name?: string;
+    email?: string;
+    image?: string;
+    [key: string]: unknown;
+}
+interface VerifiedAuth {
+    userId: string;
+    claims: JwtClaims;
+}
+interface VerifyResult extends VerifiedAuth {
+}
+interface TokenDebugInfo {
+    iss?: string | null;
+    aud?: string | string[] | null;
+    azp?: string | null;
+    exp?: number | null;
+    iat?: number | null;
+}
+interface VerifyOutcome {
+    result: VerifyResult | null;
+    debug?: TokenDebugInfo;
+    error?: unknown;
+}
+interface InternalSignature {
+    timestamp: string;
+    signature: string;
+}
+interface VerifyInternalSignatureInput {
+    secret: string | undefined;
+    timestamp: string | null | undefined;
+    signature: string | null | undefined;
+    payload: string;
+    maxSkewMs?: number;
+}
+interface SignInternalPayloadInput {
+    secret: string;
+    payload: string;
+    timestamp?: string;
+}
+
+/**
+ * JWT verification for DeepSpace workers.
+ *
+ * jose-based ES256 verification (jose runs on the Cloudflare Workers
+ * edge runtime). Imported public keys are cached per-PEM to avoid
+ * re-importing on every request, and `azp` is matched against an
+ * optional list of authorized-party patterns supporting `*` wildcards.
+ */
+
+/**
+ * Verify a DeepSpace JWT token.
+ *
+ * @param config - Verification configuration (public key, issuer, audience)
+ * @param token - The JWT string to verify
+ * @returns VerifyOutcome with either the verified result or error details
+ */
+declare function verifyJwt(config: JwtVerifierConfig, token: string | null | undefined): Promise<VerifyOutcome>;
+
+/**
+ * HMAC-based internal authentication for service-to-service calls.
+ *
+ * Ported as-is from Miyagi3 — this is auth-provider-agnostic.
+ */
+
+declare const DEFAULT_MAX_SKEW_MS: number;
+declare function computeHmacHex(secret: string, payload: string): Promise<string>;
+declare function timingSafeEqualHex(a: string, b: string): Promise<boolean>;
+declare function signInternalPayload({ secret, payload, timestamp, }: SignInternalPayloadInput): Promise<InternalSignature>;
+declare function verifyInternalSignature({ secret, timestamp, signature, payload, maxSkewMs, }: VerifyInternalSignatureInput): Promise<boolean>;
+declare function buildInternalPayload(body: unknown): string;
+
+declare function decodeJwtPayload(token: string | null | undefined): TokenDebugInfo | undefined;
+
+/**
+ * Better Auth configuration factory for DeepSpace
+ *
+ * Provides pre-configured Better Auth instances for Cloudflare Workers + D1.
+ */
+interface DeepSpaceAuthConfig {
+    /** D1 database binding */
+    database: D1Database;
+    /** Base URL for the auth worker (e.g. "https://auth.deep.space") */
+    baseURL: string;
+    /** Secret for session signing */
+    secret: string;
+    /** Google OAuth credentials (optional) */
+    google?: {
+        clientId: string;
+        clientSecret: string;
+    };
+    /** GitHub OAuth credentials (optional) */
+    github?: {
+        clientId: string;
+        clientSecret: string;
+    };
+    /** Enable email/password authentication */
+    emailAndPassword?: boolean;
+    /** Trusted origins for CORS */
+    trustedOrigins?: string[];
+}
+/**
+ * Create a Better Auth instance configured for DeepSpace.
+ *
+ * This is called per-request in the auth worker since D1 bindings
+ * are request-scoped in Cloudflare Workers.
+ */
+declare function createDeepSpaceAuth(config: DeepSpaceAuthConfig): better_auth.Auth<{
+    database: D1Database;
+    baseURL: string;
+    secret: string;
+    emailAndPassword: {
+        enabled: boolean;
+    };
+    socialProviders: Record<string, {
+        clientId: string;
+        clientSecret: string;
+    }>;
+    trustedOrigins: string[];
+    plugins: [{
+        id: "organization";
+        endpoints: better_auth_plugins.OrganizationEndpoints<better_auth_plugins.OrganizationOptions & {
+            teams: {
+                enabled: true;
+            };
+            dynamicAccessControl?: {
+                enabled?: false | undefined;
+            } | undefined;
+        }> & better_auth_plugins.TeamEndpoints<better_auth_plugins.OrganizationOptions & {
+            teams: {
+                enabled: true;
+            };
+            dynamicAccessControl?: {
+                enabled?: false | undefined;
+            } | undefined;
+        }>;
+        schema: better_auth_plugins.OrganizationSchema<better_auth_plugins.OrganizationOptions & {
+            teams: {
+                enabled: true;
+            };
+            dynamicAccessControl?: {
+                enabled?: false | undefined;
+            } | undefined;
+        }>;
+        $Infer: {
+            Organization: {
+                id: string;
+                name: string;
+                slug: string;
+                createdAt: Date;
+                logo?: string | null | undefined;
+                metadata?: any;
+            };
+            Invitation: {
+                id: string;
+                organizationId: string;
+                email: string;
+                role: "member" | "admin" | "owner";
+                status: better_auth_plugins.InvitationStatus;
+                inviterId: string;
+                expiresAt: Date;
+                createdAt: Date;
+                teamId?: string | undefined | undefined;
+            };
+            Member: {
+                id: string;
+                organizationId: string;
+                role: "member" | "admin" | "owner";
+                createdAt: Date;
+                userId: string;
+                teamId?: string | undefined | undefined;
+                user: {
+                    id: string;
+                    email: string;
+                    name: string;
+                    image?: string | undefined;
+                };
+            };
+            Team: {
+                id: string;
+                name: string;
+                organizationId: string;
+                createdAt: Date;
+                updatedAt?: Date | undefined;
+            };
+            TeamMember: {
+                id: string;
+                teamId: string;
+                userId: string;
+                createdAt: Date;
+            };
+            ActiveOrganization: {
+                members: {
+                    id: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                    createdAt: Date;
+                    userId: string;
+                    teamId?: string | undefined | undefined;
+                    user: {
+                        id: string;
+                        email: string;
+                        name: string;
+                        image?: string | undefined;
+                    };
+                }[];
+                invitations: {
+                    id: string;
+                    organizationId: string;
+                    email: string;
+                    role: "member" | "admin" | "owner";
+                    status: better_auth_plugins.InvitationStatus;
+                    inviterId: string;
+                    expiresAt: Date;
+                    createdAt: Date;
+                    teamId?: string | undefined | undefined;
+                }[];
+                teams: {
+                    id: string;
+                    name: string;
+                    organizationId: string;
+                    createdAt: Date;
+                    updatedAt?: Date | undefined;
+                }[];
+            } & {
+                id: string;
+                name: string;
+                slug: string;
+                createdAt: Date;
+                logo?: string | null | undefined;
+                metadata?: any;
+            };
+        };
+        $ERROR_CODES: {
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION">;
+            YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS: better_auth.RawError<"YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS">;
+            ORGANIZATION_ALREADY_EXISTS: better_auth.RawError<"ORGANIZATION_ALREADY_EXISTS">;
+            ORGANIZATION_SLUG_ALREADY_TAKEN: better_auth.RawError<"ORGANIZATION_SLUG_ALREADY_TAKEN">;
+            ORGANIZATION_NOT_FOUND: better_auth.RawError<"ORGANIZATION_NOT_FOUND">;
+            USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION: better_auth.RawError<"USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION">;
+            NO_ACTIVE_ORGANIZATION: better_auth.RawError<"NO_ACTIVE_ORGANIZATION">;
+            USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION: better_auth.RawError<"USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION">;
+            MEMBER_NOT_FOUND: better_auth.RawError<"MEMBER_NOT_FOUND">;
+            ROLE_NOT_FOUND: better_auth.RawError<"ROLE_NOT_FOUND">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM">;
+            TEAM_ALREADY_EXISTS: better_auth.RawError<"TEAM_ALREADY_EXISTS">;
+            TEAM_NOT_FOUND: better_auth.RawError<"TEAM_NOT_FOUND">;
+            YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER: better_auth.RawError<"YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER">;
+            YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER: better_auth.RawError<"YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER">;
+            YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION">;
+            USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION: better_auth.RawError<"USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION">;
+            INVITATION_NOT_FOUND: better_auth.RawError<"INVITATION_NOT_FOUND">;
+            YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION: better_auth.RawError<"YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION">;
+            EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION: better_auth.RawError<"EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION">;
+            YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION">;
+            INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION: better_auth.RawError<"INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE">;
+            FAILED_TO_RETRIEVE_INVITATION: better_auth.RawError<"FAILED_TO_RETRIEVE_INVITATION">;
+            YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS: better_auth.RawError<"YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS">;
+            UNABLE_TO_REMOVE_LAST_TEAM: better_auth.RawError<"UNABLE_TO_REMOVE_LAST_TEAM">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER">;
+            ORGANIZATION_MEMBERSHIP_LIMIT_REACHED: better_auth.RawError<"ORGANIZATION_MEMBERSHIP_LIMIT_REACHED">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM">;
+            INVITATION_LIMIT_REACHED: better_auth.RawError<"INVITATION_LIMIT_REACHED">;
+            TEAM_MEMBER_LIMIT_REACHED: better_auth.RawError<"TEAM_MEMBER_LIMIT_REACHED">;
+            USER_IS_NOT_A_MEMBER_OF_THE_TEAM: better_auth.RawError<"USER_IS_NOT_A_MEMBER_OF_THE_TEAM">;
+            YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM: better_auth.RawError<"YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM">;
+            YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM: better_auth.RawError<"YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER">;
+            YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER">;
+            YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION">;
+            MISSING_AC_INSTANCE: better_auth.RawError<"MISSING_AC_INSTANCE">;
+            YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE: better_auth.RawError<"YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE">;
+            TOO_MANY_ROLES: better_auth.RawError<"TOO_MANY_ROLES">;
+            INVALID_RESOURCE: better_auth.RawError<"INVALID_RESOURCE">;
+            ROLE_NAME_IS_ALREADY_TAKEN: better_auth.RawError<"ROLE_NAME_IS_ALREADY_TAKEN">;
+            CANNOT_DELETE_A_PRE_DEFINED_ROLE: better_auth.RawError<"CANNOT_DELETE_A_PRE_DEFINED_ROLE">;
+            ROLE_IS_ASSIGNED_TO_MEMBERS: better_auth.RawError<"ROLE_IS_ASSIGNED_TO_MEMBERS">;
+        };
+        options: NoInfer<better_auth_plugins.OrganizationOptions & {
+            teams: {
+                enabled: true;
+            };
+            dynamicAccessControl?: {
+                enabled?: false | undefined;
+            } | undefined;
+        }>;
+    }, {
+        id: "two-factor";
+        endpoints: {
+            enableTwoFactor: better_auth.StrictEndpoint<"/two-factor/enable", {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    password: better_auth.ZodString;
+                    issuer: better_auth.ZodOptional<better_auth.ZodString>;
+                }, better_auth.$strip>;
+                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                totpURI: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                backupCodes: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                totpURI: string;
+                backupCodes: string[];
+            }>;
+            disableTwoFactor: better_auth.StrictEndpoint<"/two-factor/disable", {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    password: better_auth.ZodString;
+                }, better_auth.$strip>;
+                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyBackupCode: better_auth.StrictEndpoint<"/two-factor/verify-backup-code", {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    code: better_auth.ZodString;
+                    disableSession: better_auth.ZodOptional<better_auth.ZodBoolean>;
+                    trustDevice: better_auth.ZodOptional<better_auth.ZodBoolean>;
+                }, better_auth.$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    type: string;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        email: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        emailVerified: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        image: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        twoFactorEnabled: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                                session: {
+                                                    type: string;
+                                                    properties: {
+                                                        token: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        userId: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        expiresAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string | undefined;
+                user: (Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }) | better_auth_plugins.UserWithTwoFactor;
+            }>;
+            generateBackupCodes: better_auth.StrictEndpoint<"/two-factor/generate-backup-codes", {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    password: better_auth.ZodString;
+                }, better_auth.$strip>;
+                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                                backupCodes: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            viewBackupCodes: better_auth.StrictEndpoint<string, {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    userId: better_auth.ZodCoercedString<unknown>;
+                }, better_auth.$strip>;
+            }, {
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            sendTwoFactorOTP: better_auth.StrictEndpoint<"/two-factor/send-otp", {
+                method: "POST";
+                body: better_auth.ZodOptional<better_auth.ZodObject<{
+                    trustDevice: better_auth.ZodOptional<better_auth.ZodBoolean>;
+                }, better_auth.$strip>>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyTwoFactorOTP: better_auth.StrictEndpoint<"/two-factor/verify-otp", {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    code: better_auth.ZodString;
+                    trustDevice: better_auth.ZodOptional<better_auth.ZodBoolean>;
+                }, better_auth.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    type: string;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        email: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        emailVerified: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        image: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: better_auth_plugins.UserWithTwoFactor;
+            } | {
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+            generateTOTP: better_auth.StrictEndpoint<string, {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    secret: better_auth.ZodString;
+                }, better_auth.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                code: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                code: string;
+            }>;
+            getTOTPURI: better_auth.StrictEndpoint<"/two-factor/get-totp-uri", {
+                method: "POST";
+                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                body: better_auth.ZodObject<{
+                    password: better_auth.ZodString;
+                }, better_auth.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                totpURI: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                totpURI: string;
+            }>;
+            verifyTOTP: better_auth.StrictEndpoint<"/two-factor/verify-totp", {
+                method: "POST";
+                body: better_auth.ZodObject<{
+                    code: better_auth.ZodString;
+                    trustDevice: better_auth.ZodOptional<better_auth.ZodBoolean>;
+                }, better_auth.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: better_auth_plugins.UserWithTwoFactor;
+            } | {
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+        };
+        options: NoInfer<better_auth_plugins.TwoFactorOptions>;
+        hooks: {
+            after: {
+                matcher(context: better_auth.HookEndpointContext): boolean;
+                handler: (inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
+                    twoFactorRedirect: boolean;
+                } | undefined>;
+            }[];
+        };
+        schema: {
+            user: {
+                fields: {
+                    twoFactorEnabled: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                        input: false;
+                    };
+                };
+            };
+            twoFactor: {
+                fields: {
+                    secret: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                        index: true;
+                    };
+                    backupCodes: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                    };
+                    userId: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                };
+            };
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        $ERROR_CODES: {
+            OTP_NOT_ENABLED: better_auth.RawError<"OTP_NOT_ENABLED">;
+            OTP_HAS_EXPIRED: better_auth.RawError<"OTP_HAS_EXPIRED">;
+            TOTP_NOT_ENABLED: better_auth.RawError<"TOTP_NOT_ENABLED">;
+            TWO_FACTOR_NOT_ENABLED: better_auth.RawError<"TWO_FACTOR_NOT_ENABLED">;
+            BACKUP_CODES_NOT_ENABLED: better_auth.RawError<"BACKUP_CODES_NOT_ENABLED">;
+            INVALID_BACKUP_CODE: better_auth.RawError<"INVALID_BACKUP_CODE">;
+            INVALID_CODE: better_auth.RawError<"INVALID_CODE">;
+            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: better_auth.RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+            INVALID_TWO_FACTOR_COOKIE: better_auth.RawError<"INVALID_TWO_FACTOR_COOKIE">;
+        };
+    }];
+}>;
+type DeepSpaceAuth = ReturnType<typeof createDeepSpaceAuth>;
+
+/**
+ * Yjs collaborative editing handlers for RecordRoom
+ */
+
+/** Collections that bypass schema checks (permissive access) */
+declare const SYSTEM_COLLECTIONS: Set<string>;
+
+export { type ActionContext, type ActionHandler, type ActionResult, type ActionTools, type ApiWorkerEnv, type AuthWorkerEnv, Awareness, type AwarenessState, type AwarenessStates, BASE_USERS_SCHEMA, BUILT_IN_TOOLS, type BaseMessage, BaseRoom, CHANNELS_SCHEMA, CHANNEL_INVITATIONS_SCHEMA, CHANNEL_MEMBERS_SCHEMA, CONVERSATION_SCHEMAS, CanvasRoom, type CanvasShape, type ClientMessage, type CollectionPermissionSummary, type CollectionSchema, type ColumnDefinition, type ColumnInterpretation, type ConnectionAttachment, type ConvMemberData, type ConvMessageData, type ConvReactionData, type ConvReadCursorData, type ConvVoteData, type ConversationStateData, type CronContext, type CronExecution, CronRoom, type CronRoomConfig, type CronTask, DEFAULT_DO_MANIFEST, DEFAULT_MAX_SKEW_MS, DIRECTORY_SCHEMAS, type DOBindings, type DOManifest, type DOManifestEntry, type DeepSpaceAIEnv, type DeepSpaceAIOptions, type DeepSpaceAuth, type DeepSpaceAuthConfig, type DirectoryCommunityData, type DirectoryConversationData, type DirectoryMembershipData, type DirectoryPostData, GLOBAL_DO_TYPES, GLOBAL_DO_TYPE_NAMES, type GameInput, GameRoom, type GameRoomConfig, type GlobalDOType, type HandlerContext, type InternalSignature, type JwtClaims, type JwtVerifierConfig, MESSAGES_SCHEMA, MSG, MSG_AWARENESS, MSG_SYNC, MSG_SYNC_STEP1, MSG_SYNC_STEP2, MSG_SYNC_UPDATE, MSG_YJS_AWARENESS, MSG_YJS_SYNC, type MessageHandlers, type MsgType, type PermissionAnalysis, type PermissionContext, type PermissionLevel, type PermissionSource, type PlatformWorkerEnv, type Player, type PrefixResult, type PresencePeer, PresenceRoom, type ProtocolMessage, REACTIONS_SCHEMA, READ_RECEIPTS_SCHEMA, RESERVED_COLLECTION_NAMES, ROLE_ADMIN, ROLE_ANONYMOUS, ROLE_DEFAULT, RecordRoom, type RecordRoomConfig, type ResolvedColumn, type ResolvedPermission, type RolePermissions, SYSTEM_COLLECTIONS, SYSTEM_MANAGED_COLUMNS, SchemaRegistry, type ScopeContext, type ScopedR2Auth, type ScopedR2Config, type ScopedR2Handler, type ServerMessage, type SharedConnection, type SignInternalPayloadInput, type StoredRecord, type SyncResult, type TokenDebugInfo, type ToolResult, type ToolSchema, USERS_COLUMNS, type User, type UserAttachment, VOTING_SCHEMAS, type VerifiedAuth, type VerifyInternalSignatureInput, type VerifyOutcome, type VerifyResult, type Viewport, WORKSPACE_SCHEMAS, YjsRoom, analyzePermissions, apiWorkerFetch, authWorkerFetch, buildCronContext, buildInternalPayload, buildTableSelect, canCreate, canDelete, canRead, canUpdate, checkFieldPermissions, clientBuild, coerceValue, collectionTableName, columnId, computeHmacHex, createDecoder, createDeepSpaceAI, createDeepSpaceAuth, createEncoder, createScopedR2Handler, dataToColumnValues, decodeJwtPayload, dispatch, encode, encodeAwarenessMessage, encodeSyncStep1, encodeSyncStep2, encodeUpdate, getGlobalDOSchemas, getGlobalDOType, getMessageType, getRolePermissions, handleAwarenessMessage, handleSyncMessage, hasContent, isOwner, noopPermissionContext, platformWorkerFetch, readVarUint, readVarUint8Array, resolveColumn, rowToData, serverBuild, signInternalPayload, timingSafeEqualHex, toUint8Array, verifyInternalSignature, verifyJwt, workspaceAccountsSchema, workspaceContentSharesSchema, workspaceEmailHandlesSchema, workspaceFormResponsesSchema, workspacePeopleSchema, workspaceProjectsSchema, workspaceTagsSchema, workspaceTasksSchema, workspaceTeamMembersSchema, workspaceTeamsSchema, workspaceTransactionsSchema, writeVarUint, writeVarUint8Array };