@moku-labs/worker 0.6.0 → 0.7.1

package/dist/index.d.cts

@@ -1,10 +1,10 @@
-import { a as WorkerConfig, c as WorkerPluginCtx, i as ResourceManifest, n as cliPlugin, o as WorkerEnv, r as ExternalManifest, s as WorkerEvents, t as deployPlugin } from "./index-VZ99IAMv.cjs";
+import { a as WorkerConfig, c as WorkerPluginCtx, i as ResourceManifest, n as cliPlugin, o as WorkerEnv, r as ExternalManifest, s as WorkerEvents, t as deployPlugin } from "./index-Dse6wZJH.cjs";
 import { envPlugin, logPlugin } from "@moku-labs/common";
 import { PluginCtx, PluginCtx as PluginCtx$1, PluginInstance } from "@moku-labs/core";
 
 //#region \0rolldown/runtime.js
 declare namespace types_d_exports {
-  export { BindingsApi, Config$4 as Config, Context };
+  export { BindingsApi, Config$5 as Config, Context };
 }
 /**
  * bindings config. Flat (spec/05 §3,§6) — a complete default so omission
@@ -15,7 +15,7 @@ declare namespace types_d_exports {
  * { required: ["MY_KV", "DB"] }
  * ```
  */
-type Config$4 = {
+type Config$5 = {
   required: string[];
 };
 /**
@@ -50,7 +50,7 @@ type BindingsApi = {
  * api-factory context. State slot is Record<string, never> — bindings holds NO
  * state (F4). Type-argument order is PluginCtx<Config, State, Events>.
  */
-type Context = PluginCtx$1<Config$4, Record<string, never>, WorkerEvents>;
+type Context = PluginCtx$1<Config$5, Record<string, never>, WorkerEvents>;
 //#endregion
 //#region src/plugins/bindings/index.d.ts
 /**
@@ -62,7 +62,7 @@ type Context = PluginCtx$1<Config$4, Record<string, never>, WorkerEvents>;
  *
  * @see README.md
  */
-declare const bindingsPlugin: import("@moku-labs/core").PluginInstance<"bindings", Config$4, Record<string, never>, BindingsApi, {}> & Record<never, never>;
+declare const bindingsPlugin: import("@moku-labs/core").PluginInstance<"bindings", Config$5, Record<string, never>, BindingsApi, {}> & Record<never, never>;
 declare namespace types_d_exports$4 {
   export { Api$3 as Api, CompiledEndpoint, Endpoint, EndpointHandler, MatchResult, Method, PathParams, PathSegment, RequestContext, RequireFn, ServerConfig, ServerCtx, ServerEvents, ServerState };
 }
@@ -335,35 +335,43 @@ type EndpointBuilder<Path extends string> = {
  */
 declare const endpoint: <Path extends string>(path: Path) => EndpointBuilder<Path>;
 declare namespace types_d_exports$1 {
-  export { Api$2 as Api, Config$3 as Config, D1Ctx, DeployManifest$2 as DeployManifest };
+  export { Api$2 as Api, Config$4 as Config, D1Ctx, D1DatabaseApi, D1Instance };
 }
 /**
- * d1 plugin configuration.
+ * A single D1 database instance: its base Cloudflare name + the env binding it resolves off, plus
+ * optional deploy-time migrations metadata.
  *
  * @example
  * ```ts
- * { binding: "DB", migrations: "./migrations" }
+ * { name: "tracker-db", binding: "DB", migrations: "db/migrations" }
  * ```
  */
-type Config$3 = {
-  /** D1 binding name resolved off the per-request env. */binding: string; /** Migrations directory; deploy-time metadata only. */
-  migrations: string;
+type D1Instance = {
+  /** Base Cloudflare D1 database name (stage-suffixed at deploy). */name: string; /** Env binding name the database resolves off the per-request `env` (e.g. `env.DB`). */
+  binding: string; /** Migrations directory; deploy-time metadata only. Omit when there are none. */
+  migrations?: string; /** Marks this instance the default when more than one is configured. */
+  default?: boolean;
 };
 /**
- * Deploy metadata entry for a D1 database, read by the deploy plugin.
+ * d1 plugin config — a keyed map of D1 database instances. The key is the stable logical id used by
+ * `app.d1.use("key")`; a single entry (or one flagged `default: true`) is the implicit default.
  *
  * @example
  * ```ts
- * { kind: "d1", binding: "DB", migrations: "./migrations" }
+ * { main: { name: "tracker-db", binding: "DB", migrations: "db/migrations" } }
  * ```
  */
-type DeployManifest$2 = {
-  /** Discriminant identifying this as a D1 resource. */kind: "d1"; /** D1 binding name. */
-  binding: string; /** Migrations directory (or "" if none). */
-  migrations: string;
-};
-/** Public api surface of the d1 plugin (thin typed wrappers over prepare().bind()). */
-type Api$2 = {
+type Config$4 = Record<string, D1Instance>;
+/**
+ * The SQL surface for one D1 database (the thin typed wrappers bound to a single instance).
+ *
+ * @example
+ * ```ts
+ * const { results } = await app.d1.query<Product>(env, "SELECT * FROM products");
+ * await app.d1.use("analytics").run(env, "INSERT INTO events (name) VALUES (?)", "click");
+ * ```
+ */
+type D1DatabaseApi = {
   /**
    * Run a statement and return all rows.
    *
@@ -406,18 +414,43 @@ type Api$2 = {
    * @returns The request-resolved database handle.
    */
   prepare: (env: WorkerEnv) => D1Database;
+};
+/**
+ * The app.d1 surface — the default database's methods, a `use(key)` selector for the others, plus
+ * deploy metadata.
+ *
+ * @example
+ * ```ts
+ * const { results } = await app.d1.query<Product>(env, "SELECT * FROM products"); // default db
+ * await app.d1.use("analytics").run(env, "INSERT INTO events (name) VALUES (?)", "click");
+ * ```
+ */
+type Api$2 = D1DatabaseApi & {
+  /**
+   * Select a specific D1 database instance by its config key.
+   *
+   * @param key - The instance key (as configured under `pluginConfigs.d1`).
+   * @returns The SQL surface bound to that database.
+   */
+  use(key: string): D1DatabaseApi;
   /**
-   * Return this plugin's deploy metadata (read by the deploy plugin).
+   * Return this plugin's deploy metadata (one entry per configured database), read by the deploy
+   * plugin. Build-time only — takes no `env`.
    *
-   * @returns Deploy manifest entry `{ kind: "d1", binding, migrations }`.
+   * @returns One d1 deploy descriptor per configured instance.
    */
-  deployManifest: () => DeployManifest$2;
+  deployManifest(): Array<{
+    kind: "d1";
+    name: string;
+    binding: string;
+    migrations?: string;
+  }>;
 };
 /**
  * Internal context type — own config first, no state, no d1-local events.
  * Intersected with a narrow `require` typed to the one dependency d1 resolves.
  */
-type D1Ctx = PluginCtx$1<Config$3, Record<string, never>, WorkerEvents> & {
+type D1Ctx = PluginCtx$1<Config$4, Record<string, never>, WorkerEvents> & {
   /**
    * Resolve a dependency plugin's api. d1 only ever resolves `bindingsPlugin`.
    *
@@ -437,71 +470,26 @@ type D1Ctx = PluginCtx$1<Config$3, Record<string, never>, WorkerEvents> & {
  *
  * @see README.md
  */
-declare const d1Plugin: import("@moku-labs/core").PluginInstance<"d1", Config$3, Record<string, never>, {
+declare const d1Plugin: import("@moku-labs/core").PluginInstance<"d1", Config$4, Record<string, never>, {
+  use: (key: string) => {
+    query: <T = unknown>(env: WorkerEnv, sql: string, ...params: unknown[]) => Promise<D1Result<T>>;
+    first: <T = unknown>(env: WorkerEnv, sql: string, ...params: unknown[]) => Promise<T | null>;
+    run: (env: WorkerEnv, sql: string, ...params: unknown[]) => Promise<D1Result<Record<string, unknown>>>;
+    batch: (env: WorkerEnv, stmts: D1PreparedStatement[]) => Promise<D1Result<unknown>[]>;
+    prepare: (env: WorkerEnv) => D1Database;
+  };
+  deployManifest: () => {
+    kind: "d1";
+    name: string;
+    binding: string;
+    migrations?: string;
+  }[];
   query: <T = unknown>(env: WorkerEnv, sql: string, ...params: unknown[]) => Promise<D1Result<T>>;
   first: <T = unknown>(env: WorkerEnv, sql: string, ...params: unknown[]) => Promise<T | null>;
   run: (env: WorkerEnv, sql: string, ...params: unknown[]) => Promise<D1Result<Record<string, unknown>>>;
   batch: (env: WorkerEnv, stmts: D1PreparedStatement[]) => Promise<D1Result<unknown>[]>;
   prepare: (env: WorkerEnv) => D1Database;
-  deployManifest: () => DeployManifest$2;
 }, {}> & Record<never, never>;
-declare namespace types_d_exports$2 {
-  export { Api$1 as Api, Config$2 as Config, Ctx$1 as Ctx, DeployManifest$1 as DeployManifest };
-}
-/**
- * durableObjects plugin configuration. Flat; complete default so omission never yields undefined.
- *
- * @example
- * ```ts
- * { bindings: { counter: "COUNTER" } }
- * ```
- */
-type Config$2 = {
-  /** Logical name -> Cloudflare DO binding name. A missing logical name falls back to itself. Default {}. */bindings: Record<string, string>;
-};
-/**
- * Deploy metadata entry for Durable Objects, read by the deploy plugin.
- *
- * @example
- * ```ts
- * { kind: "do", bindings: { counter: "COUNTER" } }
- * ```
- */
-type DeployManifest$1 = {
-  /** Discriminant identifying this as a Durable Objects resource. */kind: "do"; /** Logical name -> Cloudflare DO binding name. */
-  bindings: Record<string, string>;
-};
-/** Public api surface of the durableObjects plugin. */
-type Api$1 = {
-  /**
-   * Resolve a DurableObjectStub off the request env (logical name -> configured binding).
-   *
-   * @param env - Per-request Cloudflare bindings.
-   * @param logicalName - Logical DO name used in code.
-   * @param idName - Stable id name passed to idFromName.
-   * @returns The addressed Durable Object stub.
-   */
-  get(env: WorkerEnv, logicalName: string, idName: string): DurableObjectStub;
-  /**
-   * Return this plugin's deploy metadata (read by the deploy plugin).
-   *
-   * @returns Deploy manifest entry `{ kind: "do", bindings }`.
-   */
-  deployManifest(): DeployManifest$1;
-};
-/**
- * Internal context type — own config first, no state, no DO events.
- * Intersected with a narrow `require` typed to the one dependency durableObjects resolves.
- */
-type Ctx$1 = PluginCtx$1<Config$2, Record<string, never>, WorkerEvents> & {
-  /**
-   * Resolve a dependency plugin's api. durableObjects only ever resolves `bindingsPlugin`.
-   *
-   * @param plugin - The bindingsPlugin instance.
-   * @returns The resolved bindings api.
-   */
-  require(plugin: typeof bindingsPlugin): BindingsApi;
-};
 //#endregion
 //#region src/plugins/durable-objects/helpers.d.ts
 /**
@@ -559,31 +547,101 @@ type DurableObjectBaseConstructor = new (ctx: DurableObjectState, env: WorkerEnv
 declare const defineDurableObject: (name: string) => DurableObjectBaseConstructor & {
   readonly doName: string;
 };
+declare namespace types_d_exports$2 {
+  export { Api$1 as Api, Config$3 as Config, Ctx$1 as Ctx, DoInstance };
+}
+/**
+ * A single Durable Object instance: the env binding it resolves off plus the EXPORTED class it
+ * addresses. DOs are not provisioned (they ship with the Worker script), so there is no base
+ * Cloudflare `name` — `binding` is the env var and `className` is the class the consumer exports from
+ * `worker.ts`, decoupled from the logical key.
+ *
+ * @example
+ * ```ts
+ * { binding: "BOARD", className: "BoardChannel" }
+ * ```
+ */
+type DoInstance = {
+  /** Env binding name the namespace resolves off the per-request `env` (e.g. `env.BOARD`). */binding: string; /** The EXPORTED Durable Object class name (e.g. `"BoardChannel"`), used in the wrangler config. */
+  className: string; /** Marks this instance the default when more than one is configured. */
+  default?: boolean;
+};
+/**
+ * durableObjects plugin config — a keyed map of Durable Object instances. The key is the stable
+ * logical name passed to `app.durableObjects.get(env, key, id)`; a single entry (or one flagged
+ * `default: true`) is the implicit default.
+ *
+ * @example
+ * ```ts
+ * { board: { binding: "BOARD", className: "BoardChannel" } }
+ * ```
+ */
+type Config$3 = Record<string, DoInstance>;
+/** Public api surface of the durableObjects plugin. */
+type Api$1 = {
+  /**
+   * Resolve a DurableObjectStub off the request env (logical key -> configured binding).
+   *
+   * @param env - Per-request Cloudflare bindings.
+   * @param logicalName - Logical DO key (selects the configured instance).
+   * @param idName - Stable id name passed to idFromName.
+   * @returns The addressed Durable Object stub.
+   */
+  get(env: WorkerEnv, logicalName: string, idName: string): DurableObjectStub;
+  /**
+   * Return this plugin's deploy metadata — one entry per configured instance (read by the deploy
+   * plugin).
+   *
+   * @returns One do deploy descriptor per configured instance.
+   */
+  deployManifest(): Array<{
+    kind: "do";
+    binding: string;
+    className: string;
+  }>;
+};
+/**
+ * Internal context type — own config first, no state, no DO events.
+ * Intersected with a narrow `require` typed to the one dependency durableObjects resolves.
+ */
+type Ctx$1 = PluginCtx$1<Config$3, Record<string, never>, WorkerEvents> & {
+  /**
+   * Resolve a dependency plugin's api. durableObjects only ever resolves `bindingsPlugin`.
+   *
+   * @param plugin - The bindingsPlugin instance.
+   * @returns The resolved bindings api.
+   */
+  require(plugin: typeof bindingsPlugin): BindingsApi;
+};
 //#endregion
 //#region src/plugins/durable-objects/index.d.ts
 /**
  * Cloudflare Durable Objects plugin — Standard tier.
  *
  * Exposes `get(env, logicalName, idName)` (synchronous stub accessor, threaded env) and
- * `deployManifest()` (build-time metadata). Depends on `bindingsPlugin` for namespace
- * resolution. The `defineDurableObject` helper is mounted under `helpers` and re-exported
- * at the top level for consumer use.
+ * `deployManifest()` (build-time metadata, one entry per configured instance). Depends on
+ * `bindingsPlugin` for namespace resolution. The `defineDurableObject` helper is mounted under
+ * `helpers` and re-exported at the top level for consumer use.
  *
  * @example
  * ```typescript
  * // Consumer endpoint handler:
- * const stub = app.durableObjects.get(env, "counter", params.room!);
+ * const stub = app.durableObjects.get(env, "board", params.room!);
  * const res = await stub.fetch("https://do/increment");
- * // Consumer DO class:
- * export class Counter extends defineDurableObject("Counter") {
+ * // Consumer DO class (the EXPORTED className referenced by the "board" instance):
+ * export class BoardChannel extends defineDurableObject("BoardChannel") {
  *   async fetch(): Promise<Response> { return new Response("ok"); }
  * }
  * ```
  * @see README.md
  */
-declare const durableObjectsPlugin: import("@moku-labs/core").PluginInstance<"durableObjects", Config$2, Record<string, never>, {
+declare const durableObjectsPlugin: import("@moku-labs/core").PluginInstance<"durableObjects", Config$3, Record<string, never>, {
   get: (env: WorkerEnv, logicalName: string, idName: string) => DurableObjectStub;
-  deployManifest: () => DeployManifest$1;
+  deployManifest: () => Array<{
+    kind: "do";
+    binding: string;
+    className: string;
+  }>;
 }, {}> & {
   defineDurableObject: (name: string) => DurableObjectBaseConstructor & {
     readonly doName: string;
@@ -592,15 +650,38 @@ declare const durableObjectsPlugin: import("@moku-labs/core").PluginInstance<"du
 //#endregion
 //#region src/plugins/kv/api.d.ts
 /**
- * The app.kv surface — env-first key/value access plus deploy metadata.
+ * A single KV namespace instance: its base Cloudflare name + the env binding it resolves off.
+ *
+ * @example
+ * ```typescript
+ * { name: "tracker-cache", binding: "CACHE" }
+ * ```
+ */
+type KvInstance = {
+  /** Base Cloudflare KV namespace name (stage-suffixed at deploy). */name: string; /** Env binding name the namespace resolves off the per-request `env` (e.g. `env.CACHE`). */
+  binding: string; /** Marks this instance the default when more than one is configured. */
+  default?: boolean;
+};
+/**
+ * kv plugin config — a keyed map of KV namespace instances. The key is the stable logical id used by
+ * `app.kv.use("key")`; a single entry (or one flagged `default: true`) is the implicit default.
+ *
+ * @example
+ * ```typescript
+ * { cache: { name: "tracker-cache", binding: "CACHE" } }
+ * ```
+ */
+type Config$2 = Record<string, KvInstance>;
+/**
+ * The env-first key/value surface for one KV namespace (the methods bound to a single instance).
  *
  * @example
  * ```typescript
  * const value = await app.kv.get(env, "feature-flags");
- * await app.kv.put(env, "session:1", "data", { expirationTtl: 3600 });
+ * await app.kv.use("sessions").put(env, "session:1", "data", { expirationTtl: 3600 });
  * ```
  */
-type KvApi = {
+type KvNamespaceApi = {
   /**
    * Reads a value by key from the KV namespace. Returns null when absent.
    *
@@ -635,16 +716,36 @@ type KvApi = {
    * @returns The list result.
    */
   list(env: WorkerEnv, opts?: KVNamespaceListOptions): Promise<KVNamespaceListResult<unknown, string>>;
+};
+/**
+ * The app.kv surface — the default namespace's methods, a `use(key)` selector for the others, plus
+ * deploy metadata.
+ *
+ * @example
+ * ```typescript
+ * const value = await app.kv.get(env, "feature-flags");        // default namespace
+ * await app.kv.use("sessions").put(env, "s:1", "data");        // a named namespace
+ * ```
+ */
+type KvApi = KvNamespaceApi & {
   /**
-   * Returns this plugin's own deploy metadata, read by the deploy plugin.
-   * Build-time only — takes no env.
+   * Select a specific KV namespace instance by its config key.
    *
-   * @returns The kv deploy descriptor.
+   * @param key - The instance key (as configured under `pluginConfigs.kv`).
+   * @returns The key/value surface bound to that namespace.
    */
-  deployManifest(): {
+  use(key: string): KvNamespaceApi;
+  /**
+   * Returns this plugin's own deploy metadata (one entry per configured namespace), read by the
+   * deploy plugin. Build-time only — takes no env.
+   *
+   * @returns One kv deploy descriptor per configured instance.
+   */
+  deployManifest(): Array<{
     kind: "kv";
+    name: string;
     binding: string;
-  };
+  }>;
 };
 //#endregion
 //#region src/plugins/kv/index.d.ts
@@ -657,31 +758,35 @@ type KvApi = {
  *
  * @see README.md
  */
-declare const kvPlugin: import("@moku-labs/core").PluginInstance<"kv", {
-  binding: string;
-}, Record<string, never>, KvApi, {}> & Record<never, never>;
+declare const kvPlugin: import("@moku-labs/core").PluginInstance<"kv", Config$2, Record<string, never>, KvApi, {}> & Record<never, never>;
 declare namespace types_d_exports$3 {
-  export { Api, Config$1 as Config, Ctx, DeployManifest, QueueEvents };
+  export { Api, Config$1 as Config, Ctx, QueueEvents, QueueInstance, QueueProducerApi };
 }
 /**
- * queues plugin configuration. Flat; complete defaults so omission never yields undefined.
+ * A single Cloudflare Queue instance: its base CF queue name, the producer env binding it
+ * resolves off, and an optional per-instance consumer handler.
+ *
+ * @example
+ * ```ts
+ * { name: "tracker-activity", binding: "ACTIVITY", onMessage: async (m, env) => {} }
+ * ```
  */
-type Config$1 = {
-  /** Queue names this Worker produces to; surfaced by deployManifest(). Default []. */producers: string[]; /** Declarative consumer handler — awaited once per message in consume(). Default no-op. */
-  onMessage: (message: Message, env: WorkerEnv) => Promise<void>;
+type QueueInstance = {
+  /** Base Cloudflare queue name (stage-suffixed at deploy, e.g. `tracker-activity-dev`). */name: string; /** Producer env binding the Queue resolves off the per-request `env` (e.g. `env.ACTIVITY`). */
+  binding: string; /** Per-instance consumer handler — awaited once per message in `consume()`. Optional → no-op. */
+  onMessage?: (message: Message, env: WorkerEnv) => Promise<void>; /** Marks this instance the default when more than one is configured. */
+  default?: boolean;
 };
 /**
- * Deploy metadata entry for a queue, read by the deploy plugin.
+ * queues plugin config — a keyed map of Queue instances. The key is the stable logical id used by
+ * `app.queues.use("key")`; a single entry (or one flagged `default: true`) is the implicit default.
  *
  * @example
  * ```ts
- * { kind: "queue", producers: ["orders"] }
+ * { activity: { name: "tracker-activity", binding: "ACTIVITY", onMessage: async () => {} } }
  * ```
  */
-type DeployManifest = {
-  /** Discriminant identifying this as a queue resource. */kind: "queue"; /** Queue names produced to. */
-  producers: string[];
-};
+type Config$1 = Record<string, QueueInstance>;
 /** Per-plugin event map for queues. */
 type QueueEvents = {
   "queue:message": {
@@ -689,41 +794,74 @@ type QueueEvents = {
     messageId: string;
   };
 };
-/** Public api surface of the queues plugin (producer + consumer). */
-type Api = {
+/**
+ * The producer surface for one Queue instance (the send methods bound to a single instance).
+ *
+ * @example
+ * ```ts
+ * await app.queues.use("activity").send(env, { userId: "u1" });
+ * ```
+ */
+type QueueProducerApi = {
   /**
-   * Enqueue a single message onto the named queue.
+   * Enqueue a single message onto this instance's queue.
    *
-   * @param env - Per-request Cloudflare bindings.
-   * @param queue - Target queue binding name.
-   * @param body - Message body.
-   * @returns Resolves once enqueued.
+   * @param env - Per-request Cloudflare bindings object.
+   * @param body - Message body to enqueue.
+   * @returns Resolves once the message is enqueued.
    */
-  send(env: WorkerEnv, queue: string, body: unknown): Promise<void>;
+  send(env: WorkerEnv, body: unknown): Promise<void>;
   /**
-   * Enqueue many messages; each element becomes one message.
+   * Enqueue many messages onto this instance's queue; each element becomes one message.
    *
-   * @param env - Per-request Cloudflare bindings.
-   * @param queue - Target queue binding name.
-   * @param bodies - Message bodies.
-   * @returns Resolves once enqueued.
+   * @param env - Per-request Cloudflare bindings object.
+   * @param bodies - Array of message bodies; each becomes one message.
+   * @returns Resolves once all messages are enqueued.
    */
-  sendBatch(env: WorkerEnv, queue: string, bodies: unknown[]): Promise<void>;
+  sendBatch(env: WorkerEnv, bodies: unknown[]): Promise<void>;
+};
+/**
+ * The app.queues surface — the default instance's producer methods, a `use(key)` selector for the
+ * others, the consumer dispatch entry, plus deploy metadata.
+ *
+ * @example
+ * ```ts
+ * await app.queues.send(env, { orderId: "1" });          // default instance
+ * await app.queues.use("activity").send(env, { id: 2 }); // a named instance
+ * ```
+ */
+type Api = QueueProducerApi & {
   /**
-   * Consumer dispatch — the Worker's queue() export delegates here.
+   * Select a specific Queue instance by its config key.
+   *
+   * @param key - The instance key (as configured under `pluginConfigs.queues`).
+   * @returns The producer surface bound to that instance.
+   */
+  use(key: string): QueueProducerApi;
+  /**
+   * Consumer dispatch — the Worker's `queue()` export delegates here. Routes the batch to the
+   * matching instance's `onMessage` (by config key map / CF queue name).
    *
    * @param batch - The incoming message batch.
    * @param env - Per-request Cloudflare bindings.
-   * @param exec - waitUntil / passThroughOnException.
+   * @param ctx - waitUntil / passThroughOnException.
    * @returns Resolves after all messages settle.
    */
-  consume(batch: MessageBatch, env: WorkerEnv, exec: ExecutionContext): Promise<void>;
+  consume(batch: MessageBatch, env: WorkerEnv, ctx: ExecutionContext): Promise<void>;
   /**
-   * Return this plugin's deploy metadata (read by the deploy plugin).
+   * Return this plugin's deploy metadata (one entry per configured instance), read by the deploy
+   * plugin. Build-time only — takes no env.
    *
-   * @returns Deploy manifest entry `{ kind: "queue", producers }`.
+   * @returns One queue deploy descriptor per configured instance. `consumer: true` marks an instance
+   *   that declares an `onMessage` handler — the deploy plugin registers those as wrangler
+   *   `consumers` so this Worker actually receives the queue's messages.
    */
-  deployManifest(): DeployManifest;
+  deployManifest(): Array<{
+    kind: "queue";
+    name: string;
+    binding: string;
+    consumer?: boolean;
+  }>;
 };
 /**
  * Internal context type — own config first, no state, merged queue events.
@@ -744,7 +882,8 @@ type Ctx = PluginCtx$1<Config$1, Record<string, never>, WorkerEvents & QueueEven
 //#endregion
 //#region src/plugins/queues/index.d.ts
 /**
- * Standard tier — Cloudflare Queues producer + consumer dispatch.
+ * Standard tier — Cloudflare Queues producer + per-instance consumer dispatch over a keyed map of
+ * instances.
  *
  * `events` is declared first and via `register.map<QueueEvents>` so the plugin's own events infer
  * into the factory context; the api wiring is therefore arrow-wrapped (contextually typed).
@@ -753,15 +892,7 @@ type Ctx = PluginCtx$1<Config$1, Record<string, never>, WorkerEvents & QueueEven
  *
  * @see README.md
  */
-declare const queuesPlugin: import("@moku-labs/core").PluginInstance<"queues", Config$1, Record<string, never>, {
-  send: (env: Parameters<(message: Message, env: WorkerEnv) => Promise<void>>[1], q: string, body: unknown) => Promise<void>;
-  sendBatch: (env: Parameters<(message: Message, env: WorkerEnv) => Promise<void>>[1], q: string, bodies: unknown[]) => Promise<void>;
-  consume: (batch: MessageBatch, env: Parameters<(message: Message, env: WorkerEnv) => Promise<void>>[1], _exec: ExecutionContext) => Promise<void>;
-  deployManifest: () => {
-    kind: "queue";
-    producers: string[];
-  };
-}, {
+declare const queuesPlugin: import("@moku-labs/core").PluginInstance<"queues", Config$1, Record<string, never>, Api, {
   "queue:message": {
     queue: string;
     messageId: string;
@@ -810,28 +941,43 @@ type StorageProvider = {
   list(opts?: R2ListOptions): Promise<R2Objects>;
 };
 declare namespace types_d_exports$5 {
-  export { StorageApi, StorageConfig, StorageCtx, StorageManifest, StorageProvider };
+  export { R2Instance, StorageApi, StorageBucketApi, StorageConfig, StorageCtx, StorageProvider };
 }
 /**
- * storage plugin configuration. Flat; complete defaults so omission never yields undefined.
+ * A single R2 bucket instance: its base Cloudflare name, the env binding it resolves off, and an
+ * optional deploy-time upload directory.
  *
  * @example
- * ```ts
- * { upload: "./public", bucket: "ASSETS" }
+ * ```typescript
+ * { name: "tracker-files", binding: "FILES" }
  * ```
  */
-type StorageConfig = {
-  /** Directory uploaded to R2 at deploy (deploy metadata only). Default "". */upload: string; /** R2 bucket binding name resolved off the per-request env. Default "ASSETS". */
-  bucket: string;
-};
-/** Deploy metadata returned to the deploy plugin. */
-type StorageManifest = {
-  /** Discriminant identifying this as an R2 resource. */readonly kind: "r2"; /** R2 bucket binding name. */
-  readonly bucket: string; /** Directory uploaded to R2 at deploy. */
-  readonly upload: string;
+type R2Instance = {
+  /** Base Cloudflare R2 bucket name (stage-suffixed at deploy). */name: string; /** Env binding name the bucket resolves off the per-request `env` (e.g. `env.FILES`). */
+  binding: string; /** Directory uploaded to this bucket at deploy (deploy metadata only). */
+  upload?: string; /** Marks this instance the default when more than one is configured. */
+  default?: boolean;
 };
-/** Public storage API surface (env-first). */
-type StorageApi = {
+/**
+ * storage plugin config — a keyed map of R2 bucket instances. The key is the stable logical id used by
+ * `app.storage.use("key")`; a single entry (or one flagged `default: true`) is the implicit default.
+ *
+ * @example
+ * ```typescript
+ * { files: { name: "tracker-files", binding: "FILES" } }
+ * ```
+ */
+type StorageConfig = Record<string, R2Instance>;
+/**
+ * The env-first object surface for one R2 bucket (the methods bound to a single instance).
+ *
+ * @example
+ * ```typescript
+ * const body = await app.storage.get(env, "assets/logo.png");
+ * await app.storage.use("uploads").put(env, "avatar.png", buffer);
+ * ```
+ */
+type StorageBucketApi = {
   /**
    * Read an object; resolves null when the key is absent.
    *
@@ -865,12 +1011,37 @@ type StorageApi = {
    * @returns The list result.
    */
   list(env: WorkerEnv, opts?: R2ListOptions): Promise<R2Objects>;
+};
+/**
+ * The app.storage surface — the default bucket's methods, a `use(key)` selector for the others, plus
+ * deploy metadata.
+ *
+ * @example
+ * ```typescript
+ * const body = await app.storage.get(env, "assets/logo.png");      // default bucket
+ * await app.storage.use("uploads").put(env, "avatar.png", buffer); // a named bucket
+ * ```
+ */
+type StorageApi = StorageBucketApi & {
   /**
-   * Build-time deploy metadata for the deploy plugin.
+   * Select a specific R2 bucket instance by its config key.
    *
-   * @returns Deploy manifest entry `{ kind: "r2", bucket, upload }`.
+   * @param key - The instance key (as configured under `pluginConfigs.storage`).
+   * @returns The object surface bound to that bucket.
    */
-  deployManifest(): StorageManifest;
+  use(key: string): StorageBucketApi;
+  /**
+   * Returns this plugin's own deploy metadata (one entry per configured bucket), read by the deploy
+   * plugin. Build-time only — takes no env.
+   *
+   * @returns One r2 deploy descriptor per configured instance.
+   */
+  deployManifest(): Array<{
+    kind: "r2";
+    name: string;
+    binding: string;
+    upload?: string;
+  }>;
 };
 /**
  * Internal context type — own config first, no state, no storage events.
@@ -1002,7 +1173,7 @@ declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<
   current: () => "production" | "development" | "test";
 }>]>>;
 /** The core-bound app factory; wrapped by {@link createApp} to bridge `config.stage`. */
-declare const boundCreateApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<WorkerConfig, WorkerEvents, (import("@moku-labs/core").PluginInstance<"bindings", Config$4, Record<string, never>, BindingsApi, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"server", ServerConfig, ServerState, Api$3, {
+declare const boundCreateApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<WorkerConfig, WorkerEvents, (import("@moku-labs/core").PluginInstance<"bindings", Config$5, Record<string, never>, BindingsApi, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"server", ServerConfig, ServerState, Api$3, {
   "server:matched": {
     path: string;
     method: string;
@@ -1015,7 +1186,7 @@ declare const boundCreateApp: <const ExtraPlugins extends readonly import("@moku
   isDev: () => boolean;
   isProduction: () => boolean;
   current: () => "production" | "development" | "test";
-}>]>> | undefined) => import("@moku-labs/core").App<WorkerConfig, WorkerEvents, (import("@moku-labs/core").PluginInstance<"bindings", Config$4, Record<string, never>, BindingsApi, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"server", ServerConfig, ServerState, Api$3, {
+}>]>> | undefined) => import("@moku-labs/core").App<WorkerConfig, WorkerEvents, (import("@moku-labs/core").PluginInstance<"bindings", Config$5, Record<string, never>, BindingsApi, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"server", ServerConfig, ServerState, Api$3, {
   "server:matched": {
     path: string;
     method: string;