@velajs/cloudflare 1.10.0 → 1.22.0

package/CHANGELOG.md

@@ -1,10 +1,40 @@
 # Changelog
 
+## 1.22.0
+
+### Minor Changes
+
+- Continue the coordinated framework release on the 1.x line with the current checked provider, endpoint, identity, CRUD, live, and Studio APIs. Breaking API changes are accepted during this development phase; maintained applications use the current contracts.
+- Publish from the pnpm packages workspace with TypeScript 7 and GitHub OIDC. Obsolete standalone examples have been removed; runnable applications live in apps/.
+- Updated workspace dependencies
+  - @velajs/feature-flags@1.22.0
+  - @velajs/vela@1.22.0
+
+## 2.0.1
+
+### Patch Changes
+
+- Publish from the unified packages workspace with corrected repository paths, shared native tooling, TypeScript 7 checks, and npm OIDC releases. Runnable examples now live in apps/.
+- Updated dependencies
+  - @velajs/vela@2.0.1
+  - @velajs/feature-flags@2.0.1
+
+## 2.0.0
+
+Native binding tokens, per-environment application lifetime, environment-created module graphs, isolated live drivers, and Durable Object live inspection. Includes a complete D1/auth/CRUD/live/Studio starter.
+
+Requires the coordinated Vela 2.0 package set. See the workspace migration guide.
+
+## 1.10.1
+
+### Patch Changes
+
+- 6f04d15: Modernize the package build, validation, and release toolchain.
+
 ## 1.7.0 (2026-07-04)
 
 - `cloudflareAdapter()` exported (createCloudflareApp composes vela RuntimeAdapter); `@QueueConsumer`/`@Scheduled` declare open entrypoint kinds; queue/scheduled dispatch runs per-event in a request scope through PipelineRunner (consumer-scoped guards/interceptors/filters; request-scoped deps rebuild per batch); DO WebSocket reads `app.entrypoints`. Requires `@velajs/vela >=1.11.0`.
 
-
 ## 1.6.0 (2026-07-01)
 
 ### Added
@@ -25,11 +55,11 @@
 
   ```ts
   // before
-  import { CloudflareFactory } from '@velajs/cloudflare';
+  import { CloudflareFactory } from "@velajs/cloudflare";
   const app = await CloudflareFactory.create(AppModule);
 
   // after
-  import { createCloudflareApp } from '@velajs/cloudflare';
+  import { createCloudflareApp } from "@velajs/cloudflare";
   const app = await createCloudflareApp(AppModule);
   ```
 

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ksh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,385 +1,260 @@
 # @velajs/cloudflare
 
-[![npm version](https://img.shields.io/npm/v/@velajs/cloudflare)](https://www.npmjs.com/package/@velajs/cloudflare)
-[![CI](https://github.com/velajs/cloudflare/actions/workflows/ci.yml/badge.svg)](https://github.com/velajs/cloudflare/actions/workflows/ci.yml)
-[![License: MIT](https://img.shields.io/npm/l/@velajs/cloudflare)](https://github.com/velajs/cloudflare/blob/main/LICENSE)
+Nest-style modules, dependency injection, controllers, queue consumers, cron triggers,
+and live WebSockets on Cloudflare Workers. HTTP routing uses Hono. Bindings use the
+platform's native types.
 
-Cloudflare Workers integration for the [Vela](https://github.com/velajs/vela) framework. NestJS-style per-service modules for KV, D1, R2, Queues, Durable Objects, Workers AI, Vectorize, and Hyperdrive.
+## Native environment and application lifetime
 
-## Install
-
-```bash
-pnpm add @velajs/cloudflare @velajs/vela hono
-pnpm add -D @cloudflare/workers-types
-```
-
-`@cloudflare/workers-types` is a required peer (types-only — zero runtime cost). It's what gives `KVNamespace`, `D1Database`, `R2Bucket`, `Queue`, `DurableObjectNamespace`, `Ai`, `VectorizeIndex`, and `Hyperdrive` their proper types when you reach into the underlying binding.
-
-## Service shape
-
-Every service is a thin typed wrapper around its Cloudflare binding. Use the accessor (`.namespace`, `.database`, `.bucket`, `.queue`, `.binding`, `.index`) to call the binding's methods directly — full `@cloudflare/workers-types` autocomplete, no shim layer in between.
-
-```ts
-class KVService { readonly namespace: KVNamespace; }
-class D1Service { readonly database: D1Database; }
-class R2Service { readonly bucket: R2Bucket; }
-class QueueService<T> { readonly queue: Queue<T>; }
-class DurableObjectService { readonly namespace: DurableObjectNamespace; }
-class AIService { readonly binding: Ai; }
-class VectorizeService { readonly index: VectorizeIndex; }
-class HyperdriveService { readonly binding: Hyperdrive; }
-```
-
-## Quick Start
+Define one typed token for your generated Workers environment. Inject that token
+wherever bindings or secrets are needed, including async provider factories.
 
 ```ts
-import { Controller, Get, Module, Injectable, Param } from '@velajs/vela';
-import { createCloudflareApp, KVModule, KVService, D1Module, D1Service } from '@velajs/cloudflare';
-
-@Injectable()
-class UserService {
-  constructor(
-    private kv: KVService,
-    private d1: D1Service,
-  ) {}
-
-  async findById(id: string) {
-    const cached = await this.kv.namespace.get(`user:${id}`);
-    if (cached) return JSON.parse(cached as string);
-
-    const user = await this.d1.database.prepare('SELECT * FROM users WHERE id = ?').bind(id).first();
-    if (user) await this.kv.namespace.put(`user:${id}`, JSON.stringify(user));
-    return user;
-  }
+import { Controller, Get, Inject, InjectionToken, Module } from '@velajs/vela';
+import { createCloudflareWorker } from '@velajs/cloudflare';
+
+interface WorkerEnv {
+  CACHE: KVNamespace;
+  DB: D1Database;
+  FILES: R2Bucket;
+  JOBS: Queue<{ taskId: string }>;
+  SERVICE_NAME: string;
+  APP_SECRET: string;
 }
+export const ENV = new InjectionToken<WorkerEnv>('Worker environment');
 
-@Controller('/users')
-class UserController {
-  constructor(private users: UserService) {}
+@Controller('/status')
+class StatusController {
+  constructor(@Inject(ENV) private readonly env: WorkerEnv) {}
 
-  @Get('/:id')
-  async getUser(@Param('id') id: string) {
-    return this.users.findById(id);
+  @Get()
+  async status() {
+    return { message: await this.env.CACHE.get('status') };
   }
 }
 
-@Module({
-  imports: [
-    KVModule.forRoot({ binding: 'CACHE' }),
-    D1Module.forRoot({ binding: 'DB' }),
-  ],
-  providers: [UserService],
-  controllers: [UserController],
-})
+@Module({ controllers: [StatusController] })
 class AppModule {}
 
-export default await createCloudflareApp(AppModule);
+export default createCloudflareWorker(AppModule, { envToken: ENV });
 ```
 
-The `binding` string matches the binding name in your `wrangler.toml`:
+The worker exposes `fetch`, `queue`, and `scheduled`. Its first event builds an
+application with that event's environment. Concurrent events for the same
+environment object share construction. Different environment objects receive
+separate applications, including separate providers, lifecycle state, and live
+drivers. A failed construction is evicted and the next event retries.
 
-```toml
-[[kv_namespaces]]
-binding = "CACHE"
-id = "abc123"
+When module configuration itself needs bindings, pass `{ create: (env) => AppModule }`
+instead of a static class. The callback receives the native environment inferred
+from `envToken` and runs once per successful environment bootstrap. The same form
+works with `VelaWebSocketDurableObject` for authenticated live gateways. See the
+[complete API starter](../../apps/api-starter/README.md) for D1, Better Auth, CRUD,
+the generated Hono client, live updates, and Studio inspection in one application.
 
-[[d1_databases]]
-binding = "DB"
-database_id = "def456"
-```
+The cache uses weak object keys: it does not permanently retain replaced
+environments or secrets. Providers with request scope still rebuild per HTTP
+request or queue/cron dispatch. Do not retain request objects or authentication
+state in singleton providers.
 
-## Modules
-
-Each module follows the same pattern: `XModule.forRoot({ binding: 'NAME' })` returns a dynamic module that provides a service wrapping the Cloudflare binding.
-
-| Module | Service | Cloudflare Binding |
-|--------|---------|-------------------|
-| `KVModule` | `KVService` | KV Namespace |
-| `D1Module` | `D1Service` | D1 Database |
-| `R2Module` | `R2Service` | R2 Bucket |
-| `QueueModule` | `QueueService` | Queue (producer) |
-| `DurableObjectModule` | `DurableObjectService` | Durable Object Namespace |
-| `AIModule` | `AIService` | Workers AI |
-| `VectorizeModule` | `VectorizeService` | Vectorize Index |
-| `HyperdriveModule` | `HyperdriveService` | Hyperdrive |
-
-### KVModule
+For explicit construction inside a platform event:
 
 ```ts
-import { KVModule, KVService } from '@velajs/cloudflare';
-
-@Module({ imports: [KVModule.forRoot({ binding: 'MY_KV' })] })
-class AppModule {}
-
-@Injectable()
-class CacheService {
-  constructor(private kv: KVService) {}
-
-  async get(key: string) { return this.kv.namespace.get(key); }
-  async set(key: string, value: string) { return this.kv.namespace.put(key, value); }
-  async remove(key: string) { return this.kv.namespace.delete(key); }
-  async keys() { return this.kv.namespace.list(); }
-}
+const app = await createCloudflareApp(AppModule, {
+  env,
+  envToken: ENV,
+  globalPrefix: '/api',
+  middleware: (bindings) => [async (context, next) => {
+    context.header('x-service', bindings.SERVICE_NAME);
+    await next();
+  }],
+});
+const bindings = app.get(ENV); // WorkerEnv, inferred from ENV
+return app.fetch(request, env, executionContext);
 ```
 
-### D1Module
-
-```ts
-import { D1Module, D1Service } from '@velajs/cloudflare';
-
-@Module({ imports: [D1Module.forRoot({ binding: 'DB' })] })
-class AppModule {}
-
-@Injectable()
-class PostService {
-  constructor(private d1: D1Service) {}
+`env` is registered before provider factories and lifecycle hooks. Referencing a
+binding inside `middleware(env)` is typed from that same token; request callbacks
+capture the native environment without retyping Hono's context. Referencing a
+binding is safe during construction; platform I/O must still happen inside a
+Workers event or Durable Object context. An explicitly built application rejects
+requests or events carrying another environment object, including calls through
+the underlying Hono app. Internal `ctx.run` reentry retains the application's
+environment.
 
-  async findAll() {
-    return this.d1.database.prepare('SELECT * FROM posts').all();
-  }
-
-  async create(title: string) {
-    return this.d1.database.prepare('INSERT INTO posts (title) VALUES (?)').bind(title).run();
-  }
-}
-```
-
-### R2Module
-
-```ts
-import { R2Module, R2Service } from '@velajs/cloudflare';
-
-@Module({ imports: [R2Module.forRoot({ binding: 'ASSETS' })] })
-class AppModule {}
-
-@Injectable()
-class StorageService {
-  constructor(private r2: R2Service) {}
-
-  async upload(key: string, data: string) { return this.r2.bucket.put(key, data); }
-  async download(key: string) { return this.r2.bucket.get(key); }
-  async remove(key: string) { return this.r2.bucket.delete(key); }
-}
-```
-
-### QueueModule
-
-```ts
-import { QueueModule, QueueService } from '@velajs/cloudflare';
-
-@Module({ imports: [QueueModule.forRoot({ binding: 'EMAIL_QUEUE' })] })
-class AppModule {}
-
-@Injectable()
-class NotificationService {
-  constructor(private queue: QueueService) {}
-
-  async sendEmail(to: string, subject: string) {
-    await this.queue.queue.send({ to, subject });
-  }
-}
-```
-
-### DurableObjectModule
-
-```ts
-import { DurableObjectModule, DurableObjectService } from '@velajs/cloudflare';
-
-@Module({ imports: [DurableObjectModule.forRoot({ binding: 'COUNTER' })] })
-class AppModule {}
-
-@Injectable()
-class CounterService {
-  constructor(private doNs: DurableObjectService) {}
+`cloudflareAdapter({ env, envToken })` provides the same bootstrap and request
+contract when composing `VelaFactory.create` directly.
 
-  async increment(name: string) {
-    const id = this.doNs.namespace.idFromName(name);
-    const stub = this.doNs.namespace.get(id);
-    return (stub as any).fetch('/increment');
-  }
-}
-```
+## Typed provider factories
 
-### AIModule
+Bindings retain their full native API and generic parameters. There are no
+binding-name wrappers to initialize or cast.
 
 ```ts
-import { AIModule, AIService } from '@velajs/cloudflare';
+import { defineProvider, InjectionToken, Module } from '@velajs/vela';
 
-@Module({ imports: [AIModule.forRoot({ binding: 'AI' })] })
-class AppModule {}
+const TASK_QUEUE = new InjectionToken<Queue<{ taskId: string }>>('task queue');
 
-@Injectable()
-class ChatService {
-  constructor(private ai: AIService) {}
-
-  async chat(prompt: string) {
-    return this.ai.binding.run('@cf/meta/llama-3.1-8b-instruct', {
-      messages: [{ role: 'user', content: prompt }],
-    });
-  }
-}
+@Module({
+  providers: [defineProvider(TASK_QUEUE, {
+    inject: [ENV],
+    useFactory: (env) => env.JOBS,
+  })],
+  exports: [TASK_QUEUE],
+})
+class JobsModule {}
 ```
 
-### VectorizeModule
-
-```ts
-import { VectorizeModule, VectorizeService } from '@velajs/cloudflare';
-
-@Module({ imports: [VectorizeModule.forRoot({ binding: 'EMBEDDINGS' })] })
-class AppModule {}
+Every `useFactory` strategy declares its dependencies with `inject`, including
+`inject: []` for factories without dependencies. This also applies to
+`lazyProvider` and `forRootAsync` factory options.
 
-@Injectable()
-class SearchService {
-  constructor(private vectorize: VectorizeService) {}
+Use native `env.DB`, `env.CACHE`, `env.FILES`, `env.JOBS`, `env.AI`,
+`env.VECTORIZE`, or `env.HYPERDRIVE` directly. `@Env()` remains available for HTTP
+handler parameters; typed token injection also works outside HTTP.
 
-  async search(vector: number[]) {
-    return this.vectorize.index.query(vector, { topK: 10 });
-  }
-
-  async addVectors(vectors: unknown[]) {
-    return this.vectorize.index.upsert(vectors);
-  }
-}
-```
-
-### HyperdriveModule
+## Queues and cron
 
 ```ts
-import { HyperdriveModule, HyperdriveService } from '@velajs/cloudflare';
-
-@Module({ imports: [HyperdriveModule.forRoot({ binding: 'POSTGRES' })] })
-class AppModule {}
+import { Inject, Injectable } from '@velajs/vela';
+import { QueueConsumer, Scheduled } from '@velajs/cloudflare';
 
 @Injectable()
-class DbService {
-  constructor(private hd: HyperdriveService) {}
+class Jobs {
+  constructor(@Inject(ENV) private readonly env: WorkerEnv) {}
 
-  getConnectionString() {
-    return this.hd.binding.connectionString;
+  @Scheduled('0 * * * *')
+  async refresh() {
+    await this.env.CACHE.put('last-refresh', new Date().toISOString());
   }
 
-  getConfig() {
-    return { host: this.hd.binding.host, port: this.hd.binding.port, database: this.hd.binding.database };
+  @QueueConsumer('jobs')
+  async consume(batch: MessageBatch<unknown>) {
+    for (const message of batch.messages) {
+      // Validate message.body before interpreting its application shape.
+    }
   }
 }
 ```
 
-## Decorators
+Core `@Cron()` also runs on Workers scheduled triggers. Consumers use fresh
+request scopes and their declared guards, interceptors, and filters. Unclaimed
+errors propagate to the platform for retry. Cold queue and cron events have the
+same native bindings and live invalidation capabilities as HTTP.
 
-### @Env()
+## WebSockets, live queries, and Durable Objects
 
-Parameter decorator for direct access to Cloudflare bindings in controllers. Useful as an escape hatch when you don't need a full module.
+Use the native Durable Object entrypoint only in your Worker entry file:
 
 ```ts
-import { Env } from '@velajs/cloudflare';
-
-@Controller('/debug')
-class DebugController {
-  @Get('/env')
-  handle(@Env() env: Record<string, unknown>) {
-    return { bindings: Object.keys(env) };
-  }
-
-  @Get('/kv')
-  handleKV(@Env('MY_KV') kv: KVNamespace) {
-    return kv.get('some-key');
-  }
-}
-```
-
-### @Scheduled()
+import { InjectionToken, Module } from '@velajs/vela';
+import { LiveModule } from '@velajs/vela/live';
+import {
+  CloudflareWebSocketModule,
+  createCloudflareWorker,
+  durableObjectCursorLog,
+  durableObjectLive,
+} from '@velajs/cloudflare';
+import { VelaWebSocketDurableObject } from '@velajs/cloudflare/durable-objects';
+
+interface RoomEnv { ROOMS: DurableObjectNamespace<Room> }
+const ROOM_ENV = new InjectionToken<RoomEnv>('room environment');
 
-Method decorator for cron trigger handlers.
-
-```ts
-import { Scheduled } from '@velajs/cloudflare';
-
-@Injectable()
-class CleanupService {
-  @Scheduled('0 * * * *')  // every hour
-  async hourlyCleanup() {
-    console.log('Running hourly cleanup');
-  }
-
-  @Scheduled('0 0 * * *')  // every day at midnight
-  async dailyReport() {
-    console.log('Generating daily report');
-  }
-}
-```
-
-### @QueueConsumer()
-
-Method decorator for queue consumer handlers.
-
-```ts
-import { QueueConsumer } from '@velajs/cloudflare';
+@Module({
+  imports: [
+    CloudflareWebSocketModule.forRoot(),
+    LiveModule.forRootAsync({
+      inject: [ROOM_ENV],
+      useFactory: (env) => ({
+        driver: () => durableObjectLive({
+          namespace: env.ROOMS,
+          gatewayPath: '/rooms/:room/ws',
+        }),
+        log: () => durableObjectCursorLog(),
+      }),
+    }),
+  ],
+  // Add your @WebSocketGateway and @LiveResolver classes here.
+  providers: [],
+})
+class RoomModule {}
 
-@Injectable()
-class EmailWorker {
-  @QueueConsumer('email-queue')
-  async process(batch: MessageBatch) {
-    for (const msg of batch.messages) {
-      console.log('Sending email:', msg.body);
-      msg.ack();
-    }
-  }
-}
+export class Room extends VelaWebSocketDurableObject(RoomModule, { envToken: ROOM_ENV }) {}
+export default createCloudflareWorker(RoomModule, { envToken: ROOM_ENV });
 ```
 
-## createCloudflareApp
-
-Use `createCloudflareApp()` instead of `VelaFactory.create()` for Cloudflare apps. It sets up a one-time middleware that captures `c.env` on the first request and initializes all binding modules.
-
-```ts
-import { createCloudflareApp } from '@velajs/cloudflare';
-
-const app = await createCloudflareApp(AppModule);
-export default app;
-```
+Declare gateways with `@WebSocketGateway({ path, roomParam, binding, ... })` and
+configure origins and upgrade authentication for your application. Upgrade
+routing consumes the core trusted request identity, checks conflicts with the
+upgrade credential, and forwards issuer, subject, tenant, and expiry to the DO.
+Client-supplied internal identity headers are stripped before authorization.
 
-## Full Worker Export
+Declare live query argument and result schemas once with `defineLiveQuery({ args,
+result })` from `@velajs/vela/live`. Both entries accept a parser object such as a
+Zod schema. Use `@LiveQuery('todos.list', definition, { tags: ['todos'] })` on the
+resolver and share the definition with its client. Restored hibernation arguments
+and final query results use the same validation boundary.
 
-To use scheduled triggers and queue consumers, export the handlers explicitly:
+Each application constructs its own driver and cursor log. Workers send
+invalidations through the typed DO namespace; the DO uses its own live engine
+and SQLite cursor log. Configure the class in Wrangler `new_sqlite_classes` to
+retain cursor/epoch state across hibernation. Hibernated subscriptions are
+restored on wake; the shared live protocol handles resume or snapshot fallback.
 
-```ts
-const app = await createCloudflareApp(AppModule);
+The DO class preserves its RPC types, so `DurableObjectNamespace<Room>` exposes
+`invalidate`, `broadcast`, and PITR methods without assertions. `broadcastToRoom`,
+`liveInvalidateToRoom`, and the PITR helpers remain available from the root
+package. `VelaNonceDurableObject` is exported from `/durable-objects`; its
+`durableObjectNonceStore` factory remains on the root entrypoint.
 
-export default {
-  fetch: app.fetch,
-  scheduled: app.scheduled.bind(app),
-  queue: app.queue.bind(app),
-};
-```
+The root package contains no runtime `cloudflare:workers` import and can be
+loaded by Node tooling. Native classes belong to `/durable-objects`.
 
-## Raw Binding Access
+## R2 storage and caches
 
-Each service exposes the underlying Cloudflare binding via a getter:
+Configure named disks from an async factory using actual bucket values:
 
 ```ts
-const rawKV = kvService.namespace;     // KVNamespace
-const rawD1 = d1Service.database;      // D1Database
-const rawR2 = r2Service.bucket;        // R2Bucket
-const rawQueue = queueService.queue;   // Queue
-const rawDO = doService.namespace;     // DurableObjectNamespace
-const rawAI = aiService.binding;       // Ai
-const rawVec = vecService.index;       // VectorizeIndex
-const rawHD = hdService.binding;       // Hyperdrive
+StorageModule.forRootAsync({
+  inject: [ENV],
+  useFactory: (env) => ({
+    defaultDisk: 'uploads',
+    secret: env.APP_SECRET,
+    disks: [{ disk: 'uploads', bucket: env.FILES, root: 'uploads/{year}' }],
+    presignedUrl: { defaultExpiry: 3600, maxExpiry: 86400 },
+  }),
+});
 ```
 
-## How It Works
-
-Cloudflare Workers only provide bindings (`env.DB`, `env.MY_KV`, etc.) at request time via the `env` parameter. They are stable across requests within an isolate.
-
-`createCloudflareApp` handles this by:
-
-1. Each `XModule.forRoot()` creates a `BindingRef` (mutable holder) and registers it in the DI container
-2. Services are constructed at boot time with the `BindingRef` — no binding access yet
-3. On the first HTTP request, a one-time middleware reads `c.env` and initializes all `BindingRef` instances
-4. From that point on, services access bindings lazily through the ref
-
-This means binding-dependent services work as plain singletons with no per-request overhead.
-
-## License
-
-MIT
+`StorageService` supports upload, download, delete, existence checks, and expiring
+signed download URLs. The proxy validates signatures, HTTP method, expiry, and
+the configured root; returned files download as attachments.
+
+Construct `KVCacheStore` and `KvFlagDriver` with a native namespace:
+`new KVCacheStore(env.CACHE)` and `new KvFlagDriver(env.CACHE)`. Cache reads and
+object-valued flag reads return `unknown`; validate them with an application
+parser. Core `CacheService.getParsed(key, parser)` infers the result from that
+parser. Memory and tiered cache reads use the same unknown-value contract.
+
+## Migration
+
+This release intentionally changes the APIs:
+
+- Replace `BindingRef`, `EnvRef`, `EnvModule`, `EnvService`, all per-binding
+  modules, and all per-binding services with a typed `InjectionToken<Env>`.
+- Pass `{ env, envToken }` to `createCloudflareApp`, or export
+  `createCloudflareWorker(AppModule, { envToken })`.
+- Use `app.get(TOKEN)` without a caller-selected generic.
+- Replace storage disk `binding: 'FILES'` with `bucket: env.FILES`, and pass the
+  storage signing secret explicitly through module options.
+- Build live `driver` and `log` through per-application factories. Pass a typed
+  `namespace` to `durableObjectLive` instead of a binding name.
+- Import native Durable Object classes from `@velajs/cloudflare/durable-objects`
+  and pass `{ envToken }` to `VelaWebSocketDurableObject`.
+- Cache `get<T>` was removed. Use raw `unknown` reads and a parser.
+- Email and workflow integrations are outside this API package. Their deferred
+  standalone packages are not required to import, build, test, or install it.
+
+Use `pnpm --dir cloudflare test`, `pnpm --dir cloudflare test:workers`, and
+`pnpm --dir cloudflare typecheck` from the shared API workspace. The Workers suite
+uses real KV, D1, R2, WebSockets, SQLite Durable Objects, and cold event dispatch.