@velajs/cloudflare 1.10.0 → 1.22.0

package/dist/index.d.ts

@@ -1,41 +1,622 @@
-export { cloudflareAdapter, createCloudflareApp } from './cloudflare-factory';
-export type { CreateCloudflareAppOptions } from './cloudflare-factory';
-export { CloudflareApplication } from './cloudflare-application';
-export type { MountOpenApiOptions } from './cloudflare-application';
-export { KVModule } from './modules/kv.module';
-export { D1Module } from './modules/d1.module';
-export { R2Module } from './modules/r2.module';
-export { QueueModule } from './modules/queue.module';
-export { DurableObjectModule } from './modules/durable-object.module';
-export { AIModule } from './modules/ai.module';
-export { VectorizeModule } from './modules/vectorize.module';
-export { HyperdriveModule } from './modules/hyperdrive.module';
-export { EnvModule } from './modules/env.module';
-export { StorageModule, StorageService, StorageManagerService, StorageController, R2StorageDriver, STORAGE_OPTIONS, } from './storage/index';
-export type { StorageModuleOptions, DiskConfig, PresignedUrlConfig } from './storage/index';
-export { KVService } from './services/kv.service';
-export { KVCacheStore } from './services/kv-cache.store';
-export { D1Service } from './services/d1.service';
-export { R2Service } from './services/r2.service';
-export { QueueService } from './services/queue.service';
-export { DurableObjectService } from './services/durable-object.service';
-export { AIService } from './services/ai.service';
-export { VectorizeService } from './services/vectorize.service';
-export { HyperdriveService } from './services/hyperdrive.service';
-export { EnvService } from './services/env.service';
-export { FlagshipFlagDriver, flagshipFlagDriver } from './services/flagship-flag.driver';
-export type { FlagshipBinding, FlagshipFlagDriverOptions } from './services/flagship-flag.driver';
-export { KvFlagDriver, kvFlagDriver } from './services/kv-flag.driver';
-export type { KvFlagDriverOptions } from './services/kv-flag.driver';
-export { Env } from './decorators/env';
-export { Scheduled } from './decorators/scheduled';
-export { QueueConsumer } from './decorators/queue-consumer';
-export { VelaWebSocketDurableObject, CloudflareWebSocketModule, broadcastToRoom, } from './websocket/index';
-export type { WsGatewayRoute } from './websocket/index';
-export { DoCursorLog, durableObjectCursorLog, durableObjectLive, liveInvalidateToRoom, } from './websocket/index';
-export type { CfLiveDriver, DurableObjectLiveOptions } from './websocket/index';
-export { WebSocketGateway, SubscribeMessage, MessageBody, ConnectedSocket, WebSocketServer, WsException, } from '@velajs/vela/websocket';
-export type { WsClient, WsServer, WsResponse, WsMessage, OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect, } from '@velajs/vela/websocket';
-export type { CloudflareEnv, ScheduledRegistration, QueueRegistration } from './types';
-export type { ScheduledMetadata } from './decorators/scheduled';
-export type { QueueConsumerMetadata } from './decorators/queue-consumer';
+import { a as DoPitrId, c as DoPitrUnavailableError, d as isDoPitrUnavailable, f as readDoPitrBookmark, i as DoPitrBookmarkRead, l as VelaDoPitrRpc, n as DoPitrArmOptions, o as DoPitrNamespace, p as CloudflareRoot, r as DoPitrArmResult, s as DoPitrStorage, t as VelaNonceDurableObject, u as armDoPitr } from "./nonce.durable-object-Df3_42Sy.js";
+import { AsyncCacheStore, DynamicModule, InjectionToken, NonceStore, RuntimeAdapter, ThrottlerStore, Type, VelaApplication, VelaMiddlewareHandler, VelaSecurityOptions } from "@velajs/vela";
+import { BroadcastCommand, ConnectedSocket, MessageBody, OnGatewayConnection, OnGatewayDisconnect, OnGatewayInit, SubscribeMessage, WebSocketGateway, WebSocketGatewayOptions, WebSocketServer, WsClient, WsDispatcher, WsException, WsMessage, WsResponse, WsServer } from "@velajs/vela/websocket";
+import { DownloadResult, PresignMethod, PresignedUrlResult, StorageBody, StorageDriver, UploadOptions, UploadResult } from "@velajs/vela/storage";
+import { CommitStamp, CursorLog, InvalidationCommand, LiveDriver, LiveEngine, LiveInvalidationSink, ResumeVerdict } from "@velajs/vela/live";
+import { Context, ExecutionContext } from "hono";
+import { FeatureFlagDriver, FlagContext } from "@velajs/feature-flags";
+//#region src/websocket/room-id.d.ts
+/** Stable, collision-free Durable Object name for one gateway's room. */
+export declare function durableObjectRoomName(gatewayPath: string, roomId: string): string;
+//#endregion
+//#region src/websocket/websocket-routing.d.ts
+interface WsGatewayRoute {
+  path: string;
+  binding: string;
+  options: WebSocketGatewayOptions;
+}
+//#endregion
+//#region src/cloudflare-application.d.ts
+/**
+ * Options accepted by {@link CloudflareApplication.mountOpenApi}.
+ *
+ * Re-exposes vela's `MountOpenApiOptions` type — derived structurally from
+ * the underlying `VelaApplication.mountOpenApi` signature so consumers don't
+ * have to reach into vela's internal subpaths to type the argument.
+ */
+type MountOpenApiOptions = Parameters<VelaApplication['mountOpenApi']>[0];
+/**
+ * Wraps VelaApplication with Cloudflare-specific handlers:
+ * - `fetch` — HTTP request handler (from Hono)
+ * - `scheduled` — Cron trigger handler (matches `@Scheduled()` decorators
+ *                 AND vela's own `@Cron()` jobs)
+ * - `queue` — Queue consumer handler (matches `@QueueConsumer()` decorators)
+ * - `mountOpenApi` — Serve an OpenAPI document (and optional Scalar UI) on
+ *                    the underlying Hono app
+ *
+ * @example
+ * ```ts
+ * const app = await createCloudflareApp(AppModule, { env, envToken: ENV });
+ * export default {
+ *   fetch: app.fetch,
+ *   scheduled: app.scheduled.bind(app),
+ *   queue: app.queue.bind(app),
+ * };
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Serve OpenAPI docs alongside your routes
+ * const app = await createCloudflareApp(AppModule, { env, envToken: ENV });
+ * const document = createOpenApiDocument(AppModule);
+ * app.mountOpenApi({ document, ui: 'scalar' });
+ * // GET /openapi.json -> JSON document
+ * // GET /scalar       -> Scalar UI (loads from CDN)
+ * ```
+ */
+export declare class CloudflareApplication<T extends object = object> {
+  private app;
+  readonly env: T;
+  private wsGatewayRoutes;
+  constructor(app: VelaApplication, env: T);
+  readonly fetch: (request: Request, env: T, ctx?: ExecutionContext) => Promise<Response>;
+  getHonoApp(): ReturnType<VelaApplication['getHonoApp']>;
+  /**
+   * Resolve a provider from the application's DI container (delegates to
+   * `VelaApplication.get`). Handy for grabbing a service — e.g. an auth service —
+   * to use inside `createCloudflareApp({ middleware: env => [...] })` request middleware,
+   * which runs outside the DI request pipeline.
+   *
+   * @example
+   * ```ts
+   * const app = await createCloudflareApp(AppModule, { env, envToken: ENV });
+   * const auth = app.get(BetterAuthService);
+   * ```
+   */
+  readonly get: VelaApplication['get'];
+  get entrypoints(): VelaApplication['entrypoints'];
+  /**
+   * Serve a pre-built OpenAPI document (and optionally a Scalar UI) on the
+   * underlying Hono app. Delegates verbatim to `VelaApplication.mountOpenApi`,
+   * so the JSON endpoint defaults to `/openapi.json` and the Scalar UI (when
+   * opted in) defaults to `/scalar`. Edge-safe — the UI HTML loads Scalar from
+   * a CDN at runtime, nothing is bundled server-side.
+   *
+   * @example
+   * ```ts
+   * import { createOpenApiDocument } from '@velajs/vela';
+   *
+   * const app = await createCloudflareApp(AppModule, { env, envToken: ENV });
+   * const document = createOpenApiDocument(AppModule, {
+   *   info: { title: 'My API', version: '1.0.0' },
+   * });
+   * app.mountOpenApi({ document, ui: 'scalar' });
+   * // GET /openapi.json -> { openapi: '3.1.0', ... }
+   * // GET /scalar       -> Scalar UI HTML
+   * ```
+   */
+  mountOpenApi(options: MountOpenApiOptions): this;
+  /**
+   * @internal — scans instances for `@WebSocketGateway({ path, binding })`
+   * upgrade routes. Queue/scheduled handlers are NOT scanned anymore: they
+   * come from `app.entrypoints` (`cf:queue` / `cf:scheduled` / `cf:vela-cron`
+   * kinds) at dispatch time.
+   */
+  scanInstances(instances: unknown[]): void;
+  /** @internal — upgrade routes discovered from `@WebSocketGateway({ path, binding })`. */
+  getWsGatewayRoutes(): WsGatewayRoute[];
+  /**
+   * Handle Cloudflare scheduled (cron) events.
+   * Matches the event's cron expression to `@Scheduled()` and vela `@Cron()`
+   * handlers read from `app.entrypoints`; each handler runs inside a fresh
+   * request-scoped child (request-scoped providers rebuild per tick).
+   */
+  scheduled(event: {
+    cron: string;
+    scheduledTime?: number;
+  }, env: T, ctx: {
+    waitUntil: (promise: Promise<unknown>) => void;
+  }): Promise<void>;
+  /**
+   * Run one entrypoint handler inside a fresh request scope, through the
+   * shared guard → interceptor pipeline (components declared with
+   * `@UseGuards`/`@UseInterceptors`/`@UseFilters` on the consumer class or
+   * method). HTTP-global components deliberately do NOT apply — an HTTP auth
+   * guard has no business rejecting a queue batch. Unclaimed errors rethrow
+   * so the platform's retry semantics stay intact.
+   */
+  private dispatchEntrypoint;
+  /**
+   * Handle Cloudflare Queue consumer events.
+   * Matches the batch queue name to `@QueueConsumer()` handlers read from
+   * `app.entrypoints`; each batch is processed inside a fresh request-scoped
+   * child (request-scoped providers rebuild per batch — no boot-time captives).
+   */
+  queue(batch: {
+    queue: string;
+    messages: readonly unknown[];
+  }, env: T, ctx: {
+    waitUntil: (promise: Promise<unknown>) => void;
+  }): Promise<void>;
+  close(signal?: string): Promise<void>;
+}
+//#endregion
+//#region src/cloudflare-factory.d.ts
+interface CloudflareWorkerOptions<T extends object> {
+  /** Global typed DI token for the platform's native environment. */
+  envToken: InjectionToken<T>;
+  globalPrefix?: string;
+  security?: VelaSecurityOptions;
+  /** Build request middleware from the same typed native environment as DI. */
+  middleware?: (env: NoInfer<T>) => VelaMiddlewareHandler[];
+}
+interface CreateCloudflareAppOptions<T extends object> extends CloudflareWorkerOptions<T> {
+  /** Supply the platform environment inside fetch/queue/scheduled or a DO constructor. */
+  env: NoInfer<T>;
+}
+/** Bind an application to one environment before provider factories and lifecycle hooks. */
+export declare function cloudflareAdapter<T extends object>(options: CreateCloudflareAppOptions<T>): RuntimeAdapter;
+/** Build an application for one native Workers environment. Call inside a platform event. */
+export declare function createCloudflareApp<T extends object>(rootModule: CloudflareRoot<NoInfer<T>>, options: CreateCloudflareAppOptions<T>): Promise<CloudflareApplication<T>>;
+/**
+ * Worker entrypoint with one bootstrap per environment identity. Weak keys let
+ * obsolete environments and secrets be collected. Concurrent cold events share
+ * construction; failed construction is evicted so the next event can retry.
+ */
+export declare function createCloudflareWorker<T extends object>(rootModule: CloudflareRoot<NoInfer<T>>, options: CloudflareWorkerOptions<T>): {
+  fetch(request: Request, env: T, ctx: ExecutionContext): Promise<Response>;
+  scheduled(event: {
+    cron: string;
+    scheduledTime?: number;
+  }, env: T, ctx: {
+    waitUntil: (promise: Promise<unknown>) => void;
+  }): Promise<void>;
+  queue(batch: {
+    queue: string;
+    messages: readonly unknown[];
+  }, env: T, ctx: {
+    waitUntil: (promise: Promise<unknown>) => void;
+  }): Promise<void>;
+};
+//#endregion
+//#region src/storage/storage.types.d.ts
+/** A named storage disk backed by an R2 bucket binding. */
+interface DiskConfig {
+  disk: string;
+  /** Native bucket supplied by a typed environment provider factory. */
+  bucket: R2Bucket;
+  /** Optional root prefix; supports path-template tokens ({date}/{year}/…). */
+  root?: string;
+}
+interface PresignedUrlConfig {
+  defaultExpiry: number;
+  maxExpiry: number;
+}
+interface StorageModuleOptions {
+  /** HMAC secret used for signed downloads. */
+  secret?: string;
+  disks: DiskConfig[];
+  defaultDisk: string;
+  presignedUrl?: PresignedUrlConfig;
+}
+//#endregion
+//#region src/storage/storage.module.d.ts
+declare const ConfigurableModuleClass: import("@velajs/vela").ConfigurableModuleClassType<StorageModuleOptions, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+export declare class StorageModule extends ConfigurableModuleClass {}
+//#endregion
+//#region src/storage/r2-storage.driver.d.ts
+interface R2StorageDriverConfig {
+  disk: string;
+  bucket: R2Bucket;
+  /** HMAC secret for presigned URLs (typically env.APP_SECRET). */
+  secret?: string;
+}
+/** {@link StorageDriver} over a Cloudflare R2 bucket. */
+export declare class R2StorageDriver implements StorageDriver {
+  private readonly config;
+  constructor(config: R2StorageDriverConfig);
+  upload(body: StorageBody, path: string, options: UploadOptions): Promise<UploadResult>;
+  download(path: string): Promise<DownloadResult>;
+  delete(path: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  getPresignedUrl(path: string, method: PresignMethod, expiresIn: number): Promise<PresignedUrlResult>;
+}
+//#endregion
+//#region src/storage/storage-manager.service.d.ts
+export declare class StorageManagerService {
+  private readonly options;
+  constructor(options: StorageModuleOptions);
+  hasDisk(disk: string): boolean;
+  getDiskConfig(disk: string): DiskConfig;
+  getDriver(disk: string): R2StorageDriver;
+}
+//#endregion
+//#region src/storage/storage.service.d.ts
+/**
+ * Multi-disk storage facade. Applies each disk's (templated) root, resolves the
+ * driver, and validates presign expiry. Injectable anywhere via `StorageService`.
+ */
+export declare class StorageService {
+  private readonly options;
+  private readonly manager;
+  constructor(options: StorageModuleOptions, manager: StorageManagerService);
+  put(relativePath: string, body: StorageBody, options?: UploadOptions, disk?: string): Promise<UploadResult>;
+  get(relativePath: string, disk?: string): Promise<DownloadResult>;
+  delete(relativePath: string, disk?: string): Promise<void>;
+  exists(relativePath: string, disk?: string): Promise<boolean>;
+  url(relativePath: string, method?: PresignMethod, expiresIn?: number, disk?: string): Promise<PresignedUrlResult>;
+  private resolveDisk;
+  private fullPath;
+  private validateExpiry;
+}
+//#endregion
+//#region src/storage/storage.controller.d.ts
+/**
+ * Presign-proxy: serves objects for HMAC-signed URLs produced by
+ * `StorageService.url()`. R2 has no native presign, so a signed URL points here;
+ * this route verifies the signature (+expiry) before streaming the object.
+ * The FULL object key (root already applied at sign time) is carried as an
+ * opaque base64url query claim. The signature is verified before the claim is
+ * decoded exactly once and checked against the configured disk root.
+ */
+export declare class StorageController {
+  private readonly manager;
+  private readonly options;
+  constructor(manager: StorageManagerService, options: StorageModuleOptions);
+  download(c: Context): Promise<Response>;
+}
+//#endregion
+//#region src/storage/storage.tokens.d.ts
+export declare const STORAGE_OPTIONS: InjectionToken<StorageModuleOptions>;
+//#endregion
+//#region src/services/kv-cache.store.d.ts
+/**
+ * Cloudflare KV-backed {@link CacheStore}. Values are JSON-encoded. Intended as
+ * the slow tier under a `TieredCacheStore` (memory L1 → KV L2), but usable
+ * standalone from a typed environment factory: `new KVCacheStore(env.CACHE)`.
+ * Reads return unknown JSON; validate values at the consuming boundary.
+ *
+ * Note: Cloudflare KV requires `expirationTtl >= 60s`, so sub-minute TTLs are
+ * clamped up. Keep short TTLs on the memory tier; use KV for longer-lived entries.
+ */
+export declare class KVCacheStore implements AsyncCacheStore {
+  private readonly ns;
+  constructor(ns: KVNamespace);
+  get(key: string): Promise<unknown>;
+  set(key: string, value: unknown, ttl?: number): Promise<void>;
+  del(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/services/flagship-flag.driver.d.ts
+/**
+ * The subset of a Cloudflare **Flagship** binding this driver evaluates against
+ * — the four typed value methods. The binding itself returns the supplied
+ * `defaultValue` on evaluation errors; transport-level failures reject and are
+ * left to propagate (never-throw is the service layer's job, not the driver's).
+ *
+ * @see https://developers.cloudflare.com/flagship/binding/
+ */
+interface FlagshipBinding {
+  getBooleanValue(key: string, defaultValue: boolean, context?: FlagContext): Promise<boolean>;
+  getStringValue(key: string, defaultValue: string, context?: FlagContext): Promise<string>;
+  getNumberValue(key: string, defaultValue: number, context?: FlagContext): Promise<number>;
+  getObjectValue(key: string, defaultValue: object, context?: FlagContext): Promise<unknown>;
+}
+interface FlagshipFlagDriverOptions {
+  /** Driver name used for `use(name)` / default-driver selection. Default `"flagship"`. */
+  name?: string;
+}
+/**
+ * {@link FeatureFlagDriver} backed by a Cloudflare Flagship binding.
+ *
+ * A thin, honest wrapper: each contract method maps 1:1 onto the binding's
+ * corresponding value method, forwarding the caller's `fallback` (the binding's
+ * `defaultValue`) and evaluation context. The binding resolves the fallback on
+ * evaluation errors; anything the binding *rejects* with (e.g. a `remote: true`
+ * dev-proxy tunnel dropping) propagates — `@velajs/feature-flags`'s service owns
+ * the never-throw guarantee.
+ *
+ * Build the driver inside a provider factory with the native environment:
+ *
+ * ```ts
+ * FeatureFlagsModule.forRootAsync({
+ *   inject: [ENV],
+ *   useFactory: (env: WorkerEnv) => ({ drivers: [flagshipFlagDriver(env.FLAGS)] }),
+ * });
+ * ```
+ *
+ * Evaluation ergonomics (the 1:1 binding-method mapping) are ported from the
+ * Stratal feature-flags service (MIT, © Temitayo Fadojutimi), reshaped as a
+ * bare driver.
+ */
+export declare class FlagshipFlagDriver implements FeatureFlagDriver {
+  readonly name: string;
+  private readonly resolve;
+  constructor(binding: FlagshipBinding | (() => FlagshipBinding), options?: FlagshipFlagDriverOptions);
+  getBoolean(key: string, fallback: boolean, ctx?: FlagContext): Promise<boolean>;
+  getString(key: string, fallback: string, ctx?: FlagContext): Promise<string>;
+  getNumber(key: string, fallback: number, ctx?: FlagContext): Promise<number>;
+  getObject(key: string, fallback: object, ctx?: FlagContext): Promise<unknown>;
+}
+/** Convenience factory for {@link FlagshipFlagDriver}. */
+export declare function flagshipFlagDriver(binding: FlagshipBinding | (() => FlagshipBinding), options?: FlagshipFlagDriverOptions): FlagshipFlagDriver;
+//#endregion
+//#region src/services/kv-flag.driver.d.ts
+interface KvFlagDriverOptions {
+  /** Driver name used for `use(name)` / default-driver selection. Default `"kv"`. */
+  name?: string;
+  /** Prefix prepended to every flag key before the KV read. Default `""` (none). */
+  prefix?: string;
+}
+/**
+ * Cloudflare KV-backed {@link FeatureFlagDriver}. Flags are stored as JSON
+ * values under an optional key prefix and read with `get(key, 'json')`. Reads
+ * are type-checked against the requested type: a missing key or a value of the
+ * wrong JSON type returns the caller's `fallback`. KV has no targeting, so the
+ * evaluation context is ignored.
+ *
+ * The driver stays honest — it does **not** swallow errors. A KV failure (or a
+ * `SyntaxError` from a malformed stored value) propagates; the never-throw
+ * guarantee lives in `@velajs/feature-flags`'s service layer.
+ *
+ * Placed like {@link KVCacheStore}: construct it in a wiring factory over a
+ * resolved {@link KVNamespace}.
+ *
+ * ```ts
+ * FeatureFlagsModule.forRootAsync({
+ *   inject: [ENV],
+ *   useFactory: (env: WorkerEnv) => ({ drivers: [new KvFlagDriver(env.CACHE, { prefix: 'flag:' })] }),
+ * });
+ * ```
+ */
+export declare class KvFlagDriver implements FeatureFlagDriver {
+  private readonly ns;
+  readonly name: string;
+  private readonly prefix;
+  constructor(ns: KVNamespace, options?: KvFlagDriverOptions);
+  getBoolean(key: string, fallback: boolean, _ctx?: FlagContext): Promise<boolean>;
+  getString(key: string, fallback: string, _ctx?: FlagContext): Promise<string>;
+  getNumber(key: string, fallback: number, _ctx?: FlagContext): Promise<number>;
+  getObject(key: string, fallback: object, _ctx?: FlagContext): Promise<unknown>;
+  /**
+   * Reads and JSON-parses the (prefixed) key, returning the parsed value only
+   * when `matches` accepts its type; otherwise the caller's fallback. A missing
+   * key reads as `null` → fallback. Read/parse errors are left to propagate.
+   */
+  private read;
+}
+/** Convenience factory for {@link KvFlagDriver}. */
+export declare function kvFlagDriver(kv: KVNamespace, options?: KvFlagDriverOptions): KvFlagDriver;
+//#endregion
+//#region src/decorators/env.d.ts
+/**
+ * Parameter decorator to inject Cloudflare environment bindings.
+ *
+ * Without arguments, returns the entire `env` object.
+ * With a binding name, returns that specific binding.
+ *
+ * @example
+ * ```ts
+ * @Get()
+ * handle(@Env() env: WorkerEnv) { ... }
+ *
+ * @Get()
+ * handle(@Env('MY_KV') kv: KVNamespace) { ... }
+ * ```
+ */
+export declare const Env: (data?: string | undefined, ...pipes: import("@velajs/vela").PipeType[]) => ParameterDecorator;
+//#endregion
+//#region src/decorators/scheduled.d.ts
+interface ScheduledMetadata {
+  cron: string;
+  methodName: string;
+}
+/**
+ * Marks a method as a scheduled (cron) handler.
+ *
+ * @example
+ * ```ts
+ * @Injectable()
+ * class WorkerService {
+ *   @Scheduled('0 * * * *')
+ *   async hourlyCron() {
+ *     console.log('Running hourly');
+ *   }
+ * }
+ * ```
+ */
+export declare function Scheduled(cron: string): MethodDecorator;
+//#endregion
+//#region src/decorators/queue-consumer.d.ts
+interface QueueConsumerMetadata {
+  queueName: string;
+  methodName: string;
+}
+/**
+ * Marks a method as a queue consumer handler.
+ *
+ * @example
+ * ```ts
+ * @Injectable()
+ * class WorkerService {
+ *   @QueueConsumer('email-queue')
+ *   async processEmails(batch: MessageBatch) {
+ *     for (const msg of batch.messages) {
+ *       console.log('Processing:', msg.body);
+ *       msg.ack();
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function QueueConsumer(queueName: string): MethodDecorator;
+//#endregion
+//#region src/websocket/cloudflare-websocket.module.d.ts
+/**
+ * Cloudflare counterpart to the core `WebSocketModule.forRoot()`. Import this in
+ * your `AppModule` instead: it provides the gateway dispatcher plus a late-bound
+ * `WS_SERVER` (`WsServerHolder`) that the WebSocket Durable Object wires to a
+ * ctx-backed server per instance. `useClass` ensures a fresh holder per DI
+ * container so colocated DO instances never share a server.
+ */
+export declare class CloudflareWebSocketModule {
+  static forRoot(): DynamicModule;
+}
+//#endregion
+//#region src/websocket/broadcast.d.ts
+interface WsBroadcastStub {
+  broadcast(cmd: BroadcastCommand): Promise<void>;
+}
+interface BroadcastNamespace {
+  idFromName(name: string): DurableObjectId;
+  get(id: DurableObjectId): WsBroadcastStub;
+}
+/**
+ * Push to a room from a Worker HTTP handler / cron / queue consumer (server-
+ * initiated emit). Resolves the room's Durable Object and calls its `broadcast`
+ * RPC method — the same canonical room→DO mapping the upgrade route uses, so it
+ * always reaches the DO holding those sockets.
+ *
+ * @example
+ * ```ts
+ * // In a controller — ns from the typed Worker environment
+ * await broadcastToRoom(ns, '/orgs/:orgId/ws', `org:${id}`, 'order.created', order);
+ * ```
+ */
+export declare function broadcastToRoom(ns: BroadcastNamespace, gatewayPath: string, room: string, event: string, data?: unknown, options?: {
+  exceptIds?: string[];
+  maxFrameBytes?: number;
+}): Promise<void>;
+//#endregion
+//#region src/websocket/do-state.d.ts
+/** Structural view of the DO's SQLite handle (`ctx.storage.sql`, requires `new_sqlite_classes`). */
+interface SqlStorageLike {
+  exec(query: string, ...bindings: unknown[]): {
+    toArray(): Record<string, unknown>[];
+  };
+}
+//#endregion
+//#region src/websocket/do-live.d.ts
+/**
+ * The durable `CursorLog`: an append-only tag-invalidation log in the DO's
+ * SQLite (`__vela_live_log`, AUTOINCREMENT seq = cursor) plus an epoch UUID in
+ * `__vela_live_meta`. Because the cursor survives hibernation AND trims (it is
+ * read from `sqlite_sequence`, lunora's `ctx-db-cdc.ts` trick), a reconnecting
+ * client whose gap the log still covers gets a tiny `resume` instead of a
+ * re-run — the real-resume half of the live protocol.
+ *
+ * Constructed un-initialized at module-composition time (the same app module
+ * bootstraps in the Worker AND in each DO); `initDoLive` wires the SQLite
+ * handle inside the DO. In the Worker isolate it stays un-initialized — and is
+ * never consulted there, because `durableObjectLive()` routes every
+ * invalidation to the room DO's log (one log scope per room, exactly the
+ * protocol's model).
+ */
+export declare class DoCursorLog implements CursorLog {
+  private readonly maxRows;
+  private sql?;
+  private epoch?;
+  constructor(maxRows?: number);
+  /** @internal — called by `initDoLive` with the DO's `ctx.storage.sql`. */
+  _initialize(sql: SqlStorageLike): void;
+  append(tags: string[]): CommitStamp;
+  current(): CommitStamp;
+  evaluateResume(sinceCursor: number, sinceEpoch: string, subscriptionTags: string[]): ResumeVerdict;
+  private assertReady;
+}
+interface DurableObjectLiveOptions {
+  /** Native, RPC-typed namespace supplied by the application's environment. */
+  namespace: LiveNamespace;
+  /** Exact `@WebSocketGateway()` path sharing this room/log namespace. */
+  gatewayPath: string;
+  /** Room used when an invalidation names none. Matches the client default. */
+  defaultRoom?: string;
+}
+interface LiveInvalidateStub {
+  invalidate(cmd: InvalidationCommand): Promise<CommitStamp | undefined>;
+}
+/** Only the native namespace operations required for live invalidation. */
+interface LiveNamespace {
+  idFromName(name: string): DurableObjectId;
+  get(id: DurableObjectId): LiveInvalidateStub;
+}
+/** One driver per application; construct from a LiveModule driver factory. */
+declare class CfLiveDriver implements LiveDriver {
+  private readonly options;
+  readonly kind = "durable-object";
+  private sink;
+  private localMode;
+  constructor(options: DurableObjectLiveOptions);
+  bind(sink: LiveInvalidationSink): void;
+  /** @internal — a DO dispatches to its own engine and SQLite log. */
+  _setLocalMode(): void;
+  dispatch(cmd: InvalidationCommand): Promise<CommitStamp | undefined> | CommitStamp | undefined;
+}
+/** Use in LiveModule.forRootAsync: driver: () => durableObjectLive({ namespace: env.ROOMS, ... }). */
+export declare function durableObjectLive(options: DurableObjectLiveOptions): CfLiveDriver;
+/** Ergonomic alias: the log option for `LiveModule.forRoot` on Cloudflare. */
+export declare function durableObjectCursorLog(maxRows?: number): DoCursorLog;
+/**
+ * Invalidate live tags in a room from a Worker (controller / cron / queue
+ * consumer) — the live sibling of `broadcastToRoom`. Returns the room log
+ * scope's commit stamp for `Vela-Commit-Cursor` stamping.
+ */
+export declare function liveInvalidateToRoom(ns: LiveNamespace, gatewayPath: string, room: string, tags: string[]): Promise<CommitStamp | undefined>;
+//#endregion
+//#region src/rate-limit/cloudflare-rate-limit.store.d.ts
+/** The deliberately small surface exposed by a Workers Rate Limiting binding. */
+interface CloudflareRateLimitBinding {
+  limit(input: {
+    key: string;
+  }): Promise<{
+    success: boolean;
+  }>;
+}
+interface CloudflareRateLimitStoreOptions {
+  /** Must match the binding's configured `simple.limit`. */
+  limit: number;
+  /** Must match the binding's configured `simple.period`. */
+  periodSeconds: 10 | 60;
+  /** Bound attacker-influenced tracking keys before calling the platform. */
+  maxKeyBytes?: number;
+}
+/**
+ * Adapt a Cloudflare Workers Rate Limiting binding to Vela's throttler store.
+ *
+ * The platform binding makes the allow/deny decision. It does not expose exact
+ * counters or reset timestamps, so this adapter intentionally omits `remaining`.
+ */
+export declare function cloudflareRateLimitStore(binding: CloudflareRateLimitBinding | (() => CloudflareRateLimitBinding), options: CloudflareRateLimitStoreOptions): ThrottlerStore;
+//#endregion
+//#region src/nonce/durable-object-nonce.store.d.ts
+/** The generated Workers binding type for {@link VelaNonceDurableObject}. */
+type DurableObjectNonceNamespace = DurableObjectNamespace<VelaNonceDurableObject>;
+interface DurableObjectNonceStoreOptions {
+  /**
+   * Stable application/environment boundary (for example `billing-api:prod`).
+   * Claims are globally single-use inside this namespace and isolated from all
+   * other application namespaces. It must be non-empty, canonical, and at most
+   * 128 UTF-8 bytes.
+   */
+  appNamespace: string;
+  /**
+   * Resolve the Workers Durable Object namespace at claim time. The resolver is
+   * intentionally not cached so request-scoped env/binding references stay safe.
+   */
+  binding: () => DurableObjectNonceNamespace | Promise<DurableObjectNonceNamespace>;
+}
+/**
+ * Strict, cross-isolate {@link NonceStore} backed by one SQLite Durable Object
+ * per explicit application namespace.
+ *
+ * Invalid input, an unavailable/malformed binding, RPC failure, or a malformed
+ * RPC result all deny the claim (`false`). Only the literal boolean `true` from
+ * the Durable Object is accepted.
+ */
+export declare function durableObjectNonceStore(options: DurableObjectNonceStoreOptions): NonceStore;
+//#endregion
+export { type BroadcastNamespace, type CfLiveDriver, type CloudflareRateLimitBinding, type CloudflareRateLimitStoreOptions, type CloudflareRoot, type CloudflareWorkerOptions, ConnectedSocket, type CreateCloudflareAppOptions, type DiskConfig, type DoPitrArmOptions, type DoPitrArmResult, type DoPitrBookmarkRead, type DoPitrId, type DoPitrNamespace, type DoPitrStorage, DoPitrUnavailableError, type DurableObjectLiveOptions, type DurableObjectNonceNamespace, type DurableObjectNonceStoreOptions, type FlagshipBinding, type FlagshipFlagDriverOptions, type KvFlagDriverOptions, type LiveNamespace, MessageBody, type MountOpenApiOptions, type OnGatewayConnection, type OnGatewayDisconnect, type OnGatewayInit, type PresignedUrlConfig, type QueueConsumerMetadata, type ScheduledMetadata, type StorageModuleOptions, SubscribeMessage, type VelaDoPitrRpc, WebSocketGateway, WebSocketServer, type WsClient, WsException, type WsGatewayRoute, type WsMessage, type WsResponse, type WsServer, armDoPitr, isDoPitrUnavailable, readDoPitrBookmark };
+//# sourceMappingURL=index.d.ts.map