@velajs/vela 1.18.0 → 1.19.1

package/dist/errors/http-exception.d.ts

@@ -1,62 +0,0 @@
-export type ExceptionResponse = string | Record<string, unknown>;
-export declare class HttpException extends Error {
-    readonly statusCode: number;
-    private readonly _response;
-    constructor(response: ExceptionResponse, statusCode: number);
-    getStatus(): number;
-    getResponse(): Record<string, unknown>;
-}
-export declare class BadRequestException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class UnauthorizedException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class ForbiddenException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class NotFoundException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class MethodNotAllowedException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class NotAcceptableException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class RequestTimeoutException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class ConflictException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class GoneException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class PayloadTooLargeException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class UnsupportedMediaTypeException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class UnprocessableEntityException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class TooManyRequestsException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class InternalServerErrorException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class NotImplementedException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class BadGatewayException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class ServiceUnavailableException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}
-export declare class GatewayTimeoutException extends HttpException {
-    constructor(message?: ExceptionResponse);
-}

package/dist/errors/http-exception.js

@@ -1,134 +0,0 @@
-export class HttpException extends Error {
-    statusCode;
-    _response;
-    constructor(response, statusCode){
-        const message = typeof response === 'string' ? response : JSON.stringify(response);
-        super(message);
-        this.name = 'HttpException';
-        this.statusCode = statusCode;
-        this._response = response;
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-    getStatus() {
-        return this.statusCode;
-    }
-    getResponse() {
-        if (typeof this._response === 'string') {
-            return {
-                statusCode: this.statusCode,
-                message: this._response
-            };
-        }
-        return this._response;
-    }
-}
-// 4xx
-export class BadRequestException extends HttpException {
-    constructor(message = 'Bad Request'){
-        super(message, 400);
-        this.name = 'BadRequestException';
-    }
-}
-export class UnauthorizedException extends HttpException {
-    constructor(message = 'Unauthorized'){
-        super(message, 401);
-        this.name = 'UnauthorizedException';
-    }
-}
-export class ForbiddenException extends HttpException {
-    constructor(message = 'Forbidden'){
-        super(message, 403);
-        this.name = 'ForbiddenException';
-    }
-}
-export class NotFoundException extends HttpException {
-    constructor(message = 'Not Found'){
-        super(message, 404);
-        this.name = 'NotFoundException';
-    }
-}
-export class MethodNotAllowedException extends HttpException {
-    constructor(message = 'Method Not Allowed'){
-        super(message, 405);
-        this.name = 'MethodNotAllowedException';
-    }
-}
-export class NotAcceptableException extends HttpException {
-    constructor(message = 'Not Acceptable'){
-        super(message, 406);
-        this.name = 'NotAcceptableException';
-    }
-}
-export class RequestTimeoutException extends HttpException {
-    constructor(message = 'Request Timeout'){
-        super(message, 408);
-        this.name = 'RequestTimeoutException';
-    }
-}
-export class ConflictException extends HttpException {
-    constructor(message = 'Conflict'){
-        super(message, 409);
-        this.name = 'ConflictException';
-    }
-}
-export class GoneException extends HttpException {
-    constructor(message = 'Gone'){
-        super(message, 410);
-        this.name = 'GoneException';
-    }
-}
-export class PayloadTooLargeException extends HttpException {
-    constructor(message = 'Payload Too Large'){
-        super(message, 413);
-        this.name = 'PayloadTooLargeException';
-    }
-}
-export class UnsupportedMediaTypeException extends HttpException {
-    constructor(message = 'Unsupported Media Type'){
-        super(message, 415);
-        this.name = 'UnsupportedMediaTypeException';
-    }
-}
-export class UnprocessableEntityException extends HttpException {
-    constructor(message = 'Unprocessable Entity'){
-        super(message, 422);
-        this.name = 'UnprocessableEntityException';
-    }
-}
-export class TooManyRequestsException extends HttpException {
-    constructor(message = 'Too Many Requests'){
-        super(message, 429);
-        this.name = 'TooManyRequestsException';
-    }
-}
-// 5xx
-export class InternalServerErrorException extends HttpException {
-    constructor(message = 'Internal Server Error'){
-        super(message, 500);
-        this.name = 'InternalServerErrorException';
-    }
-}
-export class NotImplementedException extends HttpException {
-    constructor(message = 'Not Implemented'){
-        super(message, 501);
-        this.name = 'NotImplementedException';
-    }
-}
-export class BadGatewayException extends HttpException {
-    constructor(message = 'Bad Gateway'){
-        super(message, 502);
-        this.name = 'BadGatewayException';
-    }
-}
-export class ServiceUnavailableException extends HttpException {
-    constructor(message = 'Service Unavailable'){
-        super(message, 503);
-        this.name = 'ServiceUnavailableException';
-    }
-}
-export class GatewayTimeoutException extends HttpException {
-    constructor(message = 'Gateway Timeout'){
-        super(message, 504);
-        this.name = 'GatewayTimeoutException';
-    }
-}

package/dist/errors/index.d.ts

@@ -1 +0,0 @@
-export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './http-exception';

package/dist/errors/index.js

@@ -1 +0,0 @@
-export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException } from "./http-exception.js";

package/dist/event-emitter/event-emitter.decorators.d.ts

@@ -1 +0,0 @@
-export declare function OnEvent(event: string): MethodDecorator;

package/dist/event-emitter/event-emitter.decorators.js

@@ -1,10 +0,0 @@
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
-export function OnEvent(event) {
-    return (target, propertyKey)=>{
-        MetadataRegistry.appendCustomClassMeta(target.constructor, ON_EVENT_METADATA, {
-            event,
-            methodName: String(propertyKey)
-        });
-    };
-}

package/dist/event-emitter/event-emitter.module.d.ts

@@ -1,2 +0,0 @@
-export declare class EventEmitterModule {
-}

package/dist/event-emitter/event-emitter.module.js

@@ -1,23 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Module } from "../module/index.js";
-import { EventEmitter } from "./event-emitter.service.js";
-import { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
-export class EventEmitterModule {
-}
-EventEmitterModule = _ts_decorate([
-    Module({
-        lazy: true,
-        providers: [
-            EventEmitter,
-            EventEmitterSubscriber
-        ],
-        exports: [
-            EventEmitter
-        ]
-    })
-], EventEmitterModule);

package/dist/event-emitter/event-emitter.service.d.ts

@@ -1,13 +0,0 @@
-import type { EventHandler } from './event-emitter.types';
-export declare class EventEmitter {
-    private exactListeners;
-    private exactOnceListeners;
-    private wildcardListeners;
-    on(event: string, handler: EventHandler): this;
-    once(event: string, handler: EventHandler): this;
-    off(event: string, handler: EventHandler): this;
-    emit(event: string, ...args: unknown[]): Promise<void>;
-    removeAllListeners(event?: string): this;
-    listenerCount(event: string): number;
-    private getOrCreateWildcard;
-}

package/dist/event-emitter/event-emitter.service.js

@@ -1,127 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Injectable } from "../container/index.js";
-function isWildcard(pattern) {
-    return pattern.includes('*');
-}
-function compilePattern(pattern) {
-    const regexStr = pattern.split('.').map((segment)=>{
-        if (segment === '**') return '.*';
-        if (segment === '*') return '[^.]+';
-        return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }).join('\\.');
-    return new RegExp(`^${regexStr}$`);
-}
-export class EventEmitter {
-    exactListeners = new Map();
-    exactOnceListeners = new Map();
-    wildcardListeners = new Map();
-    on(event, handler) {
-        if (isWildcard(event)) {
-            this.getOrCreateWildcard(event).handlers.add(handler);
-        } else {
-            const handlers = this.exactListeners.get(event) ?? new Set();
-            handlers.add(handler);
-            this.exactListeners.set(event, handlers);
-        }
-        return this;
-    }
-    once(event, handler) {
-        this.on(event, handler);
-        if (isWildcard(event)) {
-            this.getOrCreateWildcard(event).onceHandlers.add(handler);
-        } else {
-            const onceSet = this.exactOnceListeners.get(event) ?? new Set();
-            onceSet.add(handler);
-            this.exactOnceListeners.set(event, onceSet);
-        }
-        return this;
-    }
-    off(event, handler) {
-        if (isWildcard(event)) {
-            const entry = this.wildcardListeners.get(event);
-            if (entry) {
-                entry.handlers.delete(handler);
-                entry.onceHandlers.delete(handler);
-                if (entry.handlers.size === 0) this.wildcardListeners.delete(event);
-            }
-        } else {
-            const handlers = this.exactListeners.get(event);
-            if (handlers) {
-                handlers.delete(handler);
-                this.exactOnceListeners.get(event)?.delete(handler);
-                if (handlers.size === 0) this.exactListeners.delete(event);
-            }
-        }
-        return this;
-    }
-    async emit(event, ...args) {
-        const toRemove = [];
-        // Exact match
-        const exactHandlers = this.exactListeners.get(event);
-        if (exactHandlers) {
-            const onceSet = this.exactOnceListeners.get(event);
-            await Promise.all([
-                ...exactHandlers
-            ].map(async (handler)=>{
-                await handler(...args);
-                if (onceSet?.has(handler)) {
-                    toRemove.push(()=>this.off(event, handler));
-                }
-            }));
-        }
-        // Wildcard match (regex pre-compiled at registration)
-        for (const [pattern, entry] of this.wildcardListeners){
-            if (!entry.regex.test(event)) continue;
-            await Promise.all([
-                ...entry.handlers
-            ].map(async (handler)=>{
-                await handler(...args);
-                if (entry.onceHandlers.has(handler)) {
-                    toRemove.push(()=>this.off(pattern, handler));
-                }
-            }));
-        }
-        for (const remove of toRemove)remove();
-    }
-    removeAllListeners(event) {
-        if (event) {
-            if (isWildcard(event)) {
-                this.wildcardListeners.delete(event);
-            } else {
-                this.exactListeners.delete(event);
-                this.exactOnceListeners.delete(event);
-            }
-        } else {
-            this.exactListeners.clear();
-            this.exactOnceListeners.clear();
-            this.wildcardListeners.clear();
-        }
-        return this;
-    }
-    listenerCount(event) {
-        let count = this.exactListeners.get(event)?.size ?? 0;
-        for (const entry of this.wildcardListeners.values()){
-            if (entry.regex.test(event)) count += entry.handlers.size;
-        }
-        return count;
-    }
-    getOrCreateWildcard(pattern) {
-        const existing = this.wildcardListeners.get(pattern);
-        if (existing) return existing;
-        const entry = {
-            regex: compilePattern(pattern),
-            handlers: new Set(),
-            onceHandlers: new Set()
-        };
-        this.wildcardListeners.set(pattern, entry);
-        return entry;
-    }
-}
-EventEmitter = _ts_decorate([
-    Injectable()
-], EventEmitter);

package/dist/event-emitter/event-emitter.subscriber.d.ts

@@ -1,9 +0,0 @@
-import { DiscoveryService } from '../discovery/discovery.service';
-import type { OnApplicationBootstrap } from '../lifecycle/index';
-import { EventEmitter } from './event-emitter.service';
-export declare class EventEmitterSubscriber implements OnApplicationBootstrap {
-    private readonly discovery;
-    private emitter;
-    constructor(discovery: DiscoveryService, emitter: EventEmitter);
-    onApplicationBootstrap(): void;
-}

package/dist/event-emitter/event-emitter.subscriber.js

@@ -1,45 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Injectable, Inject } from "../container/index.js";
-import { DiscoveryService } from "../discovery/discovery.service.js";
-import { EventEmitter } from "./event-emitter.service.js";
-import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
-export class EventEmitterSubscriber {
-    discovery;
-    emitter;
-    constructor(discovery, emitter){
-        this.discovery = discovery;
-        this.emitter = emitter;
-    }
-    onApplicationBootstrap() {
-        for (const found of this.discovery.methodsWithMeta(ON_EVENT_METADATA)){
-            const instance = found.class.instance;
-            if (!instance) continue;
-            const method = instance[found.methodName];
-            if (typeof method === 'function') {
-                this.emitter.on(found.meta.event, (...args)=>method.apply(instance, args));
-            }
-        }
-    }
-}
-EventEmitterSubscriber = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(DiscoveryService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
-        typeof EventEmitter === "undefined" ? Object : EventEmitter
-    ])
-], EventEmitterSubscriber);

package/dist/event-emitter/event-emitter.tokens.d.ts

@@ -1 +0,0 @@
-export declare const ON_EVENT_METADATA = "vela:on-event";

package/dist/event-emitter/event-emitter.tokens.js

@@ -1 +0,0 @@
-export const ON_EVENT_METADATA = 'vela:on-event';

package/dist/event-emitter/event-emitter.types.d.ts

@@ -1,5 +0,0 @@
-export type EventHandler = (...args: unknown[]) => void | Promise<void>;
-export interface OnEventMetadata {
-    event: string;
-    methodName: string;
-}

package/dist/event-emitter/event-emitter.types.js

@@ -1 +0,0 @@
-export { };

package/dist/event-emitter/index.d.ts

@@ -1,6 +0,0 @@
-export { EventEmitterModule } from './event-emitter.module';
-export { EventEmitter } from './event-emitter.service';
-export { EventEmitterSubscriber } from './event-emitter.subscriber';
-export { OnEvent } from './event-emitter.decorators';
-export { ON_EVENT_METADATA } from './event-emitter.tokens';
-export type { EventHandler, OnEventMetadata } from './event-emitter.types';

package/dist/event-emitter/index.js

@@ -1,5 +0,0 @@
-export { EventEmitterModule } from "./event-emitter.module.js";
-export { EventEmitter } from "./event-emitter.service.js";
-export { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
-export { OnEvent } from "./event-emitter.decorators.js";
-export { ON_EVENT_METADATA } from "./event-emitter.tokens.js";

package/dist/factory/adapter.d.ts

@@ -1,36 +0,0 @@
-import type { MiddlewareHandler } from 'hono';
-import type { VelaApplication } from '../application';
-import type { Container } from '../container/container';
-import type { DiscoveryService } from '../discovery/discovery.service';
-import type { RouteManager } from '../http/route.manager';
-/** The framework's resolved world, handed to adapter hooks. */
-export interface AdapterContext {
-    app: VelaApplication;
-    container: Container;
-    routeManager: RouteManager;
-    discovery: DiscoveryService;
-}
-/**
- * The contract a runtime binding implements to plug a platform into a Vela
- * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
- * the Node/Bun WebSocket transport do, made first-class:
- *
- * ```ts
- * const app = await VelaFactory.create(AppModule, {
- *   adapters: [cloudflareAdapter({ bindings })],
- * });
- * ```
- *
- * - `requestMiddleware` is prepended to the global middleware chain (runs
- *   before consumer middleware — e.g. capture `c.env` for binding services).
- * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
- *   available, BEFORE routes are built — register platform services here.
- * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
- *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
- */
-export interface RuntimeAdapter {
-    name: string;
-    requestMiddleware?: MiddlewareHandler[];
-    onBootstrap?(ctx: AdapterContext): void | Promise<void>;
-    onRoutesBuilt?(ctx: AdapterContext): void | Promise<void>;
-}

package/dist/factory/adapter.js

@@ -1,18 +0,0 @@
-/**
- * The contract a runtime binding implements to plug a platform into a Vela
- * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
- * the Node/Bun WebSocket transport do, made first-class:
- *
- * ```ts
- * const app = await VelaFactory.create(AppModule, {
- *   adapters: [cloudflareAdapter({ bindings })],
- * });
- * ```
- *
- * - `requestMiddleware` is prepended to the global middleware chain (runs
- *   before consumer middleware — e.g. capture `c.env` for binding services).
- * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
- *   available, BEFORE routes are built — register platform services here.
- * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
- *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
- */ export { };

package/dist/factory/bootstrap.d.ts

@@ -1,23 +0,0 @@
-import { Container } from '../container/container';
-import type { Diagnostics, Type } from '../container/types';
-import { RouteManager } from '../http/route.manager';
-import type { RouteManagerOptions } from '../http/route.manager';
-import { ModuleLoader } from '../module/module-loader';
-export interface BootstrapOptions extends RouteManagerOptions {
-    diagnostics?: Diagnostics;
-}
-export interface BootstrapResult {
-    container: Container;
-    routeManager: RouteManager;
-    loader: ModuleLoader;
-}
-/**
- * Wire the DI graph for `rootModule` and prepare the route manager — without
- * running lifecycle hooks or building the Hono app. The single primitive
- * shared by `VelaFactory.create` (HTTP), `@velajs/testing` (test), and any
- * non-HTTP consumer (CLI tools, custom runtimes).
- *
- * Framework-internal tokens (`Container`, `ModuleRef`, `APP_*`) are marked
- * global so they are resolvable from any module.
- */
-export declare function bootstrap(rootModule: Type, options?: BootstrapOptions): Promise<BootstrapResult>;

package/dist/factory/bootstrap.js

@@ -1,108 +0,0 @@
-import { Scope } from "../constants.js";
-import { Container } from "../container/container.js";
-import { ModuleRef } from "../container/module-ref.js";
-import { DiscoveryService } from "../discovery/discovery.service.js";
-import { REQUEST_CONTEXT } from "../http/request-context.js";
-import { RouteManager } from "../http/route.manager.js";
-import { UrlGeneratorService } from "../http/url/url-generator.service.js";
-import { SignedUrlGuard } from "../http/url/signed-url.guard.js";
-import { ModuleLoader } from "../module/module-loader.js";
-import { bindAppProviders } from "../pipeline/app-providers.js";
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
-/**
- * Wire the DI graph for `rootModule` and prepare the route manager — without
- * running lifecycle hooks or building the Hono app. The single primitive
- * shared by `VelaFactory.create` (HTTP), `@velajs/testing` (test), and any
- * non-HTTP consumer (CLI tools, custom runtimes).
- *
- * Framework-internal tokens (`Container`, `ModuleRef`, `APP_*`) are marked
- * global so they are resolvable from any module.
- */ export async function bootstrap(rootModule, options = {}) {
-    const container = new Container({
-        diagnostics: options.diagnostics
-    });
-    container.register({
-        provide: Container,
-        useValue: container
-    });
-    container.markGlobalToken(Container);
-    container.register({
-        provide: ModuleRef,
-        useFactory: (c)=>new ModuleRef(c),
-        inject: [
-            Container
-        ]
-    });
-    container.markGlobalToken(ModuleRef);
-    // Decorator-driven discovery — global so any provider can inject it.
-    container.register({
-        provide: DiscoveryService,
-        useFactory: (c)=>new DiscoveryService(c),
-        inject: [
-            Container
-        ]
-    });
-    container.markGlobalToken(DiscoveryService);
-    for (const t of [
-        APP_GUARD,
-        APP_PIPE,
-        APP_INTERCEPTOR,
-        APP_FILTER,
-        APP_MIDDLEWARE
-    ]){
-        container.markGlobalToken(t);
-    }
-    // REQUEST_CONTEXT is seeded into each request-scoped child by RouteManager
-    // before any handler resolves it (see route.manager.ts:getRequestContainer).
-    // The factory throws so misuse outside the request path surfaces immediately
-    // instead of materializing a phantom context.
-    container.register({
-        provide: REQUEST_CONTEXT,
-        scope: Scope.REQUEST,
-        useFactory: ()=>{
-            throw new Error('REQUEST_CONTEXT can only be resolved inside a request — ' + 'it is seeded by RouteManager when the request enters the pipeline.');
-        }
-    });
-    container.markGlobalToken(REQUEST_CONTEXT);
-    const routeManager = new RouteManager(container, options);
-    // Resolvable so non-HTTP transports (the WebSocket dispatcher) can read the
-    // same global-tier components (APP_* + app.useGlobalX()).
-    container.register({
-        provide: RouteManager,
-        useValue: routeManager
-    });
-    container.markGlobalToken(RouteManager);
-    // Named-route URL generation + signed-URL verification are app-level
-    // singletons: injectable from any module, and (for the guard) instantiable by
-    // the pipeline when a route opts in via `@SignedUrl()`. Both read their secret
-    // lazily and never force controllers/lazy modules to materialize.
-    container.register(UrlGeneratorService);
-    container.markGlobalToken(UrlGeneratorService);
-    container.register(SignedUrlGuard);
-    container.markGlobalToken(SignedUrlGuard);
-    const loader = new ModuleLoader(container, routeManager);
-    // loader.load() also arms the deferred-init seam (LazyModuleManager) — kept
-    // inside the loader so hand-rolled bootstrap paths that never call this
-    // function (@velajs/testing's TestingModuleBuilder.compile) get identical
-    // lazy semantics.
-    loader.load(rootModule);
-    bindAppProviders(routeManager, container, loader);
-    routeManager.registerConsumerMiddleware(loader.getConsumerMiddlewareDefinitions());
-    if (options.globalPrefix) {
-        routeManager.setGlobalPrefix(options.globalPrefix);
-    }
-    for (const handler of options.middleware ?? []){
-        const mw = {
-            use: handler
-        };
-        routeManager.useGlobalMiddleware(mw);
-    }
-    // All providers are registered — compute request-scope bubbling so effective
-    // scopes are known before eager instantiation and request resolution.
-    container.computeEffectiveScopes();
-    return {
-        container,
-        routeManager,
-        loader
-    };
-}