@velajs/vela 1.10.0 → 1.12.0

package/dist/seeder/seeder.module.js

@@ -5,25 +5,26 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { Module } from "../module/decorators.js";
+import { defineModule } from "../module/define-module.js";
 import { stableHash } from "../module/stable-hash.js";
 import { SeederRegistry } from "./seeder.registry.js";
-export class SeederModule {
-    /**
-   * Register seeder classes as providers so they're discovered at bootstrap.
-   * (Seeders declared in other modules' providers are also discovered — this is
-   * just a convenience to co-locate them.)
-   */ static forRoot(options = {}) {
-        const seeders = options.seeders ?? [];
-        return {
-            module: SeederModule,
-            key: stableHash({
-                seeders: seeders.map((s)=>s.name)
-            }),
+const { ConfigurableModuleClass } = defineModule({
+    name: 'Seeder',
+    // Class references aren't value-hashable — key on the seeder names, the same
+    // identity the hand-rolled forRoot used.
+    key: (options)=>stableHash({
+            seeders: (options.seeders ?? []).map((s)=>s.name)
+        }),
+    setup: ({ options })=>({
+            // Register seeder classes as providers so they're discovered at bootstrap.
+            // (Seeders declared in other modules' providers are also discovered — this
+            // is just a convenience to co-locate them.)
             providers: [
-                ...seeders
+                ...options.seeders ?? []
             ]
-        };
-    }
+        })
+});
+export class SeederModule extends ConfigurableModuleClass {
 }
 SeederModule = _ts_decorate([
     Module({

package/dist/websocket/index.d.ts

@@ -1,7 +1,7 @@
 export { WebSocketGateway, SubscribeMessage, MessageBody, ConnectedSocket, WebSocketServer, } from './websocket.decorators';
 export { WebSocketModule } from './websocket.module';
 export type { WebSocketModuleOptions } from './websocket.module';
-export { WsDispatcher } from './ws-dispatcher';
+export { WsDispatcher, type WsEntrypointMeta } from './ws-dispatcher';
 export { WsServerImpl, BroadcastOperatorImpl } from './ws-server';
 export { InMemoryRoomRegistry, local } from './ws-sync';
 export type { SyncDriver, RoomRegistry } from './ws-sync';

package/dist/websocket/index.js

@@ -2,7 +2,7 @@
 export { WebSocketGateway, SubscribeMessage, MessageBody, ConnectedSocket, WebSocketServer } from "./websocket.decorators.js";
 // Module
 export { WebSocketModule } from "./websocket.module.js";
-// Dispatcher (injected/called by transports)
+// Dispatcher (injected/called by transports) + the 'websocket' entrypoint meta
 export { WsDispatcher } from "./ws-dispatcher.js";
 // Server handle + rooms + sync
 export { WsServerImpl, BroadcastOperatorImpl } from "./ws-server.js";

package/dist/websocket/websocket.module.d.ts

@@ -1,4 +1,3 @@
-import type { DynamicModule } from '../module/types';
 import { type RoomRegistry, type SyncDriver } from './ws-sync';
 export interface WebSocketModuleOptions {
     /**
@@ -13,6 +12,24 @@ export interface WebSocketModuleOptions {
      */
     registry?: RoomRegistry;
 }
-export declare class WebSocketModule {
-    static forRoot(options?: WebSocketModuleOptions): DynamicModule;
+/**
+ * Registers the WebSocket gateway machinery: the message dispatcher (discovers
+ * `@WebSocketGateway` classes via DiscoveryService at bootstrap), the room
+ * registry, the sync driver, and the `@WebSocketServer()`-injected server
+ * handle.
+ *
+ * Construction lives in chained provider factories — registry → driver
+ * (bound to THAT registry) → server — so the single shared registry instance
+ * is preserved and everything materializes at bootstrap's eager
+ * instantiation, before any lifecycle hook or message dispatch.
+ *
+ * The instance key derives from the sync driver kind: two `forRoot()` calls
+ * with the same driver kind dedup (HMR-idempotent); pass an explicit `key`
+ * to run multiple same-kind instances side by side.
+ */
+declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<WebSocketModuleOptions, "forRoot", "create", {
+    isGlobal?: boolean;
+}>;
+export declare class WebSocketModule extends ConfigurableModuleClass {
 }
+export {};

package/dist/websocket/websocket.module.js

@@ -1,52 +1,63 @@
+import { defineModule } from "../module/define-module.js";
 import { WsDispatcher } from "./ws-dispatcher.js";
 import { WsServerImpl } from "./ws-server.js";
 import { InMemoryRoomRegistry, local } from "./ws-sync.js";
 import { WS_MODULE_OPTIONS, WS_ROOM_REGISTRY, WS_SERVER, WS_SYNC_DRIVER } from "./websocket.tokens.js";
 /**
  * Registers the WebSocket gateway machinery: the message dispatcher (discovers
- * `@WebSocketGateway` classes at bootstrap), the room registry, the sync driver,
- * and the `@WebSocketServer()`-injected server handle. Mirrors
- * `CacheModule.forRoot` / `ScheduleModule.forRoot`.
- */ // forRoot() carries non-serializable per-call state (a fresh registry/driver/
-// server), so each call is its own module instance. A unique key prevents the
-// module loader from deduping two distinct configurations into one (which would
-// silently discard the second registry/server).
-let instanceCounter = 0;
-export class WebSocketModule {
-    static forRoot(options = {}) {
-        const registry = options.registry ?? new InMemoryRoomRegistry();
-        const driver = options.sync ?? local();
-        driver.bind(registry);
-        const server = new WsServerImpl(driver);
-        const providers = [
-            {
-                provide: WS_MODULE_OPTIONS,
-                useValue: options
-            },
-            {
-                provide: WS_ROOM_REGISTRY,
-                useValue: registry
-            },
-            {
-                provide: WS_SYNC_DRIVER,
-                useValue: driver
-            },
-            {
-                provide: WS_SERVER,
-                useValue: server
-            },
-            WsDispatcher
-        ];
-        return {
-            module: WebSocketModule,
-            key: `${driver.kind}#${instanceCounter += 1}`,
-            providers,
+ * `@WebSocketGateway` classes via DiscoveryService at bootstrap), the room
+ * registry, the sync driver, and the `@WebSocketServer()`-injected server
+ * handle.
+ *
+ * Construction lives in chained provider factories — registry → driver
+ * (bound to THAT registry) → server — so the single shared registry instance
+ * is preserved and everything materializes at bootstrap's eager
+ * instantiation, before any lifecycle hook or message dispatch.
+ *
+ * The instance key derives from the sync driver kind: two `forRoot()` calls
+ * with the same driver kind dedup (HMR-idempotent); pass an explicit `key`
+ * to run multiple same-kind instances side by side.
+ */ const { ConfigurableModuleClass } = defineModule({
+    name: 'WebSocket',
+    optionsToken: WS_MODULE_OPTIONS,
+    key: (options)=>`ws#${options.sync?.kind ?? 'local'}`,
+    setup: ({ OPTIONS })=>({
+            providers: [
+                {
+                    provide: WS_ROOM_REGISTRY,
+                    useFactory: (o)=>o.registry ?? new InMemoryRoomRegistry(),
+                    inject: [
+                        OPTIONS
+                    ]
+                },
+                {
+                    provide: WS_SYNC_DRIVER,
+                    useFactory: (o, registry)=>{
+                        const driver = o.sync ?? local();
+                        driver.bind(registry);
+                        return driver;
+                    },
+                    inject: [
+                        OPTIONS,
+                        WS_ROOM_REGISTRY
+                    ]
+                },
+                {
+                    provide: WS_SERVER,
+                    useFactory: (driver)=>new WsServerImpl(driver),
+                    inject: [
+                        WS_SYNC_DRIVER
+                    ]
+                },
+                WsDispatcher
+            ],
             exports: [
                 WS_SERVER,
                 WS_SYNC_DRIVER,
                 WS_ROOM_REGISTRY,
                 WsDispatcher
             ]
-        };
-    }
+        })
+});
+export class WebSocketModule extends ConfigurableModuleClass {
 }

package/dist/websocket/websocket.tokens.d.ts

@@ -1,4 +1,5 @@
 import { InjectionToken } from '../container/types';
+import type { WebSocketModuleOptions } from './websocket.module';
 import type { RoomRegistry, SyncDriver } from './ws-sync';
 import type { WsServer } from './websocket.types';
 export declare const WS_GATEWAY_METADATA = "vela:ws-gateway";
@@ -19,4 +20,4 @@ export declare const WS_SERVER: InjectionToken<WsServer>;
 export declare const WS_SYNC_DRIVER: InjectionToken<SyncDriver>;
 /** The local room-membership registry a transport reads/writes. */
 export declare const WS_ROOM_REGISTRY: InjectionToken<RoomRegistry>;
-export declare const WS_MODULE_OPTIONS = "vela:ws-module-options";
+export declare const WS_MODULE_OPTIONS: InjectionToken<WebSocketModuleOptions>;

package/dist/websocket/websocket.tokens.js

@@ -16,5 +16,6 @@ export const WsParamType = {
  */ export const WS_SERVER = new InjectionToken('WS_SERVER');
 /** The active cross-instance sync driver (`local()` by default). */ export const WS_SYNC_DRIVER = new InjectionToken('WS_SYNC_DRIVER');
 /** The local room-membership registry a transport reads/writes. */ export const WS_ROOM_REGISTRY = new InjectionToken('WS_ROOM_REGISTRY');
-// forRoot() options carrier.
-export const WS_MODULE_OPTIONS = 'vela:ws-module-options';
+// forRoot() options carrier — a typed InjectionToken like every other module
+// options token (the raw-string form was the odd one out).
+export const WS_MODULE_OPTIONS = new InjectionToken('WS_MODULE_OPTIONS');

package/dist/websocket/ws-dispatcher.d.ts

@@ -1,24 +1,37 @@
 import { Container } from '../container/container';
+import { DiscoveryService } from '../discovery/discovery.service';
+import type { ContributesEntrypoints, Entrypoint } from '../entrypoint/entrypoint.types';
 import { RouteManager } from '../http/route.manager';
 import type { OnApplicationBootstrap } from '../lifecycle/index';
 import type { WsClient, WsServer } from './websocket.types';
+/** Metadata carried by each `'websocket'` entrypoint a transport consumes. */
+export interface WsEntrypointMeta {
+    /** The gateway's route path (from `@WebSocketGateway({ path })`). */
+    path: string;
+    /** The dispatcher that routes frames for this gateway. */
+    dispatcher: WsDispatcher;
+}
 /**
- * Discovers `@WebSocketGateway` classes at bootstrap (same `container.getTokens()`
- * scan as `EventEmitterSubscriber` / `ScheduleRegistry`) and routes inbound
- * messages to `@SubscribeMessage` handlers. Transports call `handleOpen`,
- * `dispatchMessage`, `handleClose`, and `handleError`; the guard → pipe →
- * interceptor → filter pipeline (including `APP_*` global components) is reused
- * from `ComponentManager`.
+ * Discovers `@WebSocketGateway` classes at bootstrap (via `DiscoveryService`)
+ * and routes inbound messages to `@SubscribeMessage` handlers. Transports read
+ * the gateways from `app.entrypoints.ofKind('websocket')` (this dispatcher
+ * contributes them) and call `handleOpen`, `dispatchMessage`, `handleClose`,
+ * and `handleError`; the guard → pipe → interceptor → filter pipeline
+ * (including `APP_*` global components) runs through the shared
+ * `PipelineRunner`.
  */
-export declare class WsDispatcher implements OnApplicationBootstrap {
+export declare class WsDispatcher implements OnApplicationBootstrap, ContributesEntrypoints {
     private readonly container;
+    private readonly discovery;
     private readonly server?;
     private readonly routeManager?;
     private readonly gateways;
-    constructor(container: Container, server?: WsServer | undefined, routeManager?: RouteManager | undefined);
+    constructor(container: Container, discovery: DiscoveryService, server?: WsServer | undefined, routeManager?: RouteManager | undefined);
     /** Paths of every discovered `@WebSocketGateway` — used by transports to register routes. */
     get gatewayPaths(): string[];
     onApplicationBootstrap(): Promise<void>;
+    /** One `'websocket'` entrypoint per discovered gateway (authoritative). */
+    collectEntrypoints(): Entrypoint<WsEntrypointMeta>[];
     handleOpen(path: string, client: WsClient): Promise<void>;
     handleClose(path: string, client: WsClient, _code: number, _reason: string): Promise<void>;
     handleError(path: string, _client: WsClient, err: unknown): Promise<void>;
@@ -28,6 +41,5 @@ export declare class WsDispatcher implements OnApplicationBootstrap {
     private trySend;
     private reportBootstrapError;
     private parse;
-    private resolveGateway;
     private buildGatewayEntry;
 }

package/dist/websocket/ws-dispatcher.js

@@ -14,10 +14,12 @@ function _ts_param(paramIndex, decorator) {
 }
 import { Container } from "../container/container.js";
 import { Inject, Injectable, Optional } from "../container/decorators.js";
+import { DiscoveryService } from "../discovery/discovery.service.js";
 import { instantiateMany } from "../http/instantiate.js";
 import { RouteManager } from "../http/route.manager.js";
 import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
+import { PipelineRunner } from "../pipeline/pipeline-runner.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { resolveWsArgs } from "./ws-argument-resolver.js";
 import { buildWsExecutionContext } from "./ws-execution-context.js";
@@ -37,11 +39,13 @@ function isWsResponse(x) {
 }
 export class WsDispatcher {
     container;
+    discovery;
     server;
     routeManager;
     gateways = new Map();
-    constructor(container, server, routeManager){
+    constructor(container, discovery, server, routeManager){
         this.container = container;
+        this.discovery = discovery;
         this.server = server;
         this.routeManager = routeManager;
     }
@@ -51,17 +55,15 @@ export class WsDispatcher {
         ];
     }
     async onApplicationBootstrap() {
-        for (const token of this.container.getTokens()){
-            if (typeof token !== 'function') continue;
-            const options = MetadataRegistry.getCustomClassMeta(token, WS_GATEWAY_METADATA);
-            if (!options) continue;
-            const instance = this.resolveGateway(token);
-            if (!instance) continue;
-            const entry = this.buildGatewayEntry(token, options, instance);
+        for (const found of this.discovery.providersWithMeta(WS_GATEWAY_METADATA)){
+            if (!found.instance) continue;
+            const gatewayClass = found.metatype;
+            const instance = found.instance;
+            const entry = this.buildGatewayEntry(gatewayClass, found.meta, instance);
             // Two gateways on the same path (or both defaulting to '') would silently
             // overwrite each other in the routing Map — surface it instead.
             if (this.gateways.has(entry.path)) {
-                const msg = `[vela] duplicate @WebSocketGateway path '${entry.path}' ` + `(${token.name}); keeping the first. Give each gateway a distinct path.`;
+                const msg = `[vela] duplicate @WebSocketGateway path '${entry.path}' ` + `(${gatewayClass.name}); keeping the first. Give each gateway a distinct path.`;
                 if (this.container.getDiagnostics() === 'throw') throw new Error(msg);
                 console.warn(msg);
                 continue;
@@ -71,11 +73,24 @@ export class WsDispatcher {
                 try {
                     await instance.afterInit(this.server);
                 } catch (err) {
-                    this.reportBootstrapError(token.name, err);
+                    this.reportBootstrapError(gatewayClass.name, err);
                 }
             }
         }
     }
+    /** One `'websocket'` entrypoint per discovered gateway (authoritative). */ collectEntrypoints() {
+        return [
+            ...this.gateways.values()
+        ].map((entry)=>({
+                kind: 'websocket',
+                token: entry.gatewayClass,
+                instance: entry.instance,
+                meta: {
+                    path: entry.path,
+                    dispatcher: this
+                }
+            }));
+    }
     async handleOpen(path, client) {
         const entry = this.gateways.get(path);
         if (entry && hasHandleConnection(entry.instance)) {
@@ -131,15 +146,17 @@ export class WsDispatcher {
             ...instantiateMany(globals?.filters ?? [], this.container)
         ];
         try {
-            for (const guard of guards){
-                if (!await guard.canActivate(ctx)) {
-                    throw new WsException('Forbidden');
-                }
-            }
-            const args = await resolveWsArgs(handler.paramMeta, client, message.data, pipes, handler.paramTypes);
             const method = entry.instance[handler.methodName];
-            const core = async ()=>method.apply(entry.instance, args);
-            const result = await ComponentManager.runInterceptorChain(interceptors, ctx, core);
+            // Guards → args + pipes → interceptor chain → handler, via the shared
+            // runner (WS keeps guards-first, unlike HTTP's args-before-guards).
+            const result = await PipelineRunner.run({
+                context: ctx,
+                guards,
+                interceptors,
+                resolveArgs: ()=>resolveWsArgs(handler.paramMeta, client, message.data, pipes, handler.paramTypes),
+                invoke: async (args)=>method.apply(entry.instance, args),
+                onGuardReject: ()=>new WsException('Forbidden')
+            });
             this.reply(client, message, result);
         } catch (error) {
             await this.runFilters(client, message, error, filters, ctx);
@@ -193,19 +210,6 @@ export class WsDispatcher {
         }
         return parsed;
     }
-    resolveGateway(token) {
-        try {
-            return this.container.resolve(token);
-        } catch (err) {
-            const mode = this.container.getDiagnostics();
-            if (mode === 'throw') throw err;
-            if (mode === 'log') {
-                const name = typeof token === 'function' ? token.name : String(token);
-                console.warn(`[vela] websocket gateway discovery: cannot resolve ${name}:`, err);
-            }
-            return undefined;
-        }
-    }
     buildGatewayEntry(gatewayClass, options, instance) {
         const ctor = gatewayClass;
         const subs = MetadataRegistry.getCustomClassMeta(ctor, WS_SUBSCRIBE_METADATA) ?? [];
@@ -220,12 +224,12 @@ export class WsDispatcher {
                 methodName,
                 paramMeta,
                 paramTypes,
-                guards: ComponentManager.getComponents('guard', ctor, methodName),
-                pipes: ComponentManager.getComponents('pipe', ctor, methodName),
-                interceptors: ComponentManager.getComponents('interceptor', ctor, methodName),
+                guards: ComponentManager.getScopedComponents('guard', ctor, methodName),
+                pipes: ComponentManager.getScopedComponents('pipe', ctor, methodName),
+                interceptors: ComponentManager.getScopedComponents('interceptor', ctor, methodName),
                 // Handler → controller → global, so the closest filter runs first (mirrors HandlerExecutor).
                 filters: [
-                    ...ComponentManager.getComponents('filter', ctor, methodName)
+                    ...ComponentManager.getScopedComponents('filter', ctor, methodName)
                 ].reverse()
             });
         }
@@ -240,13 +244,15 @@ export class WsDispatcher {
 WsDispatcher = _ts_decorate([
     Injectable(),
     _ts_param(0, Inject(Container)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(WS_SERVER)),
+    _ts_param(1, Inject(DiscoveryService)),
     _ts_param(2, Optional()),
-    _ts_param(2, Inject(RouteManager)),
+    _ts_param(2, Inject(WS_SERVER)),
+    _ts_param(3, Optional()),
+    _ts_param(3, Inject(RouteManager)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof Container === "undefined" ? Object : Container,
+        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
         typeof WsServer === "undefined" ? Object : WsServer,
         typeof RouteManager === "undefined" ? Object : RouteManager
     ])

package/dist/websocket-node/register-gateways.js

@@ -1,4 +1,4 @@
-import { WsDispatcher, WS_ROOM_REGISTRY } from "../websocket/index.js";
+import { WS_ROOM_REGISTRY } from "../websocket/index.js";
 import { NodeWsClient } from "./node-ws-client.js";
 function toText(data) {
     if (typeof data === 'string') return data;
@@ -24,9 +24,9 @@ function toText(data) {
  * ```
  */ export function registerWebSocketGateways(app, upgradeWebSocket) {
     const hono = app.getHonoApp();
-    const dispatcher = app.get(WsDispatcher);
     const registry = app.get(WS_ROOM_REGISTRY);
-    for (const path of dispatcher.gatewayPaths){
+    for (const { meta } of app.entrypoints.ofKind('websocket')){
+        const { path, dispatcher } = meta;
         hono.get(path, upgradeWebSocket((c)=>{
             const roomId = c.req.param('id') ?? path;
             let client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",

package/dist/http/crud-bridge.d.ts

@@ -1,90 +0,0 @@
-import type { Hono } from 'hono';
-import type { Type } from '../container/types';
-import type { CanActivate } from '../pipeline/types';
-import type { OpenApiPathItem } from '../openapi/types';
-/**
- * Context passed to {@link CrudBridge.buildRoutes} when mounting CRUD
- * sub-applications for a `@Crud()`-decorated controller.
- *
- * The bridge receives the framework's already-resolved view of the world so
- * it can produce identical routing behavior to a hand-written controller:
- * the same global prefix is prepended to every path, the same global guard
- * instances run before any generated handler, and the same path-joining
- * helper composes URL segments without double slashes.
- */
-export interface CrudBridgeRouteContext {
-    /** Application-wide path prefix (e.g. `/api`), already normalized. */
-    globalPrefix: string;
-    /** Global guard instances, pre-resolved from the root container. */
-    globalGuards: CanActivate[];
-    /** Path joiner used by the framework — handles slash normalization. */
-    joinPaths: (...parts: string[]) => string;
-}
-/**
- * Context passed to {@link CrudBridge.buildOpenApiPaths} when contributing
- * OpenAPI path items for a `@Crud()`-decorated controller.
- *
- * The bridge is responsible for producing fully-qualified path keys that
- * match the routes it actually mounts at request time. The framework supplies
- * the prefixes so the bridge does not have to re-derive them.
- */
-export interface CrudBridgeOpenApiContext {
-    /** Application-wide path prefix (e.g. `/api`), already normalized. */
-    globalPrefix: string;
-    /** Controller-level prefix as registered with `@Controller(...)`. */
-    controllerPrefix: string;
-}
-/**
- * Contract between `@velajs/vela` and a CRUD route generator (typically
- * `@velajs/crud`). The bridge inverts the previous dynamic-import pattern,
- * which was incompatible with Cloudflare Workers because esbuild leaves
- * `await import(variable)` calls as runtime imports the Workers loader
- * cannot resolve.
- *
- * A consumer registers an implementation once via {@link registerCrudBridge}
- * — usually as a side effect of importing `@velajs/crud` — and the framework
- * delegates both route building (at bootstrap) and OpenAPI generation
- * (at document creation) to it.
- */
-export interface CrudBridge {
-    /**
-     * Mount the CRUD sub-app for a controller with `vela:crud` metadata.
-     *
-     * Called during {@link RouteManager.build} after all `@Get`/`@Post`/etc.
-     * routes have been registered. The bridge is expected to attach generated
-     * routes (list, read, create, update, delete, …) onto the supplied Hono
-     * app under `ctx.globalPrefix + prefix`.
-     */
-    buildRoutes(app: Hono, controller: Type, prefix: string, crudConfig: unknown, ctx: CrudBridgeRouteContext): Promise<void>;
-    /**
-     * Contribute OpenAPI path items for a `@Crud()`-decorated controller.
-     *
-     * Called once per CRUD controller from `createOpenApiDocument` after the
-     * standard `@Get`/`@Post`/etc. paths have been collected. The returned
-     * record maps full OpenAPI path strings (e.g. `/api/users/{id}`) to path
-     * items, and is merged into the document — entries already present from
-     * hand-written handlers are preserved verb-by-verb.
-     */
-    buildOpenApiPaths(controller: Type, crudConfig: unknown, ctx: CrudBridgeOpenApiContext): Record<string, OpenApiPathItem>;
-}
-/**
- * Register a {@link CrudBridge} implementation. Intended to be called once at
- * import time by the CRUD package; subsequent calls overwrite the previous
- * registration (last-writer-wins). This is deliberate so test harnesses can
- * swap in mocks without a teardown step on the global state.
- */
-export declare function registerCrudBridge(bridge: CrudBridge): void;
-/**
- * Return the currently registered {@link CrudBridge}, or `undefined` if no
- * bridge has been registered. Consumers using `@Crud()` without a registered
- * bridge will receive a clear install-it error from the framework at build
- * time — see `RouteManager.build`.
- */
-export declare function getCrudBridge(): CrudBridge | undefined;
-/**
- * Reset the global bridge registration. Test-only — not exported from
- * `@velajs/vela/internal`. Use this in `beforeEach` to keep cases isolated.
- *
- * @internal
- */
-export declare function _resetCrudBridge(): void;

package/dist/http/crud-bridge.js

@@ -1,25 +0,0 @@
-let registered;
-/**
- * Register a {@link CrudBridge} implementation. Intended to be called once at
- * import time by the CRUD package; subsequent calls overwrite the previous
- * registration (last-writer-wins). This is deliberate so test harnesses can
- * swap in mocks without a teardown step on the global state.
- */ export function registerCrudBridge(bridge) {
-    registered = bridge;
-}
-/**
- * Return the currently registered {@link CrudBridge}, or `undefined` if no
- * bridge has been registered. Consumers using `@Crud()` without a registered
- * bridge will receive a clear install-it error from the framework at build
- * time — see `RouteManager.build`.
- */ export function getCrudBridge() {
-    return registered;
-}
-/**
- * Reset the global bridge registration. Test-only — not exported from
- * `@velajs/vela/internal`. Use this in `beforeEach` to keep cases isolated.
- *
- * @internal
- */ export function _resetCrudBridge() {
-    registered = undefined;
-}