@velajs/cloudflare 1.9.0 → 1.10.1

package/dist/cloudflare-application.js

@@ -1,186 +0,0 @@
-import { CRON_METADATA, PipelineRunner, buildEntrypointExecutionContext, registerEntrypointKind, runInEntrypointScope, shouldFilterCatch } from "@velajs/vela";
-import { ComponentManager } from "@velajs/vela/internal";
-import { collectWsGatewayRoutes } from "./websocket/websocket-routing.js";
-// vela's own @Cron jobs run via the same Workers cron trigger — declare an
-// entrypoint kind over vela's metadata key (the open-kind system makes
-// cross-package declarations first-class).
-registerEntrypointKind({
-    kind: 'cf:vela-cron',
-    metaKey: CRON_METADATA,
-    level: 'method'
-});
-function invoke(instance, methodName, args) {
-    const method = instance[methodName];
-    if (typeof method !== 'function') {
-        throw new Error(`Method '${methodName}' is not a function on ${instance.constructor.name}`);
-    }
-    return method.apply(instance, args);
-}
-/**
- * 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);
- * 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);
- * const document = createOpenApiDocument(AppModule);
- * app.mountOpenApi({ document, ui: 'scalar' });
- * // GET /openapi.json -> JSON document
- * // GET /scalar       -> Scalar UI (loads from CDN)
- * ```
- */ export class CloudflareApplication {
-    app;
-    wsGatewayRoutes = [];
-    constructor(app){
-        this.app = app;
-    }
-    get fetch() {
-        return this.app.fetch;
-    }
-    getHonoApp() {
-        return this.app.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: [...] })` request middleware,
-   * which runs outside the DI request pipeline.
-   *
-   * @example
-   * ```ts
-   * const app = await createCloudflareApp(AppModule);
-   * const auth = app.get<BetterAuthService>(BetterAuthService);
-   * ```
-   */ get(token) {
-        return this.app.get(token);
-    }
-    /**
-   * 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);
-   * 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) {
-        this.app.mountOpenApi(options);
-        return 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) {
-        for (const instance of instances){
-            if (!instance || typeof instance !== 'object') continue;
-            this.wsGatewayRoutes.push(...collectWsGatewayRoutes(instance));
-        }
-    }
-    /** @internal — upgrade routes discovered from `@WebSocketGateway({ path, binding })`. */ getWsGatewayRoutes() {
-        return this.wsGatewayRoutes;
-    }
-    /**
-   * 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).
-   */ async scheduled(event, env, ctx) {
-        const handlers = [
-            ...this.app.entrypoints.ofKind('cf:scheduled').map((ep)=>({
-                    ep,
-                    cron: ep.meta.cron
-                })),
-            ...this.app.entrypoints.ofKind('cf:vela-cron').map((ep)=>({
-                    ep,
-                    cron: ep.meta.expression
-                }))
-        ].filter((h)=>h.cron === event.cron);
-        await Promise.all(handlers.map(({ ep })=>this.dispatchEntrypoint(ep, [
-                event,
-                env,
-                ctx
-            ])));
-    }
-    /**
-   * 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.
-   */ async dispatchEntrypoint(ep, args) {
-        const targetClass = ep.token;
-        const methodName = String(ep.methodName);
-        const context = buildEntrypointExecutionContext(ep.kind, targetClass, methodName, args[0]);
-        await runInEntrypointScope(this.app.getContainer(), async (scope)=>{
-            const instance = scope.resolve(ep.token);
-            const guards = ComponentManager.resolveGuards(ComponentManager.getScopedComponents('guard', targetClass, methodName), scope);
-            const interceptors = ComponentManager.resolveInterceptors(ComponentManager.getScopedComponents('interceptor', targetClass, methodName), scope);
-            // Closest-first, mirroring the HTTP/WS dispatchers.
-            const filters = ComponentManager.resolveFilters([
-                ...ComponentManager.getScopedComponents('filter', targetClass, methodName)
-            ].reverse(), scope);
-            try {
-                await PipelineRunner.run({
-                    context,
-                    guards,
-                    interceptors,
-                    resolveArgs: async ()=>args,
-                    invoke: async (resolved)=>invoke(instance, methodName, resolved)
-                });
-            } catch (error) {
-                for (const filter of filters){
-                    if (shouldFilterCatch(filter, error)) {
-                        await filter.catch(error, context);
-                        return;
-                    }
-                }
-                throw error;
-            }
-        });
-    }
-    /**
-   * 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).
-   */ async queue(batch, env, ctx) {
-        const handlers = this.app.entrypoints.ofKind('cf:queue').filter((ep)=>ep.meta.queueName === batch.queue);
-        await Promise.all(handlers.map((ep)=>this.dispatchEntrypoint(ep, [
-                batch,
-                env,
-                ctx
-            ])));
-    }
-    async close(signal) {
-        return this.app.close(signal);
-    }
-}

package/dist/cloudflare-factory.d.ts

@@ -1,88 +0,0 @@
-import type { MiddlewareHandler } from 'hono';
-import type { RuntimeAdapter, Type } from '@velajs/vela';
-import { CloudflareApplication } from './cloudflare-application';
-/**
- * Options for {@link createCloudflareApp}.
- *
- * Mirrors a tight subset of vela's `BootstrapOptions` — only the surface
- * that makes sense for a Workers consumer is re-exposed.
- */
-export interface CreateCloudflareAppOptions {
-    /**
-     * Forwarded to `VelaFactory.create({ globalPrefix })`. Prepended to every
-     * route registered by `@Controller(...)` (and any other route emitter)
-     * inside the application, so a value of `'/v1'` turns `@Controller('/users')`
-     * into `/v1/users`.
-     *
-     * @example
-     * ```ts
-     * const app = await createCloudflareApp(AppModule, { globalPrefix: '/v1' });
-     * ```
-     */
-    globalPrefix?: string;
-    /**
-     * Extra Hono middleware to register on the underlying Hono app. Runs
-     * AFTER the one-time binding-init middleware this adapter mounts
-     * internally, so any handler in `middleware` can safely read from
-     * `BindingRef` instances and Cloudflare env bindings.
-     *
-     * @example
-     * ```ts
-     * const app = await createCloudflareApp(AppModule, {
-     *   middleware: [
-     *     async (c, next) => {
-     *       c.set('requestId', crypto.randomUUID());
-     *       await next();
-     *     },
-     *   ],
-     * });
-     * ```
-     */
-    middleware?: MiddlewareHandler[];
-}
-/**
- * Create a Cloudflare Workers application.
- *
- * Sets up a one-time Hono middleware that captures `c.env` on the first
- * request and initializes all configured binding refs. Optional
- * {@link CreateCloudflareAppOptions} are forwarded to the underlying
- * `VelaFactory.create` so consumers don't have to wrap the resulting
- * application in an outer Hono just to set a `globalPrefix` or attach
- * extra request middleware.
- *
- * @example
- * ```ts
- * // Minimal — backwards compatible
- * const app = await createCloudflareApp(AppModule);
- * export default app; // has .fetch, .scheduled, .queue
- * ```
- *
- * @example
- * ```ts
- * // With a global prefix and outer middleware
- * const app = await createCloudflareApp(AppModule, {
- *   globalPrefix: '/v1',
- *   middleware: [
- *     async (c, next) => {
- *       c.set('tenantId', c.req.header('x-tenant-id') ?? 'public');
- *       await next();
- *     },
- *   ],
- * });
- * ```
- */
-/**
- * The Cloudflare platform binding as a vela {@link RuntimeAdapter}: a one-time
- * request middleware captures `c.env` on the first request and initializes
- * every `BindingRef`/`EnvRef` (collected at `onBootstrap`, before any request
- * can arrive). Adapter `requestMiddleware` is prepended to the global chain by
- * `VelaFactory.create`, so user middleware can safely read binding refs.
- *
- * Exposed so consumers composing `VelaFactory.create` themselves can opt in:
- *
- * ```ts
- * const app = await VelaFactory.create(AppModule, { adapters: [cloudflareAdapter()] });
- * ```
- */
-export declare function cloudflareAdapter(): RuntimeAdapter;
-export declare function createCloudflareApp(rootModule: Type, options?: CreateCloudflareAppOptions): Promise<CloudflareApplication>;

package/dist/cloudflare-factory.js

@@ -1,101 +0,0 @@
-import { VelaFactory } from "@velajs/vela";
-import { BindingRef } from "./binding-ref.js";
-import { CloudflareApplication } from "./cloudflare-application.js";
-import { EnvRef } from "./env-ref.js";
-import { registerWebSocketRoutes } from "./websocket/websocket-routing.js";
-// Walks every provider registered in the container and pulls out the
-// BindingRef instances. Replaces the old module-level `bindingsRegistry`
-// global so two CloudflareApplication instances in one process don't
-// share state.
-function collectBindingRefs(container) {
-    // Enumerate per-instance useValue providers across ALL module buckets. Two
-    // same-type binding modules (e.g. KVModule.forRoot for CACHE and SESSIONS)
-    // share one token but live in distinct buckets — resolving the token would
-    // return only the first, leaving the others uninitialized.
-    const refs = [];
-    for (const value of container.getUseValues()){
-        if (value instanceof BindingRef) refs.push(value);
-    }
-    return refs;
-}
-/**
- * Create a Cloudflare Workers application.
- *
- * Sets up a one-time Hono middleware that captures `c.env` on the first
- * request and initializes all configured binding refs. Optional
- * {@link CreateCloudflareAppOptions} are forwarded to the underlying
- * `VelaFactory.create` so consumers don't have to wrap the resulting
- * application in an outer Hono just to set a `globalPrefix` or attach
- * extra request middleware.
- *
- * @example
- * ```ts
- * // Minimal — backwards compatible
- * const app = await createCloudflareApp(AppModule);
- * export default app; // has .fetch, .scheduled, .queue
- * ```
- *
- * @example
- * ```ts
- * // With a global prefix and outer middleware
- * const app = await createCloudflareApp(AppModule, {
- *   globalPrefix: '/v1',
- *   middleware: [
- *     async (c, next) => {
- *       c.set('tenantId', c.req.header('x-tenant-id') ?? 'public');
- *       await next();
- *     },
- *   ],
- * });
- * ```
- */ /**
- * The Cloudflare platform binding as a vela {@link RuntimeAdapter}: a one-time
- * request middleware captures `c.env` on the first request and initializes
- * every `BindingRef`/`EnvRef` (collected at `onBootstrap`, before any request
- * can arrive). Adapter `requestMiddleware` is prepended to the global chain by
- * `VelaFactory.create`, so user middleware can safely read binding refs.
- *
- * Exposed so consumers composing `VelaFactory.create` themselves can opt in:
- *
- * ```ts
- * const app = await VelaFactory.create(AppModule, { adapters: [cloudflareAdapter()] });
- * ```
- */ export function cloudflareAdapter() {
-    let initialized = false;
-    let refs = [];
-    return {
-        name: 'cloudflare',
-        requestMiddleware: [
-            async (c, next)=>{
-                if (!initialized) {
-                    initialized = true;
-                    const env = c.env ?? {};
-                    for (const ref of refs){
-                        // EnvRef holds the whole env; every other ref holds one binding.
-                        if (ref instanceof EnvRef) ref._initialize(env);
-                        else ref._initialize(env[ref.bindingName]);
-                    }
-                }
-                await next();
-            }
-        ],
-        onBootstrap: ({ container })=>{
-            refs = collectBindingRefs(container);
-        }
-    };
-}
-export async function createCloudflareApp(rootModule, options = {}) {
-    const velaApp = await VelaFactory.create(rootModule, {
-        globalPrefix: options.globalPrefix,
-        middleware: options.middleware,
-        adapters: [
-            cloudflareAdapter()
-        ]
-    });
-    const cfApp = new CloudflareApplication(velaApp);
-    cfApp.scanInstances(velaApp.getInstances());
-    // Register WebSocket upgrade routes for any @WebSocketGateway({ path, binding }).
-    // Each forwards the upgrade to the room's Durable Object (which owns the socket).
-    registerWebSocketRoutes(cfApp.getHonoApp(), cfApp.getWsGatewayRoutes());
-    return cfApp;
-}

package/dist/decorators/env.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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: CloudflareEnv) { ... }
- *
- * @Get()
- * handle(@Env('MY_KV') kv: KVNamespace) { ... }
- * ```
- */
-export declare const Env: (data?: string | undefined, ...pipes: import("@velajs/vela").PipeType[]) => ParameterDecorator;

package/dist/decorators/env.js

@@ -1,22 +0,0 @@
-import { createParamDecorator } from "@velajs/vela";
-/**
- * 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: CloudflareEnv) { ... }
- *
- * @Get()
- * handle(@Env('MY_KV') kv: KVNamespace) { ... }
- * ```
- */ export const Env = createParamDecorator((bindingName, ctx)=>{
-    // Hono Context has .env on Cloudflare Workers
-    const c = ctx.getContext();
-    const env = c.env;
-    if (!env) return undefined;
-    return bindingName ? env[bindingName] : env;
-});

package/dist/decorators/queue-consumer.d.ts

@@ -1,23 +0,0 @@
-export 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;
-export declare function getQueueConsumerMetadata(target: object): QueueConsumerMetadata[];

package/dist/decorators/queue-consumer.js

@@ -1,40 +0,0 @@
-import { defineMetadata, getMetadata, registerEntrypointKind } from "@velajs/vela";
-const QUEUE_CONSUMER_METADATA_KEY = 'cloudflare:queue-consumer';
-// Open entrypoint kind: any adapter can enumerate queue consumers via
-// `app.entrypoints.ofKind('cf:queue')` — declared here, next to the decorator,
-// with zero vela-core involvement.
-registerEntrypointKind({
-    kind: 'cf:queue',
-    metaKey: QUEUE_CONSUMER_METADATA_KEY,
-    level: 'method'
-});
-/**
- * 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 function QueueConsumer(queueName) {
-    return (target, propertyKey, _descriptor)=>{
-        const existing = getMetadata(QUEUE_CONSUMER_METADATA_KEY, target.constructor) ?? [];
-        existing.push({
-            queueName,
-            methodName: String(propertyKey)
-        });
-        defineMetadata(QUEUE_CONSUMER_METADATA_KEY, existing, target.constructor);
-    };
-}
-export function getQueueConsumerMetadata(target) {
-    const ctor = target.constructor ?? target;
-    return getMetadata(QUEUE_CONSUMER_METADATA_KEY, ctor) ?? [];
-}

package/dist/decorators/scheduled.d.ts

@@ -1,20 +0,0 @@
-export 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;
-export declare function getScheduledMetadata(target: object): ScheduledMetadata[];

package/dist/decorators/scheduled.js

@@ -1,36 +0,0 @@
-import { defineMetadata, getMetadata, registerEntrypointKind } from "@velajs/vela";
-const SCHEDULED_METADATA_KEY = 'cloudflare:scheduled';
-// Open entrypoint kind: adapters enumerate cron handlers via
-// `app.entrypoints.ofKind('cf:scheduled')` — declared next to the decorator.
-registerEntrypointKind({
-    kind: 'cf:scheduled',
-    metaKey: SCHEDULED_METADATA_KEY,
-    level: 'method'
-});
-/**
- * Marks a method as a scheduled (cron) handler.
- *
- * @example
- * ```ts
- * @Injectable()
- * class WorkerService {
- *   @Scheduled('0 * * * *')
- *   async hourlyCron() {
- *     console.log('Running hourly');
- *   }
- * }
- * ```
- */ export function Scheduled(cron) {
-    return (target, propertyKey, _descriptor)=>{
-        const existing = getMetadata(SCHEDULED_METADATA_KEY, target.constructor) ?? [];
-        existing.push({
-            cron,
-            methodName: String(propertyKey)
-        });
-        defineMetadata(SCHEDULED_METADATA_KEY, existing, target.constructor);
-    };
-}
-export function getScheduledMetadata(target) {
-    const ctor = target.constructor ?? target;
-    return getMetadata(SCHEDULED_METADATA_KEY, ctor) ?? [];
-}

package/dist/env-ref.d.ts

@@ -1,10 +0,0 @@
-import { BindingRef } from './binding-ref';
-/**
- * Holds the entire Cloudflare Worker `env` record (bindings + vars/secrets),
- * not a single binding. Subclasses {@link BindingRef} so createCloudflareApp's
- * binding-init middleware collects and initializes it through the same path;
- * the factory special-cases it to pass the full `env` instead of one binding.
- */
-export declare class EnvRef extends BindingRef<Record<string, unknown>> {
-    constructor();
-}

package/dist/env-ref.js

@@ -1,13 +0,0 @@
-import { BindingRef } from "./binding-ref.js";
-// Sentinel binding name for the whole-env holder — never used as an env key.
-const ENV_SENTINEL = '__cf_env__';
-/**
- * Holds the entire Cloudflare Worker `env` record (bindings + vars/secrets),
- * not a single binding. Subclasses {@link BindingRef} so createCloudflareApp's
- * binding-init middleware collects and initializes it through the same path;
- * the factory special-cases it to pass the full `env` instead of one binding.
- */ export class EnvRef extends BindingRef {
-    constructor(){
-        super(ENV_SENTINEL);
-    }
-}

package/dist/modules/ai.module.d.ts

@@ -1 +0,0 @@
-export declare const AIModule: import("./create-binding-module").BindingModuleStatic;

package/dist/modules/ai.module.js

@@ -1,8 +0,0 @@
-import { AIService } from "../services/ai.service.js";
-import { AI_BINDING_REF } from "../tokens.js";
-import { createBindingModule } from "./create-binding-module.js";
-export const AIModule = createBindingModule({
-    name: 'AI',
-    serviceClass: AIService,
-    bindingRefToken: AI_BINDING_REF
-});

package/dist/modules/create-binding-module.d.ts

@@ -1,14 +0,0 @@
-import { type DynamicModule, type InjectionToken, type Type } from '@velajs/vela';
-import { BindingRef } from '../binding-ref';
-interface CreateBindingModuleOptions<TService> {
-    name: string;
-    serviceClass: Type<TService>;
-    bindingRefToken: InjectionToken<BindingRef>;
-}
-export interface BindingModuleStatic {
-    forRoot(options: {
-        binding: string;
-    }): DynamicModule;
-}
-export declare function createBindingModule<TService>(opts: CreateBindingModuleOptions<TService>): BindingModuleStatic;
-export {};

package/dist/modules/create-binding-module.js

@@ -1,42 +0,0 @@
-import { defineConfigurableModule } from "@velajs/vela";
-import { BindingRef } from "../binding-ref.js";
-// Single factory for every Cloudflare binding module (KV, D1, R2, ...).
-// Each binding module is just a bag of (token, service); this generates the
-// canonical forRoot() shape via vela's `defineConfigurableModule` engine.
-//
-// Identity model (post vela audit #2):
-//   - One real module class is declared per binding TYPE (KV, D1, R2, ...).
-//     Its `name` property is set so error messages and diagnostics carry
-//     the friendly name (e.g. `KVModule`).
-//   - Each `forRoot({ binding })` returns `{ module, key: binding, ... }`.
-//     Vela dedups by (module, key), so two `KVModule.forRoot({...})` calls
-//     with different bindings coexist as distinct module instances; two
-//     calls with the same binding dedup.
-export function createBindingModule(opts) {
-    // Fresh module class per binding TYPE (one KVModule, one D1Module, ...).
-    // The computed-property-name idiom is the canonical JS way to give a
-    // class expression a dynamic `name`: NamedEvaluation reads the property
-    // key and stamps it on the class at creation, instead of patching the
-    // (configurable, non-writable) `name` slot via Object.defineProperty.
-    const className = `${opts.name}Module`;
-    const moduleClass = {
-        [className]: class {
-        }
-    }[className];
-    return defineConfigurableModule({
-        module: moduleClass,
-        methodName: 'forRoot',
-        keyFrom: ({ binding })=>binding,
-        providers: ({ binding })=>[
-                {
-                    provide: opts.bindingRefToken,
-                    useValue: new BindingRef(binding)
-                },
-                opts.serviceClass
-            ],
-        exports: [
-            opts.serviceClass,
-            opts.bindingRefToken
-        ]
-    });
-}

package/dist/modules/d1.module.d.ts

@@ -1 +0,0 @@
-export declare const D1Module: import("./create-binding-module").BindingModuleStatic;

package/dist/modules/d1.module.js

@@ -1,8 +0,0 @@
-import { D1Service } from "../services/d1.service.js";
-import { D1_BINDING_REF } from "../tokens.js";
-import { createBindingModule } from "./create-binding-module.js";
-export const D1Module = createBindingModule({
-    name: 'D1',
-    serviceClass: D1Service,
-    bindingRefToken: D1_BINDING_REF
-});

package/dist/modules/durable-object.module.d.ts

@@ -1 +0,0 @@
-export declare const DurableObjectModule: import("./create-binding-module").BindingModuleStatic;

package/dist/modules/durable-object.module.js

@@ -1,8 +0,0 @@
-import { DurableObjectService } from "../services/durable-object.service.js";
-import { DO_BINDING_REF } from "../tokens.js";
-import { createBindingModule } from "./create-binding-module.js";
-export const DurableObjectModule = createBindingModule({
-    name: 'DurableObject',
-    serviceClass: DurableObjectService,
-    bindingRefToken: DO_BINDING_REF
-});