@velajs/vela 1.19.0 → 1.19.1

package/package.json

@@ -1,8 +1,41 @@
 {
   "name": "@velajs/vela",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
+  "keywords": [
+    "bun",
+    "cloudflare-workers",
+    "decorators",
+    "deno",
+    "dependency-injection",
+    "edge",
+    "framework",
+    "hono",
+    "nestjs",
+    "typescript"
+  ],
+  "homepage": "https://github.com/velajs/vela#readme",
+  "bugs": {
+    "url": "https://github.com/velajs/vela/issues"
+  },
+  "license": "MIT",
+  "author": "ksh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velajs/vela.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "type": "module",
+  "sideEffects": [
+    "./dist/index.js",
+    "./dist/metadata.js",
+    "./dist/schedule-node/index.js"
+  ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -51,47 +84,29 @@
       "import": "./dist/seeder/index.js"
     }
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
-  ],
-  "sideEffects": [
-    "./dist/index.js",
-    "./dist/metadata.js",
-    "./dist/schedule-node/index.js"
-  ],
-  "keywords": [
-    "edge",
-    "hono",
-    "nestjs",
-    "framework",
-    "decorators",
-    "dependency-injection",
-    "cloudflare-workers",
-    "deno",
-    "bun",
-    "typescript"
-  ],
-  "author": "ksh",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/velajs/vela.git"
-  },
-  "homepage": "https://github.com/velajs/vela#readme",
-  "bugs": {
-    "url": "https://github.com/velajs/vela/issues"
-  },
-  "engines": {
-    "node": ">=20"
-  },
   "dependencies": {
     "@velajs/errors": "^1.0.0",
     "@velajs/live-protocol": "^1.0.0",
     "hono": "^4.12.26"
   },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@changesets/cli": "^2.31.0",
+    "@cloudflare/vitest-pool-workers": "^0.16.18",
+    "@swc/core": "^1.15.43",
+    "@types/bun": "latest",
+    "@vitest/runner": "^4.1.10",
+    "@vitest/snapshot": "^4.1.10",
+    "intl-messageformat": "^11.2.9",
+    "oxfmt": "^0.58.0",
+    "oxlint": "^1.73.0",
+    "publint": "^0.3.21",
+    "tsdown": "^0.22.4",
+    "typescript": "^7.0.2",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3"
+  },
   "peerDependencies": {
     "intl-messageformat": ">=10"
   },
@@ -100,28 +115,26 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.16.18",
-    "@swc/cli": "^0.8.1",
-    "@swc/core": "^1.15.41",
-    "@types/bun": "latest",
-    "@vitest/runner": "^4.1.9",
-    "@vitest/snapshot": "^4.1.9",
-    "intl-messageformat": "^11.2.9",
-    "typedoc": "~0.28.19",
-    "typescript": "^6.0.3",
-    "unplugin-swc": "^1.5.9",
-    "vitest": "^4.1.9",
-    "zod": "^4.4.3"
+  "engines": {
+    "node": ">=24"
   },
   "scripts": {
-    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "build": "tsdown",
     "test": "vitest run",
     "test:workers": "vitest run --config vitest.config.workers.ts",
     "test:workers:als": "vitest run --config vitest.config.workers-als.ts",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.type-tests.json",
     "check:skill": "node scripts/check-skill.mjs",
-    "docs": "typedoc",
-    "docs:check": "typedoc --emit none"
+    "docs": "pnpm --dir tools/docs docs",
+    "docs:check": "pnpm --dir tools/docs docs:check",
+    "lint": "oxlint .",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "publint": "publint",
+    "attw": "attw --pack . --profile esm-only",
+    "changeset": "changeset",
+    "version-packages": "changeset version && node scripts/sync-skill-version.mjs",
+    "release": "pnpm build && changeset publish",
+    "verify": "pnpm lint && pnpm format:check && pnpm build && pnpm typecheck && pnpm check:skill && pnpm docs:check && pnpm test && pnpm test:workers && pnpm test:workers:als && pnpm publint && pnpm attw"
   }
 }

package/dist/__tests__/workers/entry.d.ts

@@ -1,9 +0,0 @@
-declare const _default: {
-    fetch(request: Request, _env: unknown, _ctx: unknown): Promise<Response>;
-};
-export default _default;
-declare global {
-    interface ExportedHandler<Env = unknown> {
-        fetch?(request: Request, env: Env, ctx: unknown): Response | Promise<Response>;
-    }
-}

package/dist/__tests__/workers-als/entry-als.d.ts

@@ -1,9 +0,0 @@
-declare const _default: {
-    fetch(request: Request): Promise<Response>;
-};
-export default _default;
-declare global {
-    interface ExportedHandler<Env = unknown> {
-        fetch?(request: Request, env: Env, ctx: unknown): Response | Promise<Response>;
-    }
-}

package/dist/application.d.ts

@@ -1,104 +0,0 @@
-import type { Hono } from 'hono';
-import type { Container } from './container/container';
-import type { Token, Type } from './container/types';
-import type { ExceptionHandler } from './exceptions/exception-handler';
-import { EntrypointRegistry } from './entrypoint/entrypoint.registry';
-import type { RouteDescription, RouteManager } from './http/route.manager';
-import type { MountOpenApiOptions } from './openapi/types';
-import type { FilterType, GuardType, InterceptorType, PipeType } from './registry/types';
-export declare class VelaApplication {
-    private readonly container;
-    private readonly routeManager;
-    private instances;
-    private honoApp;
-    private entrypointRegistry;
-    private disposed;
-    private readonly lazyManager;
-    private readonly knownInstances;
-    constructor(container: Container, routeManager: RouteManager);
-    private trackNew;
-    /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */
-    initRoutes(): Promise<void>;
-    private getApp;
-    get fetch(): Hono['fetch'];
-    getInstances(): unknown[];
-    getContainer(): Container;
-    setInstances(instances: unknown[]): void;
-    get<T>(token: Token<T>): T;
-    getHonoApp(): Hono;
-    /**
-     * Every explicit controller route as the framework registered it (fully
-     * composed paths — the `vela route list` seam). Requires built routes;
-     * contributed routes (`@velajs/crud`) mount directly on Hono and are
-     * observable via `getHonoApp().routes` instead.
-     */
-    describeRoutes(): RouteDescription[];
-    /** The global route prefix in effect ('' when none). */
-    getGlobalPrefix(): string;
-    useGlobalPipes(...pipes: PipeType[]): this;
-    useGlobalGuards(...guards: GuardType[]): this;
-    useGlobalInterceptors(...interceptors: InterceptorType[]): this;
-    useGlobalFilters(...filters: FilterType[]): this;
-    /**
-     * Register the application-wide {@link ExceptionHandler} imperatively — the
-     * sibling of `ErrorsModule.forRoot({ handler })`. A class is constructed
-     * through DI (`useClass`); a plain handler object is registered verbatim
-     * (`useValue`). Consumed by `resolveErrorReporter` at every transport edge,
-     * so it takes effect on the next request without a rebuild.
-     *
-     * ```ts
-     * app.useGlobalExceptionHandler({ report: (e) => sentry.capture(e) });
-     * ```
-     */
-    useGlobalExceptionHandler(handler: Type<ExceptionHandler> | ExceptionHandler): this;
-    /**
-     * Serve a pre-built OpenAPI document and one or more interactive doc UIs
-     * (Swagger UI, Scalar, ReDoc) on the underlying Hono app, mirroring the
-     * hono-crud docs convention. Edge-safe: each UI is a tiny self-contained
-     * HTML shell that loads its renderer from a CDN at runtime so nothing is
-     * bundled server-side and no extra dependency is required.
-     *
-     * Defaults: spec at `/openapi.json`, Scalar at `/scalar`, Swagger UI at
-     * `/docs`, ReDoc at `/redoc`. The deprecated `path` / `uiPath` aliases are
-     * retained for migration from the previous single-UI shape.
-     *
-     * ```ts
-     * const doc = createOpenApiDocument(AppModule);
-     * app.mountOpenApi({ document: doc });            // Scalar @ /scalar
-     * app.mountOpenApi({ document: doc, ui: 'all' }); // swagger + scalar + redoc
-     * ```
-     */
-    mountOpenApi(options: MountOpenApiOptions): this;
-    /**
-     * Pull instances materialized during the bootstrap phase (lazy modules
-     * dragged in by eager consumers) into the front of the instance list —
-     * dependency-before-consumer: a group absorbed because an eager provider
-     * injected it must be initialized before that consumer's hooks read it.
-     */
-    private absorbLazyInstances;
-    callOnModuleInit(): Promise<void>;
-    callOnApplicationBootstrap(): Promise<void>;
-    /**
-     * Materialize every still-pending lazy module (async-safe): construct the
-     * groups, replay their lifecycle hooks, and add their instances to the
-     * shutdown flow. Warmup escape hatch for tests and node runtimes that want
-     * eager-everything semantics back after bootstrap.
-     */
-    materializeLazyModules(): Promise<void>;
-    /**
-     * Every entrypoint contributed by the module graph, grouped by kind —
-     * what runtime adapters/transports query instead of re-scanning providers:
-     * `app.entrypoints.ofKind('websocket')`.
-     */
-    get entrypoints(): EntrypointRegistry;
-    close(signal?: string): Promise<void>;
-    /**
-     * Full teardown: run shutdown lifecycle hooks ({@link close}) then dispose
-     * container-held instances (LIFO) and clear cached singletons. Use for
-     * graceful shutdown and dev HMR so old and new DI graphs never coexist.
-     *
-     * On runtimes/TS supporting explicit resource management this is also exposed
-     * as `Symbol.asyncDispose`, enabling `await using app = await VelaFactory.create(...)`.
-     */
-    dispose(signal?: string): Promise<void>;
-}

package/dist/application.js

@@ -1,364 +0,0 @@
-import { HTTPException } from "hono/http-exception";
-import { toErrorBody } from "@velajs/errors";
-import { APP_EXCEPTION_HANDLER } from "./pipeline/tokens.js";
-import { resolveErrorReporter } from "./exceptions/reporter.js";
-import { DiscoveryService } from "./discovery/discovery.service.js";
-import { EntrypointRegistry } from "./entrypoint/entrypoint.registry.js";
-import { LazyModuleManager } from "./module/lazy-modules.js";
-import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
-import { renderScalarUi } from "./openapi/scalar-ui.js";
-import { renderSwaggerUi } from "./openapi/swagger-ui.js";
-import { renderRedocUi } from "./openapi/redoc-ui.js";
-export class VelaApplication {
-    container;
-    routeManager;
-    instances = [];
-    honoApp = null;
-    entrypointRegistry = null;
-    disposed = false;
-    lazyManager;
-    // Identity guard for the instance flow: a token registered by BOTH a lazy
-    // and an eager module reaches us through the eager pass AND the absorbed
-    // batch — without dedup its hooks would run twice.
-    knownInstances = new Set();
-    constructor(container, routeManager){
-        this.container = container;
-        this.routeManager = routeManager;
-        // bootstrap() registers the manager; a hand-built container may not have
-        // one (container unit tests) — lazy semantics simply don't engage then.
-        this.lazyManager = container.has(LazyModuleManager) ? container.resolve(LazyModuleManager) : undefined;
-        // Live-phase materializations join the instance flow so close()/dispose()
-        // run shutdown hooks over them (LIFO — appended last, destroyed first).
-        this.lazyManager?.setOnMaterialized((instances)=>{
-            this.instances.push(...this.trackNew(instances));
-        });
-    }
-    trackNew(batch) {
-        const fresh = batch.filter((i)=>!this.knownInstances.has(i));
-        for (const i of fresh)this.knownInstances.add(i);
-        return fresh;
-    }
-    /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */ async initRoutes() {
-        this.honoApp = await this.routeManager.build();
-        // Last line of defense for the HTTP edge. HandlerExecutor's catch tail
-        // only sees controller-handler errors; a raw Hono middleware (or any
-        // hono-level throw that bypasses route.manager's wrapMiddlewareWithFilters)
-        // would otherwise reach Hono's default error handler unreported and
-        // unredacted. `onError` funnels it through the same report-first + canonical
-        // redacted body path every other edge uses.
-        this.honoApp.onError((err, c)=>{
-            const reporter = resolveErrorReporter(this.container);
-            // Hono's own HTTPException (e.g. `bodyLimit`'s 413) carries a deliberate,
-            // author-intended client response — honor it exactly as Hono's default
-            // error handler would, without treating it as a server fault to redact.
-            // But a 5xx HTTPException is still a server fault: every other edge reports
-            // before returning, so report status>=500 here too (leaving the verbatim
-            // response — and its redaction/status — untouched).
-            if (err instanceof HTTPException) {
-                if (err.status >= 500) {
-                    reporter.report(err, {
-                        edge: 'hono',
-                        source: `${c.req.method} ${c.req.path}`
-                    });
-                }
-                return err.getResponse();
-            }
-            reporter.report(err, {
-                edge: 'hono',
-                source: `${c.req.method} ${c.req.path}`
-            });
-            const { body, status } = toErrorBody(err, {
-                catalog: reporter.catalog
-            });
-            return c.json(body, status);
-        });
-    }
-    getApp() {
-        if (!this.honoApp) {
-            throw new Error('Routes not built. This should not happen — VelaFactory.create() builds routes automatically.');
-        }
-        return this.honoApp;
-    }
-    get fetch() {
-        return this.getApp().fetch;
-    }
-    getInstances() {
-        return this.instances;
-    }
-    getContainer() {
-        return this.container;
-    }
-    setInstances(instances) {
-        this.instances = instances;
-        this.knownInstances.clear();
-        for (const i of instances)this.knownInstances.add(i);
-    }
-    get(token) {
-        return this.container.resolve(token);
-    }
-    getHonoApp() {
-        return this.getApp();
-    }
-    /**
-   * Every explicit controller route as the framework registered it (fully
-   * composed paths — the `vela route list` seam). Requires built routes;
-   * contributed routes (`@velajs/crud`) mount directly on Hono and are
-   * observable via `getHonoApp().routes` instead.
-   */ describeRoutes() {
-        this.getApp(); // same routes-not-built guard as every HTTP accessor
-        return this.routeManager.getRouteDescriptions();
-    }
-    /** The global route prefix in effect ('' when none). */ getGlobalPrefix() {
-        return this.routeManager.getGlobalPrefix();
-    }
-    // Pipeline components — applied at request time, no rebuild needed
-    useGlobalPipes(...pipes) {
-        this.routeManager.useGlobalPipes(...pipes);
-        return this;
-    }
-    useGlobalGuards(...guards) {
-        this.routeManager.useGlobalGuards(...guards);
-        return this;
-    }
-    useGlobalInterceptors(...interceptors) {
-        this.routeManager.useGlobalInterceptors(...interceptors);
-        return this;
-    }
-    useGlobalFilters(...filters) {
-        this.routeManager.useGlobalFilters(...filters);
-        return this;
-    }
-    /**
-   * Register the application-wide {@link ExceptionHandler} imperatively — the
-   * sibling of `ErrorsModule.forRoot({ handler })`. A class is constructed
-   * through DI (`useClass`); a plain handler object is registered verbatim
-   * (`useValue`). Consumed by `resolveErrorReporter` at every transport edge,
-   * so it takes effect on the next request without a rebuild.
-   *
-   * ```ts
-   * app.useGlobalExceptionHandler({ report: (e) => sentry.capture(e) });
-   * ```
-   */ useGlobalExceptionHandler(handler) {
-        this.container.register(typeof handler === 'function' ? {
-            provide: APP_EXCEPTION_HANDLER,
-            useClass: handler
-        } : {
-            provide: APP_EXCEPTION_HANDLER,
-            useValue: handler
-        });
-        return this;
-    }
-    /**
-   * Serve a pre-built OpenAPI document and one or more interactive doc UIs
-   * (Swagger UI, Scalar, ReDoc) on the underlying Hono app, mirroring the
-   * hono-crud docs convention. Edge-safe: each UI is a tiny self-contained
-   * HTML shell that loads its renderer from a CDN at runtime so nothing is
-   * bundled server-side and no extra dependency is required.
-   *
-   * Defaults: spec at `/openapi.json`, Scalar at `/scalar`, Swagger UI at
-   * `/docs`, ReDoc at `/redoc`. The deprecated `path` / `uiPath` aliases are
-   * retained for migration from the previous single-UI shape.
-   *
-   * ```ts
-   * const doc = createOpenApiDocument(AppModule);
-   * app.mountOpenApi({ document: doc });            // Scalar @ /scalar
-   * app.mountOpenApi({ document: doc, ui: 'all' }); // swagger + scalar + redoc
-   * ```
-   */ mountOpenApi(options) {
-        const app = this.getApp();
-        const doc = options.document;
-        const title = options.title;
-        // Spec JSON: new default `/openapi.json`. The deprecated `path` alias is
-        // honored as an override only (does not change the default).
-        const specPath = options.specPath ?? options.path ?? '/openapi.json';
-        app.get(specPath, (c)=>c.json(doc));
-        // Normalize the requested UI set. Default is Scalar only.
-        const uiOption = options.ui;
-        let uis;
-        let singleStringUi = false;
-        if (uiOption === undefined) {
-            uis = [
-                'scalar'
-            ];
-        } else if (uiOption === 'all') {
-            uis = [
-                'swagger',
-                'scalar',
-                'redoc'
-            ];
-        } else if (Array.isArray(uiOption)) {
-            uis = uiOption;
-        } else {
-            uis = [
-                uiOption
-            ];
-            singleStringUi = true;
-        }
-        for (const ui of uis){
-            // Back-compat: the old `{ ui: 'scalar', uiPath }` form mapped a single
-            // string UI to `uiPath`. Honor that only when exactly one UI was
-            // requested as a string.
-            const legacyPath = singleStringUi && uis.length === 1 ? options.uiPath : undefined;
-            if (ui === 'swagger') {
-                const path = legacyPath ?? options.swaggerPath ?? '/docs';
-                const html = renderSwaggerUi(specPath, title);
-                app.get(path, (c)=>c.html(html));
-            } else if (ui === 'redoc') {
-                const path = legacyPath ?? options.redocPath ?? '/redoc';
-                const html = renderRedocUi(specPath, title);
-                app.get(path, (c)=>c.html(html));
-            } else {
-                const path = legacyPath ?? options.scalarPath ?? '/scalar';
-                const html = renderScalarUi(specPath, title);
-                app.get(path, (c)=>c.html(html));
-            }
-        }
-        return this;
-    }
-    // Lifecycle hooks
-    /**
-   * Pull instances materialized during the bootstrap phase (lazy modules
-   * dragged in by eager consumers) into the front of the instance list —
-   * dependency-before-consumer: a group absorbed because an eager provider
-   * injected it must be initialized before that consumer's hooks read it.
-   */ absorbLazyInstances(prepend) {
-        const batch = this.trackNew(this.lazyManager?.takeAbsorbed() ?? []);
-        if (batch.length === 0) return batch;
-        if (prepend) {
-            this.instances = [
-                ...batch,
-                ...this.instances
-            ];
-        } else {
-            this.instances.push(...batch);
-        }
-        return batch;
-    }
-    async callOnModuleInit() {
-        this.absorbLazyInstances(true);
-        // Index loop: hooks can trigger further absorptions, which append —
-        // the loop naturally covers them.
-        for(let i = 0; i < this.instances.length; i++){
-            const instance = this.instances[i];
-            if (hasOnModuleInit(instance)) {
-                await instance.onModuleInit();
-            }
-            this.absorbLazyInstances(false);
-        }
-    }
-    async callOnApplicationBootstrap() {
-        for(let i = 0; i < this.instances.length; i++){
-            const instance = this.instances[i];
-            if (hasOnApplicationBootstrap(instance)) {
-                await instance.onApplicationBootstrap();
-            }
-            // Instances absorbed mid-phase already missed the init pass — run
-            // onModuleInit now; the loop then reaches them for the bootstrap hook.
-            for (const late of this.absorbLazyInstances(false)){
-                if (hasOnModuleInit(late)) await late.onModuleInit();
-            }
-        }
-        // Computed-entrypoint contributors (ContributesEntrypoints) in lazy
-        // modules must exist before the snapshot below — materialize them now
-        // (the documented cost of contributing computed entrypoints), then run
-        // their hooks through the same absorb loop.
-        if (this.lazyManager) {
-            await this.lazyManager.materializeContributors();
-            let batch;
-            while((batch = this.absorbLazyInstances(false)).length > 0){
-                for (const late of batch){
-                    if (hasOnModuleInit(late)) await late.onModuleInit();
-                }
-                for (const late of batch){
-                    if (hasOnApplicationBootstrap(late)) await late.onApplicationBootstrap();
-                }
-            }
-            // From here on, materializations replay their hooks at the trigger.
-            this.lazyManager.setPhaseLive();
-        }
-        // Build the per-app entrypoint registry AFTER the hooks: dispatchers that
-        // implement ContributesEntrypoints (WsDispatcher) finish their own
-        // discovery inside onApplicationBootstrap. Built here — not in
-        // VelaFactory/initRoutes — so slim bootstrap paths that never build HTTP
-        // routes (the Cloudflare Durable Object) still get `app.entrypoints`.
-        // Lazy-pending providers of declared kinds yield metadata-only entries
-        // (instance: undefined) — dispatchers re-resolve by token per event,
-        // which materializes the owning module at dispatch time.
-        const discovery = this.container.has(DiscoveryService) ? this.container.resolve(DiscoveryService) : new DiscoveryService(this.container);
-        this.entrypointRegistry = await EntrypointRegistry.build(discovery, this.instances, {
-            deferLazy: true
-        });
-        // Make the per-app registry injectable (global token): providers that
-        // dispatch entrypoints themselves (the queue module's in-process driver
-        // binding) resolve it instead of needing a back-reference to the app.
-        // Registered AFTER build so anything resolving it sees the final registry;
-        // pre-bootstrap resolution attempts fail the `has()` probe and defer.
-        this.container.register({
-            provide: EntrypointRegistry,
-            useValue: this.entrypointRegistry
-        });
-        this.container.markGlobalToken(EntrypointRegistry);
-    }
-    /**
-   * Materialize every still-pending lazy module (async-safe): construct the
-   * groups, replay their lifecycle hooks, and add their instances to the
-   * shutdown flow. Warmup escape hatch for tests and node runtimes that want
-   * eager-everything semantics back after bootstrap.
-   */ async materializeLazyModules() {
-        await this.lazyManager?.materializeAll();
-    }
-    /**
-   * Every entrypoint contributed by the module graph, grouped by kind —
-   * what runtime adapters/transports query instead of re-scanning providers:
-   * `app.entrypoints.ofKind('websocket')`.
-   */ get entrypoints() {
-        if (!this.entrypointRegistry) {
-            throw new Error('Entrypoints are not built yet — they are assembled at the end of ' + 'callOnApplicationBootstrap(). Finish bootstrapping before querying them.');
-        }
-        return this.entrypointRegistry;
-    }
-    async close(signal) {
-        const reversed = [
-            ...this.instances
-        ].reverse();
-        for (const instance of reversed){
-            if (hasBeforeApplicationShutdown(instance)) {
-                await instance.beforeApplicationShutdown(signal);
-            }
-        }
-        for (const instance of reversed){
-            if (hasOnModuleDestroy(instance)) {
-                await instance.onModuleDestroy();
-            }
-        }
-        for (const instance of reversed){
-            if (hasOnApplicationShutdown(instance)) {
-                await instance.onApplicationShutdown(signal);
-            }
-        }
-    }
-    /**
-   * Full teardown: run shutdown lifecycle hooks ({@link close}) then dispose
-   * container-held instances (LIFO) and clear cached singletons. Use for
-   * graceful shutdown and dev HMR so old and new DI graphs never coexist.
-   *
-   * On runtimes/TS supporting explicit resource management this is also exposed
-   * as `Symbol.asyncDispose`, enabling `await using app = await VelaFactory.create(...)`.
-   */ async dispose(signal) {
-        // Idempotent: `await using` + an explicit dispose(), or repeated shutdown
-        // signals, must not re-run shutdown lifecycle hooks.
-        if (this.disposed) return;
-        this.disposed = true;
-        await this.close(signal);
-        await this.container.dispose();
-    }
-}
-// Attach the well-known async-dispose symbol at runtime (it is not in the
-// ES2022 lib the project compiles against) so `await using` works where
-// supported, without a type dependency on esnext.disposable.
-const ASYNC_DISPOSE = Symbol.asyncDispose;
-if (ASYNC_DISPOSE) {
-    VelaApplication.prototype[ASYNC_DISPOSE] = function() {
-        return this.dispose();
-    };
-}

package/dist/cache/cache.decorators.d.ts

@@ -1,2 +0,0 @@
-export declare const CacheKey: (key: string) => (target: object, propertyKey?: string | symbol) => void;
-export declare const CacheTTL: (seconds: number) => (target: object, propertyKey?: string | symbol) => void;

package/dist/cache/cache.decorators.js

@@ -1,4 +0,0 @@
-import { SetMetadata } from "../pipeline/reflector.js";
-import { CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";
-export const CacheKey = (key)=>SetMetadata(CACHE_KEY_METADATA, key);
-export const CacheTTL = (seconds)=>SetMetadata(CACHE_TTL_METADATA, seconds);

package/dist/cache/cache.interceptor.d.ts

@@ -1,9 +0,0 @@
-import type { ExecutionContext, CallHandler, NestInterceptor } from '../pipeline/types';
-import type { CacheModuleOptions, CacheStore } from './cache.types';
-export declare class CacheInterceptor implements NestInterceptor {
-    private cacheStore;
-    private options;
-    private reflector;
-    constructor(cacheStore: CacheStore, options: CacheModuleOptions);
-    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
-}