@velajs/vela 1.19.0 → 1.19.1

package/dist/cache/cache.interceptor.js

@@ -1,60 +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/decorators.js";
-import { Reflector } from "../pipeline/reflector.js";
-import { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";
-export class CacheInterceptor {
-    cacheStore;
-    options;
-    reflector = new Reflector();
-    constructor(cacheStore, options){
-        this.cacheStore = cacheStore;
-        this.options = options;
-    }
-    async intercept(context, next) {
-        const request = context.getRequest();
-        // Only cache GET requests
-        if (request.method !== 'GET') {
-            return next.handle();
-        }
-        // Determine cache key
-        const customKey = this.reflector.getAllAndOverride(CACHE_KEY_METADATA, context);
-        const url = new URL(request.url);
-        const cacheKey = customKey ?? `cache:GET:${url.pathname}`;
-        // Check cache
-        const cached = this.cacheStore.get(cacheKey);
-        if (cached !== undefined) {
-            return cached;
-        }
-        // Execute handler
-        const result = await next.handle();
-        // Determine TTL
-        const customTtl = this.reflector.getAllAndOverride(CACHE_TTL_METADATA, context);
-        const ttl = customTtl ?? this.options.ttl ?? 5;
-        // Store in cache
-        this.cacheStore.set(cacheKey, result, ttl);
-        return result;
-    }
-}
-CacheInterceptor = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(CACHE_MANAGER)),
-    _ts_param(1, Inject(CACHE_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof CacheStore === "undefined" ? Object : CacheStore,
-        typeof CacheModuleOptions === "undefined" ? Object : CacheModuleOptions
-    ])
-], CacheInterceptor);

package/dist/cache/cache.module.d.ts

@@ -1,7 +0,0 @@
-import type { CacheModuleOptions } from './cache.types';
-declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<CacheModuleOptions, "forRoot", "create", {
-    isGlobal: boolean;
-}>;
-export declare class CacheModule extends ConfigurableModuleClass {
-}
-export {};

package/dist/cache/cache.module.js

@@ -1,58 +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/decorators.js";
-import { ConfigurableModuleBuilder } from "../module/configurable-module.builder.js";
-import { APP_INTERCEPTOR } from "../pipeline/tokens.js";
-import { CacheInterceptor } from "./cache.interceptor.js";
-import { CacheService } from "./cache.service.js";
-import { MemoryCacheStore } from "./cache.store.js";
-import { CACHE_MANAGER, CACHE_MODULE_OPTIONS } from "./cache.tokens.js";
-// Reuse the public CACHE_MODULE_OPTIONS token so its identity (and the
-// index.ts export) is unchanged. `isGlobal` here means "register the interceptor
-// globally as APP_INTERCEPTOR" — NOT `DynamicModule.global` — so the extras
-// transform is customized rather than using the default isGlobal→global.
-const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder({
-    moduleName: 'Cache',
-    optionsInjectionToken: CACHE_MODULE_OPTIONS
-}).setExtras({
-    isGlobal: false
-}, (definition, { isGlobal })=>isGlobal ? {
-        ...definition,
-        providers: [
-            ...definition.providers ?? [],
-            {
-                provide: APP_INTERCEPTOR,
-                useExisting: CacheInterceptor
-            }
-        ]
-    } : definition).build();
-export class CacheModule extends ConfigurableModuleClass {
-}
-CacheModule = _ts_decorate([
-    Module({
-        providers: [
-            CacheService,
-            CacheInterceptor,
-            // One options-injecting provider serves BOTH forRoot and forRootAsync.
-            // A custom `store` (e.g. TieredCacheStore / KVCacheStore) overrides the
-            // default in-memory store.
-            {
-                provide: CACHE_MANAGER,
-                useFactory: (options)=>options.store ?? new MemoryCacheStore(options.ttl ?? 5, options.max ?? 100),
-                inject: [
-                    MODULE_OPTIONS_TOKEN
-                ]
-            }
-        ],
-        exports: [
-            CACHE_MANAGER,
-            CACHE_MODULE_OPTIONS,
-            CacheService,
-            CacheInterceptor
-        ]
-    })
-], CacheModule);

package/dist/cache/cache.service.d.ts

@@ -1,9 +0,0 @@
-import type { CacheStore } from './cache.types';
-export declare class CacheService {
-    private store;
-    constructor(store: CacheStore);
-    get<T = unknown>(key: string): T | undefined;
-    set<T = unknown>(key: string, value: T, ttl?: number): void;
-    del(key: string): void;
-    clear(): void;
-}

package/dist/cache/cache.service.js

@@ -1,42 +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/decorators.js";
-import { CACHE_MANAGER } from "./cache.tokens.js";
-export class CacheService {
-    store;
-    constructor(store){
-        this.store = store;
-    }
-    get(key) {
-        return this.store.get(key);
-    }
-    set(key, value, ttl) {
-        this.store.set(key, value, ttl);
-    }
-    del(key) {
-        this.store.del(key);
-    }
-    clear() {
-        this.store.clear();
-    }
-}
-CacheService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(CACHE_MANAGER)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof CacheStore === "undefined" ? Object : CacheStore
-    ])
-], CacheService);

package/dist/cache/cache.store.d.ts

@@ -1,12 +0,0 @@
-import type { CacheStore } from './cache.types';
-export declare class MemoryCacheStore implements CacheStore {
-    private store;
-    private defaultTtl;
-    private max;
-    constructor(ttl?: number, max?: number);
-    get<T = unknown>(key: string): T | undefined;
-    set<T = unknown>(key: string, value: T, ttl?: number): void;
-    del(key: string): void;
-    clear(): void;
-    private evict;
-}

package/dist/cache/cache.store.js

@@ -1,51 +0,0 @@
-export class MemoryCacheStore {
-    store = new Map();
-    defaultTtl;
-    max;
-    constructor(ttl = 5, max = 100){
-        this.defaultTtl = ttl;
-        this.max = max;
-    }
-    get(key) {
-        const entry = this.store.get(key);
-        if (!entry) return undefined;
-        if (Date.now() > entry.expiresAt) {
-            this.store.delete(key);
-            return undefined;
-        }
-        return entry.value;
-    }
-    set(key, value, ttl) {
-        // Evict if at capacity
-        if (!this.store.has(key) && this.store.size >= this.max) {
-            this.evict();
-        }
-        const effectiveTtl = ttl ?? this.defaultTtl;
-        this.store.set(key, {
-            value,
-            expiresAt: Date.now() + effectiveTtl * 1000
-        });
-    }
-    del(key) {
-        this.store.delete(key);
-    }
-    clear() {
-        this.store.clear();
-    }
-    evict() {
-        // First remove expired entries
-        const now = Date.now();
-        for (const [key, entry] of this.store){
-            if (now > entry.expiresAt) {
-                this.store.delete(key);
-            }
-        }
-        // If still at capacity, remove oldest (first inserted)
-        if (this.store.size >= this.max) {
-            const firstKey = this.store.keys().next().value;
-            if (firstKey !== undefined) {
-                this.store.delete(firstKey);
-            }
-        }
-    }
-}

package/dist/cache/cache.tokens.d.ts

@@ -1,6 +0,0 @@
-import { InjectionToken } from '../container/types';
-import type { CacheStore, CacheModuleOptions } from './cache.types';
-export declare const CACHE_MANAGER: InjectionToken<CacheStore>;
-export declare const CACHE_MODULE_OPTIONS: InjectionToken<CacheModuleOptions>;
-export declare const CACHE_KEY_METADATA = "vela:cache-key";
-export declare const CACHE_TTL_METADATA = "vela:cache-ttl";

package/dist/cache/cache.tokens.js

@@ -1,5 +0,0 @@
-import { InjectionToken } from "../container/types.js";
-export const CACHE_MANAGER = new InjectionToken('CACHE_MANAGER');
-export const CACHE_MODULE_OPTIONS = new InjectionToken('CACHE_MODULE_OPTIONS');
-export const CACHE_KEY_METADATA = 'vela:cache-key';
-export const CACHE_TTL_METADATA = 'vela:cache-ttl';

package/dist/cache/cache.types.d.ts

@@ -1,41 +0,0 @@
-/** A value that may be returned synchronously or as a promise. */
-export type Awaitable<T> = T | Promise<T>;
-export interface CacheModuleOptions {
-    ttl?: number;
-    max?: number;
-    isGlobal?: boolean;
-    /**
-     * Custom SYNC backing store (replaces the default in-memory store). For async
-     * (KV/tiered) caching use {@link AsyncCacheStore} + `TieredCacheStore`
-     * programmatically — the interceptor/CacheService path is synchronous.
-     */
-    store?: CacheStore;
-}
-/**
- * Synchronous cache backing store. This is the original, stable contract used by
- * `CacheService` and `CacheInterceptor` — unchanged.
- */
-export interface CacheStore {
-    get<T = unknown>(key: string): T | undefined;
-    set<T = unknown>(key: string, value: T, ttl?: number): void;
-    del(key: string): void;
-    clear(): void;
-}
-/**
- * Asynchronous cache backing store (additive). Implemented by remote/tiered
- * stores (`TieredCacheStore`, and `KVCacheStore` in `@velajs/cloudflare`) where
- * reads/writes are inherently async. Use it programmatically — inject the store
- * under your own token — rather than as the synchronous `CACHE_MANAGER`.
- */
-export interface AsyncCacheStore {
-    get<T = unknown>(key: string): Promise<T | undefined>;
-    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
-    del(key: string): Promise<void>;
-    clear(): Promise<void>;
-}
-/** A store that may be sync or async (used to compose tiers). */
-export type AnyCacheStore = CacheStore | AsyncCacheStore;
-export interface CacheEntry<T = unknown> {
-    value: T;
-    expiresAt: number;
-}

package/dist/cache/cache.types.js

@@ -1 +0,0 @@
-/** A value that may be returned synchronously or as a promise. */ export { };

package/dist/cache/index.d.ts

@@ -1,8 +0,0 @@
-export { CacheModule } from './cache.module';
-export { CacheService } from './cache.service';
-export { CacheInterceptor } from './cache.interceptor';
-export { MemoryCacheStore } from './cache.store';
-export { TieredCacheStore } from './tiered-cache.store';
-export { CacheKey, CacheTTL } from './cache.decorators';
-export { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from './cache.tokens';
-export type { Awaitable, CacheModuleOptions, CacheStore, AsyncCacheStore, AnyCacheStore, CacheEntry, } from './cache.types';

package/dist/cache/index.js

@@ -1,7 +0,0 @@
-export { CacheModule } from "./cache.module.js";
-export { CacheService } from "./cache.service.js";
-export { CacheInterceptor } from "./cache.interceptor.js";
-export { MemoryCacheStore } from "./cache.store.js";
-export { TieredCacheStore } from "./tiered-cache.store.js";
-export { CacheKey, CacheTTL } from "./cache.decorators.js";
-export { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";

package/dist/cache/tiered-cache.store.d.ts

@@ -1,19 +0,0 @@
-import type { AnyCacheStore, AsyncCacheStore } from './cache.types';
-/**
- * Composes an ordered list of cache tiers (fastest first, e.g. in-memory L1 →
- * KV L2). Tiers may be sync ({@link CacheStore}) or async ({@link AsyncCacheStore}) —
- * results are awaited uniformly. Reads are read-through: the first tier with a
- * hit wins, and nearer tiers that missed are backfilled. Writes/deletes/clears
- * fan out to all tiers. Always async ({@link AsyncCacheStore}).
- *
- * Runtime-agnostic — the concrete tiers (memory here, KV in `@velajs/cloudflare`)
- * live wherever fits.
- */
-export declare class TieredCacheStore implements AsyncCacheStore {
-    private readonly tiers;
-    constructor(tiers: AnyCacheStore[]);
-    get<T = unknown>(key: string): Promise<T | undefined>;
-    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
-    del(key: string): Promise<void>;
-    clear(): Promise<void>;
-}

package/dist/cache/tiered-cache.store.js

@@ -1,40 +0,0 @@
-/**
- * Composes an ordered list of cache tiers (fastest first, e.g. in-memory L1 →
- * KV L2). Tiers may be sync ({@link CacheStore}) or async ({@link AsyncCacheStore}) —
- * results are awaited uniformly. Reads are read-through: the first tier with a
- * hit wins, and nearer tiers that missed are backfilled. Writes/deletes/clears
- * fan out to all tiers. Always async ({@link AsyncCacheStore}).
- *
- * Runtime-agnostic — the concrete tiers (memory here, KV in `@velajs/cloudflare`)
- * live wherever fits.
- */ export class TieredCacheStore {
-    tiers;
-    constructor(tiers){
-        if (tiers.length === 0) {
-            throw new Error('TieredCacheStore requires at least one tier.');
-        }
-        this.tiers = tiers;
-    }
-    async get(key) {
-        for(let i = 0; i < this.tiers.length; i++){
-            const value = await this.tiers[i].get(key);
-            if (value !== undefined) {
-                // Backfill nearer (faster) tiers that missed.
-                for(let j = 0; j < i; j++){
-                    await this.tiers[j].set(key, value);
-                }
-                return value;
-            }
-        }
-        return undefined;
-    }
-    async set(key, value, ttl) {
-        await Promise.all(this.tiers.map((tier)=>tier.set(key, value, ttl)));
-    }
-    async del(key) {
-        await Promise.all(this.tiers.map((tier)=>tier.del(key)));
-    }
-    async clear() {
-        await Promise.all(this.tiers.map((tier)=>tier.clear()));
-    }
-}

package/dist/config/config.module.d.ts

@@ -1,19 +0,0 @@
-import type { DynamicModule } from '../module/types';
-import type { ConfigModuleOptions } from './config.types';
-declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<ConfigModuleOptions<Record<string, unknown>>, "forRoot", "create", {
-    isGlobal?: boolean;
-}>;
-export declare class ConfigModule extends ConfigurableModuleClass {
-    /**
-     * Preserve (a) per-call generic inference over the flat config record and
-     * (b) the eager-validation contract: `validate` runs at call time so bad
-     * config fails fast, then is stripped so the derived `CONFIG_OPTIONS`
-     * provider is a passthrough (no double validation). `validateSchema` (the
-     * merged-config schema) is deferred to first read — its input needs env.
-     */
-    static forRoot<T extends Record<string, unknown>>(options?: ConfigModuleOptions<T> & {
-        isGlobal?: boolean;
-        key?: string;
-    }): DynamicModule;
-}
-export {};

package/dist/config/config.module.js

@@ -1,98 +0,0 @@
-import { Container } from "../container/container.js";
-import { defineModule } from "../module/define-module.js";
-import { ConfigService } from "./config.service.js";
-import { ConfigStore } from "./config.store.js";
-import { CONFIG_OPTIONS } from "./config.tokens.js";
-/**
- * Carrier for the namespace `asProvider()` KEY providers ONLY. Split out of
- * ConfigModule and marked `lazy: true` so those factories — which inject
- * `CONFIG_ENV`, live per-request on edge runtimes — never run at bootstrap.
- * ConfigModule itself stays EAGER (see below).
- */ let ConfigNamespacesModule = class ConfigNamespacesModule {
-};
-/**
- * Build the lazy sub-module holding one KEY provider per namespace. Its `key`
- * is derived from the owning ConfigModule instance key so multiple ConfigModule
- * instances get distinct sub-module instances (no import-dedup collision).
- */ function namespacesSubModule(load, key) {
-    return {
-        module: ConfigNamespacesModule,
-        key: `config-ns:${key}`,
-        lazy: true,
-        providers: load.map((namespace)=>namespace.asProvider()),
-        exports: load.map((namespace)=>namespace.KEY)
-    };
-}
-// Rebuilt on `defineModule` (the blessed engine — CLAUDE.md: changed modules
-// use it). ConfigModule is EAGER: `ConfigService`, `ConfigStore`, and
-// `CONFIG_OPTIONS` construct at bootstrap, so a `forRootAsync` async
-// `useFactory` resolves in the awaited bootstrap pass and a *synchronous*
-// `app.get(ConfigService)` afterwards returns the cached singleton (no drain).
-//
-// ONLY the namespace `asProvider()` KEY providers are deferred — they move into
-// a LAZY sub-module (`ConfigNamespacesModule`) that ConfigModule imports and
-// re-exports. Their factories inject `CONFIG_ENV` (live per-request on edge
-// runtimes), so construction must not happen at bootstrap. `ConfigStore`
-// resolves each KEY through the container on first `get()`; that first
-// resolution claims + sync-drains the sub-module (namespace factories are
-// synchronous, so the sync seam is safe). `resolveAllInstances` treats the KEY
-// tokens as lazy-only (they belong solely to the lazy sub-module) and skips
-// them at bootstrap.
-const { ConfigurableModuleClass } = defineModule({
-    name: 'Config',
-    setup: ({ OPTIONS, options, key })=>{
-        const load = options.load ?? [];
-        const { validateSchema } = options;
-        return {
-            // Lazy sub-module carries the KEY providers; re-exported below so direct
-            // `@Inject(ns.KEY)` and `ConfigStore`'s container lookup both reach them.
-            imports: load.length > 0 ? [
-                namespacesSubModule(load, key)
-            ] : [],
-            providers: [
-                {
-                    // Flat config record. `validate` is applied here for the async path;
-                    // `forRoot` pre-validates eagerly and strips it (see the override).
-                    provide: CONFIG_OPTIONS,
-                    useFactory: (opts)=>opts.validate ? opts.validate(opts.config ?? {}) : opts.config ?? {},
-                    inject: [
-                        OPTIONS
-                    ]
-                },
-                {
-                    // Factory-provided so the store closes over the namespace list +
-                    // schema; it resolves each namespace's KEY lazily via the container.
-                    provide: ConfigStore,
-                    useFactory: (container, config)=>new ConfigStore(container, config, load, validateSchema),
-                    inject: [
-                        Container,
-                        CONFIG_OPTIONS
-                    ]
-                },
-                ConfigService
-            ],
-            exports: [
-                ConfigService,
-                ConfigStore,
-                CONFIG_OPTIONS,
-                ...load.map((n)=>n.KEY)
-            ]
-        };
-    }
-});
-export class ConfigModule extends ConfigurableModuleClass {
-    /**
-   * Preserve (a) per-call generic inference over the flat config record and
-   * (b) the eager-validation contract: `validate` runs at call time so bad
-   * config fails fast, then is stripped so the derived `CONFIG_OPTIONS`
-   * provider is a passthrough (no double validation). `validateSchema` (the
-   * merged-config schema) is deferred to first read — its input needs env.
-   */ static forRoot(options = {}) {
-        const validatedConfig = options.validate ? options.validate(options.config ?? {}) : options.config;
-        const { validate: _validate, ...rest } = options;
-        return super.forRoot({
-            ...rest,
-            config: validatedConfig
-        });
-    }
-}

package/dist/config/config.service.d.ts

@@ -1,20 +0,0 @@
-import { ConfigStore } from './config.store';
-import type { ConfigPath, ConfigPathValue } from './config.types';
-/**
- * Typed, dot-notation reads over the merged config. Stays a singleton (NestJS
- * parity); delegates to the {@link ConfigStore}. Pass `ConfigType<[...]>` as the
- * generic to type namespaced paths (`cfg.get('database.url')` → `string`).
- */
-export declare class ConfigService<T extends Record<string, unknown> = Record<string, unknown>> {
-    private readonly store;
-    constructor(store: ConfigStore);
-    /** Read a config value; `undefined` when absent, or the supplied default. */
-    get<P extends ConfigPath<T>>(path: P): ConfigPathValue<T, P> | undefined;
-    get<P extends ConfigPath<T>>(path: P, defaultValue: ConfigPathValue<T, P>): ConfigPathValue<T, P>;
-    /** Read a config value; throws when the path is absent. */
-    getOrThrow<P extends ConfigPath<T>>(path: P): ConfigPathValue<T, P>;
-    /** Whether a config path resolves to a defined value. */
-    has<P extends ConfigPath<T>>(path: P): boolean;
-    /** The full merged config object (flat record + resolved namespaces). */
-    getAll(): T;
-}

package/dist/config/config.service.js

@@ -1,43 +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/decorators.js";
-import { ConfigStore } from "./config.store.js";
-export class ConfigService {
-    store;
-    constructor(store){
-        this.store = store;
-    }
-    get(path, defaultValue) {
-        const value = this.store.get(path);
-        return value === undefined ? defaultValue : value;
-    }
-    /** Read a config value; throws when the path is absent. */ getOrThrow(path) {
-        return this.store.getOrThrow(path);
-    }
-    /** Whether a config path resolves to a defined value. */ has(path) {
-        return this.store.has(path);
-    }
-    /** The full merged config object (flat record + resolved namespaces). */ getAll() {
-        return this.store.all();
-    }
-}
-ConfigService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(ConfigStore)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ConfigStore === "undefined" ? Object : ConfigStore
-    ])
-], ConfigService);

package/dist/config/config.store.d.ts

@@ -1,46 +0,0 @@
-import type { Container } from '../container/container';
-import type { ConfigSchema } from './config.types';
-import type { AnyConfigNamespace } from './register-as';
-/**
- * Singleton source of truth for merged configuration.
- *
- * Holds the flat `config` record plus a `namespace → KEY` map. Namespaces are
- * resolved LAZILY — the KEY is pulled from the container on the first read of
- * that namespace and cached — so the store never forces namespace factories to
- * materialize at construction. Resolution uses the synchronous container seam
- * (`resolve`), which stays compatible with lazy modules.
- *
- * The merged shape is `{ ...config, [ns]: value }` — a namespace shadows a flat
- * key of the same name.
- *
- * Constructed via a factory provider in {@link ConfigModule} so it can close
- * over the `load` list and `validateSchema` without extra tokens.
- */
-export declare class ConfigStore {
-    private readonly container;
-    private readonly config;
-    private readonly validateSchema?;
-    private readonly namespaceKeys;
-    private readonly cache;
-    private validated;
-    private validationError;
-    constructor(container: Pick<Container, 'resolve'>, config?: Record<string, unknown>, namespaces?: ReadonlyArray<AnyConfigNamespace>, validateSchema?: ConfigSchema | undefined);
-    /** Read a value by dot-notation path; `undefined` if absent. */
-    get(path: string): unknown;
-    /** Read a value by dot-notation path; throws if absent. */
-    getOrThrow(path: string): unknown;
-    /** Whether a dot-notation path resolves to a defined value. */
-    has(path: string): boolean;
-    /** The full merged config object (flat record + resolved namespaces). */
-    all(): Record<string, unknown>;
-    private read;
-    /** Resolve a namespace's KEY through the container on first use, then cache. */
-    private resolveNamespace;
-    private merged;
-    /**
-     * Validate the merged config once, on first read. Deferred (not at bootstrap)
-     * because the merged shape needs namespace factories — and their env — which
-     * are only available after bootstrap on edge runtimes.
-     */
-    private ensureValidated;
-}