deepspace 0.3.8 → 0.3.9

package/dist/server.d.ts

@@ -0,0 +1,3805 @@
+import { LanguageModel, ModelMessage } from 'ai';
+import * as Y from 'yjs';
+import * as better_auth from 'better-auth';
+import * as better_auth_plugins from 'better-auth/plugins';
+import { Context } from 'hono';
+
+/**
+ * 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;
+
+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 RecordResult {
+    recordId: string;
+    data: Record<string, unknown>;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SubscribePayload {
+    subscriptionId: string;
+    query: Query;
+}
+interface UnsubscribePayload {
+    subscriptionId: string;
+}
+interface PutPayload {
+    collection: string;
+    recordId: string;
+    data: Record<string, unknown>;
+    requestId?: string;
+}
+interface DeletePayload {
+    collection: string;
+    recordId: string;
+    requestId?: string;
+}
+interface SetRolePayload {
+    userId: string;
+    role: string;
+}
+interface YjsJoinPayload {
+    collection: string;
+    recordId: string;
+    fieldName: string;
+}
+interface YjsLeavePayload {
+    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 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.
+ */
+
+/**
+ * Discriminated result wrapper. Narrowing on `.success` lets TS know
+ * `.data` is present in the success branch and `.error` in the failure
+ * branch, so callers can't read the wrong field by accident.
+ *
+ * `TData` is the per-operation data shape — `tools.query` returns
+ * `{ records, count }`, `tools.get` returns `{ record }`, etc. Apps
+ * that compose their own server actions can specialize further.
+ */
+type ActionResult<TData = unknown> = {
+    success: true;
+    data: TData;
+    error?: never;
+} | {
+    success: false;
+    data?: never;
+    error: string;
+};
+/** Shape of the data field for `tools.query`. */
+interface QueryActionData<T = Record<string, unknown>> {
+    records: Array<RecordResult & {
+        data: T;
+    }>;
+    count: number;
+}
+/** Shape of the data field for `tools.get`. */
+interface GetActionData<T = Record<string, unknown>> {
+    record: RecordResult & {
+        data: T;
+    };
+}
+/** Shape of the data field for `tools.create`/`update`/`remove`. */
+interface MutateActionData {
+    recordId: string;
+}
+interface ActionTools {
+    /**
+     * Insert a new record. When `recordId` is omitted the DO generates one
+     * (typical). Pass `recordId` to upsert against a known key — useful
+     * for `users` where the row id must equal the auth user's id so
+     * `tools.get('users', userId)` resolves.
+     */
+    create<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, data: T, recordId?: string): Promise<ActionResult<MutateActionData>>;
+    update<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, recordId: string, data: Partial<T>): Promise<ActionResult<MutateActionData>>;
+    remove(collection: string, recordId: string): Promise<ActionResult<MutateActionData>>;
+    get<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, recordId: string): Promise<ActionResult<GetActionData<T>>>;
+    query<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, options?: {
+        where?: Record<string, unknown>;
+        orderBy?: string;
+        orderDir?: 'asc' | 'desc';
+        limit?: number;
+    }): Promise<ActionResult<QueryActionData<T>>>;
+    /**
+     * Call an integration endpoint (e.g. 'openai/chat-completion') via the
+     * api-worker. On success, `result.data` is the integration's response
+     * body directly — there is no `.response` wrapper. So an OpenAI call
+     * yields `result.data.choices`, a Freepik image call yields
+     * `result.data.images`, etc.
+     */
+    integration<T = unknown>(endpoint: string, data?: unknown): Promise<ActionResult<T>>;
+    /**
+     * Insert or refresh the `users` row for an authenticated caller.
+     * Mirrors the WS-connect registerUser flow — useful for CLI-only
+     * actions (e.g. publishing via `deepspace foo publish`) where the
+     * caller may never have opened the web app and has no `users` row
+     * yet. Bypasses SYSTEM_MANAGED column stripping so name/email/
+     * imageUrl are actually written.
+     *
+     * Defaults `userId` to the action's caller. Pass `isAdmin: true` only
+     * if the caller's platform-tier role is admin (worker.ts should
+     * derive this from the verified JWT — never trust client input).
+     */
+    registerUser(opts: {
+        userId?: string;
+        name?: string;
+        email?: string;
+        imageUrl?: string;
+        isAdmin?: boolean;
+    }): Promise<ActionResult<{
+        user: {
+            id: string;
+            name: string;
+            email: string;
+            imageUrl?: string;
+            role: string;
+        };
+    }>>;
+}
+/**
+ * `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;
+    /**
+     * The caller's raw JWT. Forward this on outbound requests that need to
+     * impersonate the user (e.g. checking `/api/apps` ownership on the
+     * deploy worker, where the user — not the app owner — should be billed
+     * / authorized).
+     */
+    callerJwt: string;
+}
+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 or custom platform deployments. */
+    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>;
+
+/**
+ * AI provider helpers — create Vercel AI SDK providers that route through
+ * the DeepSpace API worker proxy for per-user billing.
+ *
+ * Supported providers: anthropic, openai, cerebras.
+ *
+ * The API worker can be reached in two ways:
+ *   - Service binding `env.API_WORKER` (Cloudflare Fetcher) — preferred in
+ *     production if the app has declared the binding in wrangler.toml.
+ *   - HTTPS URL `env.API_WORKER_URL` — used in local dev and in production
+ *     for apps that don't declare the binding. `deepspace dev` writes this
+ *     into `.dev.vars` automatically.
+ *
+ * Auth is automatic by default:
+ *   - For server-side autonomous calls (cron, DO alarms, background agents),
+ *     the helper reads the long-lived `env.APP_OWNER_JWT` minted at deploy
+ *     time (or by `deepspace dev` in local development) and uses it for the
+ *     proxy auth header. The owner is billed automatically via the JWT sub.
+ *   - For user-initiated calls (e.g. an `/api/ai/chat` route handling a
+ *     browser request), pass `options.authToken` explicitly with the user's
+ *     own JWT so the call is billed to the user.
+ *
+ * Usage:
+ *
+ *   // Server-side autonomous — no auth config needed
+ *   import { createDeepSpaceAI } from 'deepspace/worker'
+ *   const cerebras = createDeepSpaceAI(env, 'cerebras')
+ *   const result = await generateText({ model: cerebras('llama-3.3-70b'), ... })
+ *
+ *   // User-initiated (inside a request handler)
+ *   const jwt = c.req.header('Authorization')!.slice(7)
+ *   const anthropic = createDeepSpaceAI(c.env, 'anthropic', { authToken: jwt })
+ */
+
+/**
+ * Model factory: `(modelId) => LanguageModel`. The explicit return type
+ * keeps tsup's DTS build from leaking unportable `.pnpm/@ai-sdk+provider/...`
+ * paths into the published `dist/index.d.ts`.
+ */
+type DeepSpaceModelFactory = (modelId: string) => LanguageModel;
+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): DeepSpaceModelFactory;
+
+/**
+ * captureScreenshot — call platform-worker /internal/screenshot.
+ *
+ * Apps don't ship CF Browser Rendering bindings or puppeteer in their
+ * own bundle. The platform holds the binding; consumers call this
+ * helper to get PNG bytes for a URL.
+ *
+ * The platform enforces: a host allowlist (*.app.space / *.deep.space),
+ * a per-app sliding rate limit, and viewport/timeout clamping. Returns
+ * `null` on any non-2xx — callers should treat as "no preview available"
+ * and surface their own fallback UX.
+ *
+ * Auth is the same HMAC-of-appName pattern `/internal/files` uses:
+ *   x-app-identity-token = hmac(PLATFORM_IDENTITY_SECRET, APP_NAME)
+ *   x-app-name           = APP_NAME
+ *
+ * Apps already have both as bindings (APP_IDENTITY_TOKEN + APP_NAME),
+ * so this helper is a thin wrapper — no extra secrets to manage.
+ */
+
+interface ScreenshotOptions {
+    url: string;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+    timeoutMs?: number;
+    fullPage?: boolean;
+}
+interface ScreenshotEnv extends PlatformWorkerEnv {
+    APP_NAME: string;
+    APP_IDENTITY_TOKEN: string;
+}
+interface ScreenshotResult {
+    /** PNG bytes. */
+    body: ArrayBuffer;
+    /** `image/png`. */
+    contentType: string;
+}
+/**
+ * Capture a screenshot of `opts.url` and return the PNG bytes.
+ *
+ * Returns null on capture failure (target unreachable, timeout, BR
+ * binding misconfigured platform-side). The platform endpoint logs the
+ * underlying error; callers should treat null as "no preview available"
+ * and surface their own UX fallback.
+ */
+declare function captureScreenshot(env: ScreenshotEnv, opts: ScreenshotOptions): Promise<ScreenshotResult | null>;
+
+/**
+ * Chat context pipeline — keeps the per-request payload to the LLM bounded.
+ *
+ * `prepareMessagesWithCompaction` runs before `streamText`: truncate old tool
+ * results, apply a cached summary if available, otherwise summarize the older
+ * half of history when over budget. Falls back to a sliding window if
+ * summarization fails. `capToolResultSize` caps individual tool calls.
+ */
+
+interface ChatTurn {
+    id?: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    parts?: unknown[];
+}
+type Summarizer = (messages: ChatTurn[]) => Promise<string>;
+interface ChatContextConfig {
+    contextBudget: number;
+    toolResultCap: number;
+    keepRecentToolResults: number;
+    minKept: number;
+}
+declare const DEFAULT_CONTEXT_CONFIG: ChatContextConfig;
+declare function totalChars(messages: ChatTurn[]): number;
+/**
+ * Replace older tool-result payloads with a small marker. Keeps the last
+ * `keepRecent` tool results intact. Errors (`success: false`) are preserved —
+ * they're small and the agent needs them for reasoning.
+ */
+declare function truncateOldToolResults(messages: ChatTurn[], keepRecent: number): ChatTurn[];
+/**
+ * Drop oldest messages until total character count is under `charCap`,
+ * never going below `minKept` messages. System messages (e.g. compaction
+ * summaries) are pinned — dropping them would discard the most condensed
+ * context first.
+ */
+declare function applySlidingWindow(messages: ChatTurn[], charCap: number, minKept: number): ChatTurn[];
+/**
+ * Replace oversized tool results with an error telling the agent to narrow
+ * its query. Keeps a small preview so the agent can see what it got.
+ */
+declare function capToolResultSize(result: unknown, byteCap: number): unknown;
+/**
+ * Convert persisted ChatTurns into AI SDK ModelMessages.
+ *
+ * Persisted assistant rows store `parts` in UI shape (text + tool-invocation,
+ * each invocation carrying its own `result`). When fed back to the LLM, the
+ * shape MUST match the original multi-step flow: an assistant message
+ * containing a `tool_use` block must end with that block, the IMMEDIATELY
+ * NEXT message must be a tool/user message containing the matching
+ * `tool_result`, and any text the model produced AFTER seeing the tool
+ * result belongs in a SEPARATE assistant message after the tool message.
+ *
+ * Anthropic specifically rejects an assistant message of the form
+ * `[text, tool_use, text]` — the trailing text breaks its `tool_use` →
+ * `tool_result` pairing check. So we walk the parts in order and split at
+ * each tool-invocation boundary, emitting a fresh assistant + tool pair per
+ * tool call, and a final trailing assistant message for any post-tool text.
+ *
+ * Tool-invocation entries with `state: 'call'` (no result — typically an
+ * interrupted stream) are dropped on both sides.
+ */
+declare function turnsToCoreMessages(turns: ChatTurn[]): ModelMessage[];
+/**
+ * Convert AI SDK response messages into our persisted UI shape (text +
+ * tool-invocation parts), pairing each assistant tool-call with its tool-
+ * result from the following tool message. Order is chronological.
+ *
+ * Inverse of `turnsToCoreMessages`: takes the v5 `ModelMessage[]` returned
+ * from `streamText`'s `onFinish` and produces the flat `parts` array we
+ * persist on `ai-messages` rows. Reads `c.input` / `c.output` (v5 wire
+ * names) and unwraps `output`'s tagged-union via `unwrapToolOutput`.
+ */
+declare function buildUiParts(responseMessages: ModelMessage[]): unknown[];
+/**
+ * Unwrap v5's tagged tool-result `output` to the flat shape we persist.
+ * Errors get remapped to `{ success: false, error }` because
+ * `truncateOldToolResults` preserves entries with that shape across turns —
+ * without the remap, error context would get truncated like a normal result.
+ */
+declare function unwrapToolOutput(output: unknown): unknown;
+/**
+ * Pre-stream pipeline with compaction.
+ *
+ * 1. Truncate old tool results.
+ * 2. If a cached summary covers a known message id, replace prior turns with it.
+ * 3. If still over budget, summarize the older half of `working` and return a
+ *    `newSummary` for persistence — runs even after cached-summary application
+ *    so a long-running chat can re-summarize on subsequent turns.
+ * 4. On summarizer error or missing ids, fall back to a sliding window
+ *    (which preserves system messages — see `applySlidingWindow`).
+ */
+declare function prepareMessagesWithCompaction(messages: ChatTurn[], config: ChatContextConfig, options: {
+    summarizer: Summarizer;
+    cachedSummary?: {
+        text: string;
+        throughId: string;
+    };
+}): Promise<{
+    messages: ChatTurn[];
+    newSummary?: {
+        text: string;
+        throughId: string;
+    };
+}>;
+/**
+ * Build a default summarizer backed by Claude Haiku.
+ *
+ * Billing: defaults to the app owner via `APP_OWNER_JWT` — summarization is
+ * usually infrastructure, not user work. Pass `{ authToken }` to bill a
+ * specific user (e.g. the caller's JWT) instead.
+ */
+declare function makeDefaultSummarizer(env: DeepSpaceAIEnv, options?: {
+    authToken?: string;
+}): Summarizer;
+
+/**
+ * Chat history helpers — wrap RecordRoom's tools API for ai-chats / ai-messages.
+ *
+ * Trust model: every helper sends `X-App-Action: 'true'`, which bypasses
+ * RecordRoom's per-record RBAC. The worker is the trust boundary, not
+ * RecordRoom. Callers MUST verify ownership before invoking write helpers
+ * (`updateChat`, `appendMessage`, `deleteChatCascade`); the worker's
+ * `/api/ai/chat`, `PATCH /api/ai/chats/:id`, and `DELETE /api/ai/chats/:id`
+ * routes do this via a `getChat()` precheck that 404s when the row is
+ * missing or owned by another user. Read helpers (`getChat`, `loadMessages`)
+ * filter by `chatId` against userBound rows, so cross-user reads return
+ * empty — but new consumers should still consider an explicit ownership
+ * check before exposing data.
+ *
+ * The tools API returns records as `{ recordId, data, createdAt, updatedAt }`
+ * envelopes; helpers below flatten them into ChatRow / ChatMessageRow.
+ */
+/**
+ * Canonical chat row.
+ *
+ * `recordId` is the primary identifier — same envelope shape as every
+ * other DeepSpace data type (records.* tools, useQuery results, etc.).
+ *
+ * `id` is kept as a deprecated alias so existing callers don't break,
+ * but every new caller should prefer `recordId`. Without this rename
+ * an integrator who reads `chat.recordId` (the obvious thing given the
+ * rest of the SDK) silently gets `undefined`, then ships code that
+ * sends `{"chatId": undefined}` to `/api/ai/chat` and gets back a 400
+ * with a misleading error.
+ */
+type ChatRow = {
+    recordId: string;
+    /** @deprecated Use `recordId`. Retained for backward compatibility. */
+    id: string;
+    userId: string;
+    title: string;
+    model?: string;
+    compactedSummary?: string;
+    compactedThroughId?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type ChatMessageRow = {
+    recordId: string;
+    /** @deprecated Use `recordId`. Retained for backward compatibility. */
+    id: string;
+    chatId: string;
+    userId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    parts?: unknown[];
+    createdAt: string;
+};
+declare function getChat(stub: DurableObjectStub, chatId: string, userId: string): Promise<ChatRow | null>;
+declare function createChat(stub: DurableObjectStub, userId: string, opts?: {
+    title?: string;
+    model?: string;
+}): Promise<ChatRow>;
+declare function updateChat(stub: DurableObjectStub, chatId: string, userId: string, patch: Partial<Pick<ChatRow, 'title' | 'model' | 'compactedSummary' | 'compactedThroughId'>>): Promise<void>;
+declare function deleteChatCascade(stub: DurableObjectStub, chatId: string, userId: string): Promise<void>;
+declare function loadMessages(stub: DurableObjectStub, chatId: string, userId: string): Promise<ChatMessageRow[]>;
+declare function appendMessage(stub: DurableObjectStub, msg: {
+    id: string;
+    chatId: string;
+    userId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    parts?: unknown[];
+}): Promise<void>;
+
+/**
+ * Per-binding usage metering — record Vectorize / Workers AI / etc. costs
+ * to the auto-attached `USAGE_EVENTS` Analytics Engine dataset.
+ *
+ * Why: the platform's tail-worker captures per-invocation compute (CPU + wall
+ * time + script name) but it can't see which model an AI call hit, how many
+ * tokens it embedded, or how many vectors a Vectorize query scanned. Without
+ * those signals there's no way to surface per-tenant binding cost on the
+ * billing dashboard.
+ *
+ * The deploy-worker auto-attaches a `USAGE_EVENTS` AE binding to every app
+ * (dataset: `deepspace_binding_usage`). Apps don't need to declare it. They
+ * just call `meterAi(...)` / `meterVectorize(...)` / `meterUsage(...)` after
+ * each call and the dashboard rolls it up by `ownerUserId`.
+ *
+ * Schema written:
+ *   indexes: [ownerUserId]
+ *   blobs:   [appName, kind, model_or_index, op]
+ *   doubles: [units, count]
+ *
+ * Use:
+ *   await meterAi(env, '@cf/qwen/qwen3-embedding-0.6b', { inputChars: 5000 })
+ *   await meterVectorize(env, 'unison-candidates', 'query', { vectors: 1000 })
+ *   await meterUsage(env, 'custom-thing', { units: 1 })
+ */
+interface MeteringEnv {
+    USAGE_EVENTS?: AnalyticsEngineDataset;
+    OWNER_USER_ID?: string;
+    APP_NAME?: string;
+}
+/**
+ * Generic event recorder. Returns `false` if the binding isn't present
+ * (dev / not yet deployed) or if AnalyticsEngine throws — metering must
+ * never break the calling code path.
+ */
+declare function meterUsage(env: MeteringEnv, kind: string, fields?: {
+    id?: string;
+    op?: string;
+    units?: number;
+    count?: number;
+}): boolean;
+/**
+ * Record a Workers AI call.
+ *
+ * Cloudflare prices input and output tokens at different rates for LLMs
+ * (output is typically more expensive); embedding models bill input only.
+ * Emits up to two events per call so the dashboard rollup can group by
+ * `op` and apply the right per-token rate:
+ *
+ *   op='input'   units=inputChars
+ *   op='output'  units=outputChars
+ *
+ * For a pure embedding call (outputChars=0), only the input event fires.
+ * Pass `inputChars` and `outputChars` raw — the rough chars-to-token
+ * conversion happens at price time using `COST_RATES.ai.embedInputPerChar`.
+ *
+ * Note: only embedding-input has an authoritative rate today. LLM-output
+ * pricing varies wildly per model so `priceBindingUsageEvent` returns 0
+ * for `op='output'` until per-model rates are wired. The events are still
+ * recorded so the dashboard can show that the calls happened.
+ */
+declare function meterAi(env: MeteringEnv, model: string, fields?: {
+    inputChars?: number;
+    outputChars?: number;
+    calls?: number;
+}): boolean;
+/**
+ * Record a Vectorize operation.
+ *
+ * Cloudflare's published model (https://developers.cloudflare.com/vectorize/platform/pricing/):
+ *
+ *   "If you have 10,000 vectors with 384-dimensions in an index, and make
+ *    100 queries against that index, your total queried vector dimensions
+ *    would sum to 3.878 million ((10000 + 100) * 384)."
+ *
+ * So query billing is *additive* — `(stored + queries) * dims` summed
+ * across the call, not per-query-multiplied-by-stored. Translating to a
+ * per-call meter:
+ *
+ *   op='query':   units = (vectors + storedCount) * dims
+ *                 Without `storedCount` we significantly undercount: a single
+ *                 query against a 100K-vector index produces ~100K queried
+ *                 dims, not just `dims`.
+ *   op='upsert':  CF doesn't bill upserts directly; the chargeable delta is
+ *                 the change to stored-vector-month. `units = vectors * dims`
+ *                 approximates the per-call storage delta.
+ *   op='delete' / 'getByIds':  recorded for observability; no direct cost.
+ *
+ * Edge case: querying an empty index gives `(1 + 0) * dims = dims`, which
+ * matches CF's formula (the `+ queries` term is always added, even at 0
+ * stored). If CF later changes that and an empty-index query bills 0,
+ * adjust here — `metering` is the single place to update the math.
+ */
+declare function meterVectorize(env: MeteringEnv, indexName: string, op: 'query' | 'upsert' | 'delete' | 'getByIds', fields?: {
+    vectors?: number;
+    dims?: number;
+    storedCount?: number;
+}): boolean;
+/**
+ * Per-`units` USD multipliers, matched to the (`kind`, `op`) the meter
+ * helpers above record. Dashboard rollup can multiply
+ *
+ *   SUM(_sample_interval * doubles[1])   -- units
+ *
+ * by these to surface $-figures without re-querying CF's billing API.
+ */
+declare const COST_RATES: {
+    readonly ai: {
+        /**
+         * USD per character of *embedding input* (bge-m3 / qwen3-embedding tier).
+         * Renamed from `perChar` to make explicit that this rate does NOT
+         * apply to LLM-generation output — see `priceBindingUsageEvent`.
+         */
+        readonly embedInputPerChar: number;
+    };
+    readonly vectorize: {
+        /** USD per queried dimension (per query, per stored vector compared). */
+        readonly queriedPerDim: number;
+        /** USD per stored dimension per month. */
+        readonly storedPerDimPerMonth: number;
+    };
+};
+/**
+ * Price a single rolled-up `deepspace_binding_usage` row. Lives next to
+ * `COST_RATES` so the (kind, op) → rate mapping stays paired with the schema
+ * the meter helpers write.
+ *
+ * Returns 0 for combinations without an authoritative per-unit rate; the row
+ * still surfaces in dashboards for observability. Notable zeros:
+ *   - `ai/output`: LLM-output prices vary per model and `meterAi` doesn't
+ *     carry a model-family signal. Pricing it at the embedding rate would
+ *     silently under-bill chat-LLM use.
+ *   - `vectorize.storedPerDimPerMonth`: events are per-call deltas, not
+ *     monthly snapshots, so a windowed SUM isn't meaningful here.
+ */
+declare function priceBindingUsageEvent(kind: string, op: string, units: number): number;
+
+/**
+ * Lightweight D1 schema bootstrapping for apps that use auto-provisioned
+ * `[[d1_databases]]` bindings.
+ *
+ * The auto-provisioner gives apps an empty D1; the app needs to create its
+ * own tables before using them. This helper runs ordered SQL fragments and
+ * tracks which have applied via a `_dpc_migrations` meta-table so re-running
+ * is a no-op:
+ *
+ * ```ts
+ * import { runMigrations } from 'deepspace/worker'
+ *
+ * await runMigrations(env.CARDS_DB, [
+ *   `CREATE TABLE cards (id INTEGER PRIMARY KEY, json TEXT NOT NULL);`,
+ *   `CREATE INDEX idx_cards_updated ON cards(updated_at);`,
+ * ])
+ * ```
+ *
+ * **SQL formatting:** statements may span multiple lines freely. The runner
+ * splits each migration string on `;` and runs each fragment via
+ * `prepare().run()`. That sidesteps `db.exec()`'s newline-or-semicolon quirks
+ * (it's optimized for migration files, not inline strings) and gets you
+ * predictable single-statement semantics. Trailing `;` after the last
+ * statement is fine; semicolons inside string literals are not (we use a
+ * naive split, since DDL almost never has them).
+ *
+ * Each entry in the array is one migration. The runner records the index of
+ * each successfully-applied migration in `_dpc_migrations`; subsequent calls
+ * skip rows already recorded. Adding a new migration means appending to the
+ * array; never reorder or delete entries.
+ *
+ * Why a meta-table instead of `PRAGMA user_version`: D1's SQLite authorizer
+ * rejects PRAGMA writes with `SQLITE_AUTH`, even though the same statements
+ * work in raw SQLite. A real table works on any D1 database and stays a
+ * trivial bootstrap (one CREATE TABLE IF NOT EXISTS).
+ *
+ * Concurrency: D1 serializes statements per database, but two simultaneous
+ * `runMigrations` callers could race the same migration index. The duplicate
+ * INSERT collides on the primary key and the second caller sees the failure
+ * — but the migration itself uses `IF NOT EXISTS` so the schema is correct
+ * either way. Apps invoke this at startup which is single-threaded per
+ * worker isolate; the cross-isolate race is rare and self-healing.
+ *
+ * This is the simplest possible migration story (option 1 in
+ * docs/proposals/binding-auto-provisioning.md). Apps that outgrow it can
+ * adopt CF's `wrangler d1 migrations apply` directly without breaking the
+ * helper.
+ */
+interface RunMigrationsResult {
+    /** Version before this run started. Equals the count of migrations already applied. */
+    fromVersion: number;
+    /** Version after migrations applied. Equals fromVersion if nothing ran. */
+    toVersion: number;
+    /** Number of migrations applied this call. */
+    applied: number;
+}
+/**
+ * Apply ordered SQL migrations to a D1 database. Idempotent: the next call
+ * with the same array is a no-op until the array grows.
+ *
+ * Throws on any individual migration failure. The migrations meta-row is
+ * only inserted after a migration succeeds, so a partial failure leaves a
+ * recoverable state — fix the SQL, redeploy, and the failed migration runs
+ * on next startup.
+ */
+declare function runMigrations(db: D1Database, migrations: readonly string[]): Promise<RunMigrationsResult>;
+
+/**
+ * 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";
+};
+
+/**
+ * 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 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>;
+
+/**
+ * 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<E = Record<string, unknown>> {
+    protected state: DurableObjectState;
+    protected env: E;
+    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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+/**
+ * Lint a CollectionSchema for declarations that look like they should
+ * enforce something but don't, due to interactions between top-level
+ * fields (visibilityField, ownerField) and per-role permission levels.
+ *
+ * The SDK has historically silently accepted schemas that imply more
+ * enforcement than they actually deliver — e.g., `visibilityField` set
+ * but every role's `read: true` means "anyone can read everything"
+ * regardless of `visibility`. Warn loudly at registration so app
+ * authors notice before shipping a privacy bug.
+ *
+ * Returns an array of warning messages. Empty = clean.
+ */
+declare function lintSchema(schema: CollectionSchema): string[];
+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<E = Record<string, unknown>> extends BaseRoom<E> {
+    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<E = Record<string, unknown>> extends BaseRoom<E> {
+    private doc;
+    private initialized;
+    private awarenessStates;
+    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 readAwarenessUpdates;
+    private encodeAwarenessMessage;
+    private sendAwarenessSnapshot;
+    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<E = Record<string, unknown>> extends BaseRoom<E> {
+    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<E = Record<string, unknown>> extends BaseRoom<E> {
+    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<E = Record<string, unknown>> extends BaseRoom<E> {
+    private peers;
+    private peerSockets;
+    constructor(state: DurableObjectState, env: unknown);
+    /**
+     * Durable Objects can hibernate and clear heap while Cloudflare keeps
+     * WebSocket connections. Deserialize attachments from already-connected
+     * sockets so `peers` matches reality before we send PRESENCE_SYNC.
+     */
+    private hydratePeersFromLiveSockets;
+    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<E = Record<string, unknown>> extends BaseRoom<E> {
+    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;
+/**
+ * Shape-validate a DO manifest received over the wire (e.g. from the CLI's
+ * deploy form-field). Without this, malformed input gets passed straight to
+ * `deployToWfP`'s `.filter(...).map(...)` chain and crashes the route mid-deploy.
+ *
+ * Mirrors the contract of `validateBindingManifest` for non-DO bindings.
+ */
+declare function validateDoManifest(manifest: unknown): {
+    valid: true;
+    manifest: DOManifest;
+} | {
+    valid: false;
+    reason: string;
+};
+
+/**
+ * Binding Manifest — non-DO bindings declared by an app's wrangler.toml that
+ * the deploy-worker should pass through to Cloudflare's WfP upload API.
+ *
+ * Apps don't export a `__BINDING_MANIFEST__`; the CLI extracts these from the
+ * normalized vite/wrangler output config at deploy time. This file just owns
+ * the types + validation so both sides (CLI client and deploy-worker server)
+ * agree on the shape.
+ */
+/**
+ * A single non-DO binding the app declares. Mirrors CF's WfP binding API.
+ *
+ * Provisionable resources (d1, kv_namespace, vectorize, r2_bucket, queue) accept
+ * the literal string `"auto"` in their ID field to request platform-side
+ * provisioning at deploy time. When `"auto"` is used, the deploy-worker creates
+ * the resource on the platform CF account, persists the resulting CF ID in the
+ * app registry, and substitutes the real ID before forwarding to WfP. The
+ * sentinel sticks around in this type because:
+ *   1. `wrangler` parsing requires a non-empty string in the id field
+ *   2. The CLI passes the unresolved manifest through to the deploy-worker
+ *   3. The deploy-worker is the only side with CF API credentials
+ *
+ * Companion fields (`database_name`, `title`, `dimensions`, `metric`) are only
+ * used when `"auto"` is set — they tell the provisioner how to create the
+ * resource. After provisioning these fields are still present on the wire but
+ * ignored by WfP.
+ */
+type CustomBinding = {
+    type: 'vectorize';
+    name: string;
+    /** Either a pre-existing index name or the literal `"auto"`. */
+    index_name: string;
+    /** Required when `index_name === "auto"`. */
+    dimensions?: number;
+    /** Required when `index_name === "auto"`. */
+    metric?: 'cosine' | 'euclidean' | 'dot-product';
+} | {
+    type: 'ai';
+    name: string;
+} | {
+    type: 'r2_bucket';
+    name: string;
+    /** Either a pre-existing bucket name or the literal `"auto"`. */
+    bucket_name: string;
+} | {
+    type: 'kv_namespace';
+    name: string;
+    /** Either a pre-existing KV namespace ID or the literal `"auto"`. */
+    namespace_id: string;
+    /** Required when `namespace_id === "auto"`. Human-readable namespace title. */
+    title?: string;
+} | {
+    type: 'd1';
+    name: string;
+    /** Either a pre-existing D1 database UUID or the literal `"auto"`. */
+    id: string;
+    /** Required when `id === "auto"`. Human-readable database name. */
+    database_name?: string;
+} | {
+    type: 'queue';
+    name: string;
+    /** Either a pre-existing queue name or the literal `"auto"`. */
+    queue_name: string;
+} | {
+    type: 'browser_rendering';
+    name: string;
+} | {
+    type: 'analytics_engine';
+    name: string;
+    dataset?: string;
+} | {
+    type: 'hyperdrive';
+    name: string;
+    id: string;
+};
+type CustomBindingManifest = CustomBinding[];
+/** Sentinel string in an ID field that requests platform-side provisioning. */
+declare const AUTO_PROVISION_SENTINEL = "auto";
+/** Binding types whose ID field accepts the `"auto"` sentinel for provisioning. */
+declare const AUTO_PROVISIONABLE_TYPES: Set<string>;
+/**
+ * True if a binding has the `"auto"` sentinel in its primary ID field. Used by
+ * the deploy-worker to decide which entries need provisioning and by the
+ * validator to enforce companion-field requirements.
+ */
+declare function isAutoProvision(b: CustomBinding): boolean;
+/** Binding `type` values an app is allowed to declare. */
+declare const ALLOWED_BINDING_TYPES: Set<string>;
+/**
+ * Binding NAMES the SDK reserves on every app — apps may not redeclare them.
+ *
+ * Includes:
+ *   - Static-asset + service bindings the platform sets up automatically.
+ *   - SDK-managed env (auth, identity, owner JWT, HMAC secret).
+ *   - The auto-attached cost-tracking AE dataset (`USAGE_EVENTS`).
+ *
+ * DO binding names (RECORD_ROOMS, YJS_ROOMS, etc.) are NOT in this set
+ * because they live in a separate manifest (`__DO_MANIFEST__`).
+ */
+declare const RESERVED_BINDING_NAMES: Set<string>;
+/**
+ * Per-binding validation error. `binding` is undefined for top-level
+ * shape failures (e.g. manifest is not an array).
+ */
+interface ValidationError {
+    binding?: CustomBinding;
+    reason: string;
+}
+/**
+ * Validate a binding manifest. Returns errors; an empty array means valid.
+ *
+ * Used both client-side (CLI) for friendly fail-fast and server-side
+ * (deploy-worker) as a security boundary — apps can't sneak in reserved
+ * binding names by editing the wire format.
+ */
+declare function validateBindingManifest(manifest: unknown): {
+    valid: true;
+    bindings: CustomBindingManifest;
+} | {
+    valid: false;
+    errors: ValidationError[];
+};
+/**
+ * Convert vite/wrangler's normalized config (from `.wrangler/deploy/config.json`)
+ * into a CustomBindingManifest.
+ *
+ * Vite normalizes wrangler.toml into object/array structures with shapes like
+ * `{ ai: { binding: 'AI' } }`, `{ vectorize: [{ binding, index_name }] }`,
+ * etc. We extract each known shape with explicit field plucks (no broad
+ * `as` casts) and return a flat array.
+ */
+declare function bindingManifestFromOutputConfig(outputConfig: Record<string, unknown>): CustomBindingManifest;
+
+/**
+ * Pure helpers for computing Cloudflare Durable Object migrations from a
+ * declared manifest + the bindings already registered on a deployed script.
+ *
+ * Lives in the SDK (not deploy-worker) so the logic is testable with vitest
+ * and reusable from other CF deploy paths if we ever add them.
+ */
+
+/** Subset of CF's `bindings` API response we read from. */
+interface ExistingDOBinding {
+    /** Binding name in `env`, e.g. 'RECORD_ROOMS' */
+    name: string;
+    /** Always `'durable_object_namespace'` for DO bindings. */
+    type: string;
+    /** SDK class name, e.g. 'AppRecordRoom' */
+    class_name?: string;
+}
+/** What goes in the CF script-upload `migrations` block. */
+interface DoMigrationDirective {
+    tag: string;
+    new_sqlite_classes?: string[];
+    deleted_classes?: string[];
+}
+interface DoMigrationPlan {
+    /** New SQLite classes to register (present in manifest, absent in existing). */
+    newSqliteClasses: string[];
+    /** Classes to delete (present in existing, absent in manifest). */
+    deletedClasses: string[];
+    /** True when there's actual delta — only then should the migrations block be sent. */
+    needsMigration: boolean;
+    /** The full directive to splat into the CF script-upload metadata. Null if no migration is needed. */
+    directive: DoMigrationDirective | null;
+}
+interface ComputeDoMigrationOptions {
+    /**
+     * Override for the timestamp baked into the migration tag. Tests pass a
+     * fixed value to assert determinism; production omits this and gets
+     * `Date.now()`, which guarantees lifetime tag uniqueness even across
+     * cycles like `[A]→[A,B]→[A]→[A,B]`.
+     */
+    now?: number;
+}
+/**
+ * Compute the migration plan for a deploy.
+ *
+ *   manifest:   what the app declares now
+ *   existing:   what CF currently has registered for this script
+ *
+ * Behavior:
+ *   - new_sqlite_classes  ← in manifest, not in existing, sqlite=true
+ *   - deleted_classes     ← in existing, not in manifest
+ *   - needsMigration       ← either of the above is non-empty
+ *   - tag                 ← content-addressed by (add, remove) so:
+ *                            - identical re-deploy → unchanged tag → no-op (and
+ *                              `needsMigration` is false anyway)
+ *                            - any class change → unique tag → CF processes
+ *
+ * Bug history: an earlier version computed `tag = v${count}`. Removing a class
+ * dropped the count, the migration block was skipped (no NEW classes), and CF
+ * retained the orphaned class registration with its SQLite storage. The
+ * `deleted_classes` path closes that gap; the content-addressed tag prevents
+ * tag collisions when class sets are added and removed in different orders.
+ */
+declare function computeDoMigration(manifest: readonly DOManifestEntry[], existing: readonly ExistingDOBinding[], options?: ComputeDoMigrationOptions): DoMigrationPlan;
+
+/**
+ * App-name validation + sanitization helpers.
+ *
+ * Strategy: validate strictly so we have a precise definition of "valid",
+ * but DON'T reject non-conforming names — sanitize them, warn the user, and
+ * proceed. Hard rejection would break apps whose `wrangler.toml name` was
+ * something like `My_App` (previously deployed as `my-app` via silent
+ * server-side sanitization). The new behavior preserves "still deploys,"
+ * but the CLI now surfaces a warning so the user can fix the name when
+ * convenient instead of being silently surprised by their hostname.
+ *
+ * Rules track Cloudflare's WfP script-name constraints (RFC 1035 host label,
+ * no consecutive dashes) plus our 2-char minimum so subdomains read sensibly.
+ */
+declare const APP_NAME_RULES: {
+    /** ^[a-z0-9](-?[a-z0-9])+$ — RFC 1035 host label, no consecutive dashes. */
+    readonly pattern: RegExp;
+    readonly minLength: 2;
+    readonly maxLength: 63;
+};
+type AppNameValidation = {
+    valid: true;
+    name: string;
+} | {
+    valid: false;
+    reason: string;
+};
+/**
+ * Strict validation: returns valid only if the name already conforms.
+ * Useful as a precondition test or for CI lints.
+ */
+declare function validateAppName(raw: unknown): AppNameValidation;
+type AppNameResolution = {
+    ok: true;
+    name: string;
+    warning?: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Resolve an app name for deploy: prefer the input as-is if valid, otherwise
+ * sanitize and warn. Hard-fail only if even sanitization can't produce a
+ * valid name (empty, all-non-alphanumeric, too short, too long).
+ *
+ * The intent is "what previously worked still works, with a friendly warning
+ * about non-conforming names."
+ */
+declare function resolveAppName(raw: unknown): AppNameResolution;
+
+/**
+ * AI Chat Schemas
+ *
+ * Pre-built collection schemas for DO-backed AI chat history.
+ * The worker is the only writer; the client reads via `useQuery`.
+ */
+
+declare const AI_CHATS_SCHEMA: CollectionSchema;
+declare const AI_MESSAGES_SCHEMA: CollectionSchema;
+
+/**
+ * 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>;
+
+/**
+ * Subscription handlers for RecordRoom
+ *
+ * All collections use table-mode storage (c_* tables with typed columns).
+ */
+
+interface SubscriptionContext {
+    sql: SqlStorage;
+    schemaRegistry: SchemaRegistry;
+    state: DurableObjectState;
+    getPermissionContext(): PermissionContext;
+    /** Typed against `ServerMessage` so outbound broadcasts are
+     *  compile-checked against the wire contract. */
+    send(ws: WebSocket, message: ServerMessage): void;
+}
+/**
+ * Handle a new subscription request.
+ *
+ * We no longer store subscriptions server-side - broadcasts go to all clients
+ * and they filter locally. This avoids hibernation issues.
+ */
+declare function handleSubscribe(ctx: SubscriptionContext, ws: WebSocket, attachment: ConnectionAttachment, payload: SubscribePayload): void;
+/**
+ * Handle unsubscribe request.
+ *
+ * Since we no longer store subscriptions server-side, this is a no-op.
+ * The client handles unsubscription locally.
+ */
+declare function handleUnsubscribe(_ctx: SubscriptionContext, _ws: WebSocket, _attachment: ConnectionAttachment, _payload: UnsubscribePayload): void;
+/**
+ * Execute a query and return matching records.
+ * All collections use table-mode (c_* tables).
+ *
+ * `skipUserRbac` lets a server-action caller (i.e. the app itself, via
+ * `X-App-Action`) bypass the per-user read filter for parity with the other
+ * `tools.*` operations (`get`, `create`, `update`, `remove`).
+ */
+declare function executeQuery(ctx: SubscriptionContext, query: Query, userId: string, userRole: string, skipUserRbac?: boolean): RecordResult[];
+/**
+ * Check if a record matches a subscription's query and permissions
+ */
+declare function recordMatchesSubscription(record: {
+    recordId: string;
+    data: Record<string, unknown>;
+    createdBy: string;
+}, collection: string, query: Query, userId: string, userRole: string, schema: CollectionSchema, ctx: PermissionContext): boolean;
+/**
+ * Broadcast a record change to all connected clients who can read it.
+ *
+ * Instead of matching subscriptions (which are lost on hibernation),
+ * we broadcast to ALL clients and include the collection name.
+ * The client filters based on its local subscriptions.
+ */
+declare function broadcastChange(ctx: SubscriptionContext, state: DurableObjectState, collection: string, record: RecordResult, changeType: 'create' | 'update' | 'delete'): void;
+
+/**
+ * Record operation handlers for RecordRoom (PUT/DELETE)
+ *
+ * All collections use table-mode storage (c_* tables with typed columns).
+ */
+
+interface RecordContext extends SubscriptionContext {
+    state: DurableObjectState;
+}
+/**
+ * Get a single record from its c_* table.
+ */
+declare function getRecord(sql: SqlStorage, collection: string, recordId: string, schema?: CollectionSchema): {
+    data: Record<string, unknown>;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+} | null;
+/**
+ * Handle PUT (create/update) record request via WebSocket.
+ * Thin wrapper around putRecord() — translates ToolResult errors to WS messages.
+ */
+declare function handlePut(ctx: RecordContext, ws: WebSocket, attachment: ConnectionAttachment, payload: PutPayload): void;
+/**
+ * Handle DELETE record request via WebSocket.
+ * Thin wrapper around deleteRecord() — translates ToolResult errors to WS messages.
+ */
+declare function handleDelete(ctx: RecordContext, ws: WebSocket, attachment: ConnectionAttachment, payload: DeletePayload): void;
+/**
+ * Put (create/update) a record. Returns ToolResult instead of sending WS messages.
+ * Performs schema validation, RBAC checks, and broadcasts changes.
+ *
+ * @param skipUserRbac - When true, skip user role checks. Used by server actions
+ *   that have already been authorized at the app level.
+ * @param systemUpdate - When true, also skip system-managed field stripping.
+ *   Used for server-initiated updates to system fields (e.g. user profile sync).
+ */
+declare function putRecord(ctx: RecordContext, collection: string, recordId: string, data: Record<string, unknown>, userId: string, userRole: string, skipUserRbac?: boolean, systemUpdate?: boolean): ToolResult;
+/**
+ * Delete a record. Returns ToolResult instead of sending WS messages.
+ * Performs RBAC check and broadcasts the deletion.
+ *
+ * @param skipUserRbac - When true, skip user role checks. Used by server actions.
+ */
+declare function deleteRecord(ctx: RecordContext, collection: string, recordId: string, userId: string, userRole: string, skipUserRbac?: boolean): ToolResult;
+/**
+ * Read a single record with RBAC check. Returns ToolResult.
+ *
+ * @param skipUserRbac - When true, skip user role checks. Used by server actions.
+ */
+declare function readRecord(ctx: RecordContext, collection: string, recordId: string, userId: string, userRole: string, skipUserRbac?: boolean): ToolResult;
+
+/**
+ * User management handlers for RecordRoom
+ *
+ * Users are stored in the c_users table (table-mode).
+ * System-managed fields (email, name, role, etc.) can only be set by registerUser().
+ */
+
+interface UserContext {
+    sql: SqlStorage;
+    state: DurableObjectState;
+    schemaRegistry: SchemaRegistry;
+    send(ws: WebSocket, message: {
+        type: string;
+        payload: unknown;
+    }): void;
+}
+/**
+ * Get a single user by ID from the c_users table.
+ */
+declare function getUser(sql: SqlStorage, userId: string, schemaRegistry?: SchemaRegistry): User | null;
+/**
+ * Get all users from the c_users table.
+ */
+declare function getAllUsers(sql: SqlStorage, schemaRegistry?: SchemaRegistry): User[];
+/**
+ * Register or update a user in the c_users table.
+ *
+ * This is the ONLY way to set system-managed fields (email, name, role, etc.).
+ * Normal mutations via handlePut will reject changes to system-managed fields.
+ *
+ * Role derivation (in order of priority):
+ * 1. isAdmin=true (global admin, canvas owner, or app owner) → always 'admin'
+ * 2. Existing role in users collection (preserved)
+ * 3. Default role (configurable per-app, defaults to 'member')
+ *
+ * This allows each miniapp to define its own role hierarchy while
+ * ensuring admins and owners always have full access.
+ */
+declare function registerUser(sql: SqlStorage, userId: string, name: string, email: string, imageUrl: string | undefined, isAdmin: boolean, defaultRole?: string, schemaRegistry?: SchemaRegistry): Promise<User>;
+/**
+ * Handle user list request.
+ * Returns all users with full data (system + app fields).
+ */
+declare function handleUserList(ctx: UserContext, ws: WebSocket, _attachment: ConnectionAttachment): void;
+/**
+ * Handle user profile update.
+ *
+ * Called when the client's profile loads after the initial WS connection.
+ * Updates the user's name/email/imageUrl in c_users and broadcasts the
+ * updated user list to all connected clients so names refresh in real time.
+ */
+interface UserUpdatePayload {
+    name?: string;
+    email?: string;
+    imageUrl?: string;
+}
+declare function handleUserUpdate(ctx: RecordContext, ws: WebSocket, attachment: ConnectionAttachment, payload: UserUpdatePayload): void;
+/**
+ * Handle set role request (admin only).
+ * Updates the role field in the c_users table.
+ */
+declare function handleSetRole(ctx: UserContext, ws: WebSocket, attachment: ConnectionAttachment, payload: SetRolePayload): Promise<void>;
+
+/**
+ * Yjs collaborative editing handlers for RecordRoom
+ */
+
+/**
+ * Schemas for system collections.
+ * These have empty columns arrays — they only use system columns
+ * (_row_id, _created_by, _created_at, _updated_at).
+ * Yjs data is stored in the yjs_docs table, not in the record itself.
+ */
+declare const SYSTEM_COLLECTION_SCHEMAS: CollectionSchema[];
+interface YjsContext {
+    sql: SqlStorage;
+    state: DurableObjectState;
+    yjsDocs: Map<YjsDocKey, Y.Doc>;
+    schemaRegistry: SchemaRegistry;
+    getPermissionContext(): PermissionContext;
+    send(ws: WebSocket, message: {
+        type: string;
+        payload: unknown;
+    }): void;
+    sendBinary(ws: WebSocket, data: Uint8Array): void;
+}
+/**
+ * Create a Yjs doc key from collection, recordId, and fieldName
+ */
+declare function getYjsDocKey(collection: string, recordId: string, fieldName: string): YjsDocKey;
+/**
+ * Get or create a Y.Doc for a record field.
+ * Loads from database if exists, creates new if not.
+ */
+declare function getOrCreateYjsDoc(ctx: YjsContext, docKey: YjsDocKey): Promise<Y.Doc>;
+/**
+ * Save Yjs doc state to database.
+ */
+declare function saveYjsDoc(sql: SqlStorage, docKey: YjsDocKey, doc: Y.Doc): void;
+/**
+ * Handle request to join Yjs sync for a record field.
+ * System collections (see SYSTEM_COLLECTIONS) are permissive; others require schema.
+ */
+declare function handleYjsJoin(ctx: YjsContext, ws: WebSocket, attachment: ConnectionAttachment, payload: YjsJoinPayload): Promise<void>;
+/**
+ * Handle request to leave Yjs sync for a record field.
+ */
+declare function handleYjsLeave(ws: WebSocket, attachment: ConnectionAttachment, payload: YjsLeavePayload): void;
+/**
+ * Handle binary Yjs sync messages from clients.
+ *
+ * Protocol:
+ * - MSG_SYNC_STEP1: Client sends state vector → Server responds with SYNC_STEP2 (diff)
+ * - MSG_SYNC_STEP2/UPDATE: Client sends update → Server applies and broadcasts
+ */
+declare function handleYjsBinaryMessage(ctx: YjsContext, ws: WebSocket, attachment: ConnectionAttachment, data: Uint8Array): Promise<void>;
+/**
+ * Broadcast a Yjs update to all subscribers of a doc, except the sender.
+ */
+declare function broadcastYjsUpdate(ctx: YjsContext, docKey: YjsDocKey, update: Uint8Array, excludeWs: WebSocket | null): void;
+
+/**
+ * HTTP Debug API handlers for RecordRoom
+ */
+
+interface DebugApiContext extends SubscriptionContext {
+    state: DurableObjectState;
+    yjsDocs: Map<YjsDocKey, Y.Doc>;
+    sendBinary: (ws: WebSocket, data: Uint8Array) => void;
+}
+/**
+ * Handle HTTP API requests (for debugging)
+ */
+declare function handleApiRequest(ctx: DebugApiContext, request: Request, url: URL): Promise<Response>;
+
+/**
+ * Tools API HTTP handlers for RecordRoom
+ *
+ * Provides an HTTP interface for agent tool calls (records, schemas, users).
+ *
+ * Caller identity is supplied via HTTP headers:
+ *
+ *   X-User-Id:    <userId>     — identifies the caller (required for any
+ *                                 tool that touches user-bound data).
+ *   X-App-Action: 'true'       — bypass user RBAC because the app's
+ *                                 server-side code is already the trust
+ *                                 boundary. Used by server actions and
+ *                                 cron jobs; unsafe to pass from clients.
+ *
+ * The userId is looked up in the users collection to derive the caller's
+ * role. All operations go through the same RBAC checks as the WebSocket
+ * path unless flagged as an app action.
+ */
+
+interface ToolsApiContext extends SubscriptionContext {
+    state: DurableObjectState;
+    yjsDocs: Map<YjsDocKey, Y.Doc>;
+    sendBinary: (ws: WebSocket, data: Uint8Array) => void;
+    ownerUserId?: string;
+}
+/**
+ * Handle /tools/ API requests.
+ * Called from handleApiRequest when path starts with 'tools/'.
+ */
+declare function handleToolsRequest(ctx: ToolsApiContext, request: Request, path: string): Promise<Response>;
+
+/**
+ * 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 (usually the configured platform API URL) */
+    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>;
+
+/**
+ * Subscription primitives shared between client (useSubscription hook) and
+ * server (requireSubscription helper). Pulled into a shared module so the
+ * entitlement gate has a single source of truth — if it ever diverges between
+ * client and server, gated features silently disagree about who's allowed in,
+ * which is a security bug, not a UX bug.
+ */
+type SubscriptionStatus = 'none' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'unpaid' | 'paused';
+/** Per-interval price advertised by a plan. */
+interface PlanPrice {
+    interval: 'month' | 'year';
+    priceCents: number;
+    currency?: string;
+}
+/**
+ * Plan shape returned by `/api/subscriptions/me` and consumed directly by
+ * `<PricingTable plans={sub.plans}>`. Fields beyond slug/rank are optional so
+ * a free tier (no prices, no trial) doesn't need to fabricate them.
+ */
+interface PlanInfo {
+    slug: string;
+    rank: number;
+    name: string;
+    trialDays?: number | null;
+    prices: PlanPrice[];
+}
+
+/**
+ * Server-side subscription helpers. Called from the developer's worker
+ * (Hono Context) — they proxy to the api-worker's `/api/subscriptions/me`
+ * using the worker's signed app-identity headers, so the same trust
+ * model the SDK hook uses applies here.
+ */
+
+interface SubscriptionRead {
+    tier: string;
+    status: SubscriptionStatus;
+    currentPeriodEnd: number | null;
+    cancelAtPeriodEnd: boolean;
+    trialEndsAt: number | null;
+    plans: PlanInfo[];
+}
+interface StarterAppEnv$1 extends ApiWorkerEnv {
+    APP_IDENTITY_TOKEN: string;
+    APP_NAME: string;
+}
+declare function getSubscription(c: Context<{
+    Bindings: StarterAppEnv$1;
+}>): Promise<SubscriptionRead>;
+/**
+ * Enforce a tier gate inside a route. Throws `SubscriptionRequiredError` if
+ * the caller's subscription doesn't meet the requested tier OR isn't currently
+ * entitled (status ∈ {active, trialing}). Callers do
+ * `await requireSubscription(c, { atLeast: 'pro' })` and let the thrown
+ * response propagate.
+ *
+ * Why the status gate: a row with `planSlug='pro'` and `status='past_due'`
+ * means "this user used to be on Pro but their payment is overdue" — paid
+ * features should not unlock. Same for canceled/unpaid/incomplete.
+ */
+declare function requireSubscription(c: Context<{
+    Bindings: StarterAppEnv$1;
+}>, opts: {
+    tier?: string;
+    atLeast?: string;
+}): Promise<SubscriptionRead>;
+declare class SubscriptionRequiredError extends Error {
+    readonly required: string;
+    readonly current: string;
+    constructor(required: string, current: string);
+}
+/**
+ * Thrown by `getSubscription` / `requireSubscription` when the upstream
+ * `/api/subscriptions/me` rejects the caller with 401 or 403 — typically
+ * because the inbound request didn't carry a Bearer token, or carried one
+ * the api-worker can't verify. Distinct from `SubscriptionRequiredError`
+ * (which is about tier/entitlement, not identity) so route handlers can
+ * map identity failures to 401 and tier failures to 402.
+ */
+declare class SubscriptionAuthError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/**
+ * Cancel one customer's subscription, or every subscription on a given plan.
+ *
+ * Forwards the inbound `Authorization` header — the platform verifies the
+ * actor is the app owner before calling Stripe. As with `refundInvoice`,
+ * gate this in your own admin route too; the platform check is the second
+ * layer, not the first.
+ *
+ * Defaults to `atPeriodEnd: true` so customers aren't cut off mid-cycle.
+ * Pass `atPeriodEnd: false` for an immediate cancel (refund handled
+ * separately if you want one).
+ */
+interface CancelSubscriptionOpts {
+    /** Cancel one specific customer's subscription. Mutually exclusive with `planSlug`. */
+    userId?: string;
+    /** Cancel every active subscription on this plan. Mutually exclusive with `userId`. */
+    planSlug?: string;
+    /** Default true. Pass false for an immediate cancel. */
+    atPeriodEnd?: boolean;
+    /** Optional free-form audit reason. */
+    reason?: string;
+}
+interface CancelSubscriptionResult {
+    success: boolean;
+    canceled: number;
+    failures: Array<{
+        stripeSubscriptionId: string;
+        error: string;
+    }>;
+    atPeriodEnd: boolean;
+    /**
+     * True when the matching subscription set was larger than the server-side
+     * batch limit (currently 50). Loop the call until this returns false to
+     * cancel every remaining row — the `cancel_at_period_end` flag is
+     * idempotent, so re-flagging an already-flagged subscription is a no-op.
+     */
+    hasMore: boolean;
+}
+declare function cancelSubscription(c: Context<{
+    Bindings: StarterAppEnv$1;
+}>, opts: CancelSubscriptionOpts): Promise<CancelSubscriptionResult>;
+declare class CancelSubscriptionError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+
+interface StarterAppEnv extends ApiWorkerEnv {
+    APP_IDENTITY_TOKEN: string;
+    APP_NAME: string;
+}
+interface RefundResult {
+    success: boolean;
+    stripeRefundId: string;
+    amountRefunded: number;
+    status: 'pending' | 'succeeded' | 'failed' | 'canceled' | 'requires_action' | null;
+}
+interface RefundOpts {
+    invoiceId: string;
+    amount?: number;
+    reason?: 'requested_by_customer' | 'duplicate' | 'fraudulent';
+    requestNonce?: string;
+}
+declare function refundInvoice(c: Context<{
+    Bindings: StarterAppEnv;
+}>, opts: RefundOpts): Promise<RefundResult>;
+declare class RefundError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+
+export { AI_CHATS_SCHEMA, AI_MESSAGES_SCHEMA, ALLOWED_BINDING_TYPES, APP_NAME_RULES, AUTO_PROVISIONABLE_TYPES, AUTO_PROVISION_SENTINEL, type ActionContext, type ActionHandler, type ActionResult, type ActionTools, type ApiWorkerEnv, type AppNameResolution, type AppNameValidation, type AuthWorkerEnv, BASE_USERS_SCHEMA, BUILT_IN_TOOLS, BaseRoom, CHANNELS_SCHEMA, CHANNEL_INVITATIONS_SCHEMA, CHANNEL_MEMBERS_SCHEMA, CONVERSATION_SCHEMAS, COST_RATES, CancelSubscriptionError, type CancelSubscriptionOpts, type CancelSubscriptionResult, CanvasRoom, type CanvasShape, type ChatContextConfig, type ChatMessageRow, type ChatRow, type ChatTurn, type CollectionPermissionSummary, type CollectionSchema, type ColumnDefinition, type ColumnInterpretation, type ConvMemberData, type ConvMessageData, type ConvReactionData, type ConvReadCursorData, type ConvVoteData, type ConversationStateData, type CronContext, type CronExecution, CronRoom, type CronRoomConfig, type CronTask, type CustomBinding, type CustomBindingManifest, DEFAULT_CONTEXT_CONFIG, DEFAULT_DO_MANIFEST, DEFAULT_MAX_SKEW_MS, DIRECTORY_SCHEMAS, type DOBindings, type DOManifest, type DOManifestEntry, type DebugApiContext, type DeepSpaceAIEnv, type DeepSpaceAIOptions, type DeepSpaceAuth, type DeepSpaceAuthConfig, type DirectoryCommunityData, type DirectoryConversationData, type DirectoryMembershipData, type DirectoryPostData, type DoMigrationDirective, type DoMigrationPlan, type ExistingDOBinding, GLOBAL_DO_TYPES, GLOBAL_DO_TYPE_NAMES, type GameInput, GameRoom, type GameRoomConfig, type GetActionData, type GlobalDOType, type InternalSignature, type JwtClaims, type JwtVerifierConfig, MESSAGES_SCHEMA, type MutateActionData, type PermissionAnalysis, type PermissionContext, type PermissionLevel, type PermissionSource, type PlanInfo, type PlatformWorkerEnv, type Player, type PrefixResult, type PresencePeer, PresenceRoom, type QueryActionData, REACTIONS_SCHEMA, READ_RECEIPTS_SCHEMA, RESERVED_BINDING_NAMES, RESERVED_COLLECTION_NAMES, type RecordContext, RecordRoom, type RecordRoomConfig, RefundError, type RefundOpts, type RefundResult, type ResolvedColumn, type ResolvedPermission, type RolePermissions, type RunMigrationsResult, SYSTEM_COLLECTION_SCHEMAS, SYSTEM_MANAGED_COLUMNS, SchemaRegistry, type ScopeContext, type ScopedR2Auth, type ScopedR2Config, type ScopedR2Handler, type ScreenshotEnv, type ScreenshotOptions, type ScreenshotResult, type SharedConnection, type SignInternalPayloadInput, type StoredRecord, SubscriptionAuthError, type SubscriptionContext, type SubscriptionRead, SubscriptionRequiredError, type SubscriptionStatus, type Summarizer, type TokenDebugInfo, type ToolResult, type ToolSchema, type ToolsApiContext, USERS_COLUMNS, type User, type UserAttachment, type UserContext, VOTING_SCHEMAS, type ValidationError, type VerifiedAuth, type VerifyInternalSignatureInput, type VerifyOutcome, type VerifyResult, type Viewport, WORKSPACE_SCHEMAS, type YjsContext, YjsRoom, analyzePermissions, apiWorkerFetch, appendMessage, applySlidingWindow, authWorkerFetch, bindingManifestFromOutputConfig, broadcastChange, broadcastYjsUpdate, buildCronContext, buildInternalPayload, buildTableSelect, buildUiParts, canCreate, canDelete, canRead, canUpdate, cancelSubscription, capToolResultSize, captureScreenshot, checkFieldPermissions, coerceValue, collectionTableName, columnId, computeDoMigration, computeHmacHex, createChat, createDeepSpaceAI, createDeepSpaceAuth, createScopedR2Handler, dataToColumnValues, decodeJwtPayload, deleteChatCascade, deleteRecord, executeQuery, getAllUsers, getChat, getGlobalDOSchemas, getGlobalDOType, getOrCreateYjsDoc, getRecord, getRolePermissions, getSubscription, getUser, getYjsDocKey, handleApiRequest, handleDelete, handlePut, handleSetRole, handleSubscribe, handleToolsRequest, handleUnsubscribe, handleUserList, handleUserUpdate, handleYjsBinaryMessage, handleYjsJoin, handleYjsLeave, isAutoProvision, isOwner, lintSchema, loadMessages, makeDefaultSummarizer, meterAi, meterUsage, meterVectorize, noopPermissionContext, platformWorkerFetch, prepareMessagesWithCompaction, priceBindingUsageEvent, putRecord, readRecord, recordMatchesSubscription, refundInvoice, registerUser, requireSubscription, resolveAppName, resolveColumn, rowToData, runMigrations, saveYjsDoc, signInternalPayload, timingSafeEqualHex, totalChars, truncateOldToolResults, turnsToCoreMessages, unwrapToolOutput, updateChat, validateAppName, validateBindingManifest, validateDoManifest, verifyInternalSignature, verifyJwt, workspaceAccountsSchema, workspaceContentSharesSchema, workspaceEmailHandlesSchema, workspaceFormResponsesSchema, workspacePeopleSchema, workspaceProjectsSchema, workspaceTagsSchema, workspaceTasksSchema, workspaceTeamMembersSchema, workspaceTeamsSchema, workspaceTransactionsSchema };