@velajs/vela 1.18.0 → 1.19.1

package/dist/live/live.module.js

@@ -1,87 +0,0 @@
-import { defineModule } from "../index.js";
-import { InMemoryCursorLog } from "./live.cursor.js";
-import { LiveEngine } from "./live.engine.js";
-import { LiveInvalidation, localLive, perAppLiveDriver } from "./live.invalidation.js";
-import { LIVE_CURSOR_LOG, LIVE_DRIVER, LIVE_MODULE_OPTIONS } from "./live.tokens.js";
-import { PresenceResolver, PresenceService } from "./presence.js";
-/**
- * First-party live-query module (tag-based realtime reactivity) — authored,
- * like the queue module, entirely on vela's public API (`live-openness.test.ts`
- * machine-verifies it; the only extra dependency is the shared wire package
- * `@velajs/live-protocol`).
- *
- * ```ts
- * imports: [WebSocketModule.forRoot({}), LiveModule.forRoot({})]
- * ```
- *
- * App code declares `@LiveResolver` classes with `@LiveQuery(name, { tags })`
- * methods; clients subscribe over the `$live` reserved WebSocket event; writes
- * invalidate tags via `LiveInvalidation` (the `@velajs/crud` bridge does it
- * automatically per table). See `LIVE.md` for the wire protocol, delivery
- * guarantees, and the resume story.
- *
- * Deliberately EAGER (like WebSocketModule): the engine self-drives — it
- * claims the `$live` event at bootstrap and receives invalidations from
- * writes that never touch a live token — so the lazy-module contract
- * ("nothing self-drives") rules laziness out.
- */ const { ConfigurableModuleClass } = defineModule({
-    name: 'Live',
-    optionsToken: LIVE_MODULE_OPTIONS,
-    key: (options)=>`live#${options?.driver?.kind ?? 'local'}`,
-    setup: ({ OPTIONS, options })=>({
-            providers: [
-                {
-                    provide: LIVE_CURSOR_LOG,
-                    useFactory: (o)=>o.log ?? new InMemoryCursorLog(),
-                    inject: [
-                        OPTIONS
-                    ]
-                },
-                {
-                    provide: LIVE_DRIVER,
-                    // Wrapped per app: user-supplied drivers are shared config objects
-                    // (the same module bootstraps in the Worker AND in each Durable
-                    // Object), so per-app sink/mode state lives in the wrapper — see
-                    // perAppLiveDriver.
-                    useFactory: (o)=>perAppLiveDriver(o.driver ?? localLive()),
-                    inject: [
-                        OPTIONS
-                    ]
-                },
-                {
-                    provide: PresenceService,
-                    useFactory: (o)=>{
-                        const presence = o.presence;
-                        if (presence === false) return new PresenceService(undefined, false);
-                        return new PresenceService(presence?.ttlMs, true);
-                    },
-                    inject: [
-                        OPTIONS
-                    ]
-                },
-                {
-                    provide: LiveInvalidation,
-                    useFactory: (driver)=>new LiveInvalidation(driver),
-                    inject: [
-                        LIVE_DRIVER
-                    ]
-                },
-                LiveEngine,
-                // The built-in `$presence.roster` resolver. Skipping it is STRUCTURAL
-                // (`presence: false` must be visible at forRoot/forRootAsync call time,
-                // like queue's `queues`); a disabled-at-runtime service still no-ops.
-                ...options?.presence === false ? [] : [
-                    PresenceResolver
-                ]
-            ],
-            exports: [
-                LiveEngine,
-                LiveInvalidation,
-                LIVE_DRIVER,
-                LIVE_CURSOR_LOG,
-                PresenceService
-            ]
-        })
-});
-export class LiveModule extends ConfigurableModuleClass {
-}

package/dist/live/live.tokens.d.ts

@@ -1,9 +0,0 @@
-import { InjectionToken } from '../index';
-import type { CursorLog, LiveDriver, LiveModuleOptions } from './live.types';
-export declare const LIVE_RESOLVER_METADATA = "vela:live:resolver";
-export declare const LIVE_QUERY_METADATA = "vela:live:query";
-/** The invalidation driver in effect for a `LiveModule` instance (`localLive()` by default). */
-export declare const LIVE_DRIVER: InjectionToken<LiveDriver>;
-/** The ordered tag-invalidation log backing cursors/epochs for this log scope. */
-export declare const LIVE_CURSOR_LOG: InjectionToken<CursorLog>;
-export declare const LIVE_MODULE_OPTIONS: InjectionToken<LiveModuleOptions>;

package/dist/live/live.tokens.js

@@ -1,8 +0,0 @@
-import { InjectionToken } from "../index.js";
-// Free-form metadata keys — same string-token convention as the queue module.
-export const LIVE_RESOLVER_METADATA = 'vela:live:resolver';
-export const LIVE_QUERY_METADATA = 'vela:live:query';
-/** The invalidation driver in effect for a `LiveModule` instance (`localLive()` by default). */ export const LIVE_DRIVER = new InjectionToken('vela:live:driver');
-/** The ordered tag-invalidation log backing cursors/epochs for this log scope. */ export const LIVE_CURSOR_LOG = new InjectionToken('vela:live:cursor-log');
-// forRoot() options carrier.
-export const LIVE_MODULE_OPTIONS = new InjectionToken('LIVE_MODULE_OPTIONS');

package/dist/live/live.types.d.ts

@@ -1,138 +0,0 @@
-import type { WsClient } from '../index';
-/**
- * Identity captured at subscribe time and replayed into every re-run of the
- * subscription's query — never re-read from the client afterwards. Free-form;
- * `expiresAt` (epoch ms) is the one recognized field: a lapsed identity drops
- * the socket before it receives another scoped push (outbound enforcement —
- * a passive subscriber never trips inbound checks).
- */
-export interface LiveIdentity {
-    [key: string]: unknown;
-    expiresAt?: number;
-}
-/** Second positional argument every `@LiveQuery` handler receives. */
-export interface LiveQueryContext {
-    identity?: LiveIdentity;
-    /** The subscribed connection's id. */
-    clientId: string;
-    /** Rooms the connection was in when it subscribed. */
-    rooms: string[];
-}
-export interface LiveQueryOptions<A = unknown> {
-    /**
-     * Dependency tags this query's result is built from — the invalidation
-     * contract. Static for the common case; the function form derives
-     * per-entity tags from the (parsed) subscribe args. Writes invalidate tags
-     * via `LiveInvalidation.invalidate()` (the CRUD bridge does it
-     * automatically with `crud:<table>` tags).
-     */
-    tags: string[] | ((args: A) => string[]);
-    /** Key field for incremental list deltas (default `'id'`). */
-    key?: string;
-    /**
-     * Args validator, run ONCE at subscribe (a zod schema's `.parse` slots in
-     * directly). A throw rejects the subscription with a `bad_args` error frame.
-     */
-    parse?: (args: unknown) => A;
-}
-/** One `@LiveQuery` declaration on a `@LiveResolver` class. */
-export interface LiveQueryMetadata {
-    name: string;
-    methodName: string | symbol;
-    options: LiveQueryOptions;
-}
-/** Class-level marker meta written by `@LiveResolver()`. */
-export interface LiveResolverMetadata {
-}
-/** A position in this log scope's ordered invalidation log. */
-export interface CommitStamp {
-    cursor: number;
-    epoch: string;
-}
-/**
- * Resume verdict for a reconnecting subscription:
- * - `'resume'` — nothing the subscription depends on changed while away; keep
- *   the client's cached value and just advance its cursor.
- * - `'rerun'` — a relevant tag was invalidated in the gap; re-run and snapshot.
- * - `'snapshot'` — the gap cannot be reasoned about (epoch fork, trimmed log,
- *   rollback); re-run and snapshot.
- */
-export type ResumeVerdict = 'resume' | 'rerun' | 'snapshot';
-/**
- * The ordered tag-invalidation log for ONE log scope (this process on
- * node/bun/deno; one Durable Object on Cloudflare). Cursor = monotonic
- * sequence; epoch = timeline token rolled whenever monotonicity can no longer
- * be guaranteed (process restart, DO reset).
- */
-export interface CursorLog {
-    append(tags: string[]): CommitStamp | Promise<CommitStamp>;
-    current(): CommitStamp | Promise<CommitStamp>;
-    evaluateResume(sinceCursor: number, sinceEpoch: string, subscriptionTags: string[]): ResumeVerdict | Promise<ResumeVerdict>;
-}
-/** A tag invalidation crossing the driver seam. `room` addresses the log scope holding the subscribers (advisory for local delivery). */
-export interface InvalidationCommand {
-    room?: string;
-    tags: string[];
-    /** Origin instance id — lets pub/sub drivers drop their own echo. */
-    origin?: string;
-}
-/** What a driver delivers invalidations INTO — the live engine of one log scope. */
-export interface LiveInvalidationSink {
-    applyInvalidation(cmd: InvalidationCommand): CommitStamp | Promise<CommitStamp>;
-}
-/**
- * Cross-boundary invalidation transport — the live sibling of the WebSocket
- * `SyncDriver`, carrying TAGS (re-run instructions) instead of pre-serialized
- * frames. `localLive()` is the in-core single-scope default; platform packages
- * (`durableObjectLive()` in @velajs/cloudflare, `redisLive()` in
- * websocket-node) implement it out-of-core. `dispatch` returns the commit
- * stamp of the targeted log scope when the driver can observe it.
- */
-export interface LiveDriver {
-    readonly kind: string;
-    bind(sink: LiveInvalidationSink): void;
-    dispatch(cmd: InvalidationCommand): CommitStamp | undefined | Promise<CommitStamp | undefined>;
-    start?(): void | Promise<void>;
-    stop?(): void | Promise<void>;
-}
-/** One live subscription as tracked by the engine (and persisted by transports that survive eviction). */
-export interface SubscriptionRecord {
-    sub: string;
-    query: string;
-    args: unknown;
-    /** Frozen at subscribe from the (parsed) args. */
-    tags: string[];
-    /** Delta key field (subscribe-frame override wins over the handler option). */
-    key?: string;
-    identity?: LiveIdentity;
-    /**
-     * The last result this subscription confirmed on the wire (the delta diff
-     * baseline). `undefined` after a cursor-resume: the server never re-ran the
-     * query, so the next relevant change sends a full snapshot.
-     */
-    lastJson?: string;
-    lastCursor?: number;
-}
-export interface LivePresenceOptions {
-    /** Roster entries older than this are filtered at read time (default 30_000 ms). */
-    ttlMs?: number;
-}
-export interface LiveModuleOptions {
-    /** Cross-boundary invalidation driver. Defaults to `localLive()`. */
-    driver?: LiveDriver;
-    /** Ordered invalidation log. Defaults to the in-memory per-process log. */
-    log?: CursorLog;
-    /**
-     * Identity capture at subscribe. Default: a shallow copy of `client.data`
-     * (whatever the app's upgrade/`handleConnection` auth stamped there), or
-     * `undefined` when empty.
-     */
-    identity?: (client: WsClient) => LiveIdentity | undefined;
-    /** Presence preset configuration; `false` disables the built-in resolver. */
-    presence?: LivePresenceOptions | false;
-}
-/** Meta carried by the `'live'` entrypoint (transports reach the engine through it). */
-export interface LiveEntrypointMeta {
-    /** The engine — typed loosely to avoid a circular type edge; cast to `LiveEngine`. */
-    engine: unknown;
-}

package/dist/live/live.types.js

@@ -1 +0,0 @@
-/** Meta carried by the `'live'` entrypoint (transports reach the engine through it). */ export { };

package/dist/live/presence.d.ts

@@ -1,44 +0,0 @@
-/** The invalidation tag for one room's roster. `$`-prefixed: never collides with app tags. */
-export declare const presenceTag: (room: string) => string;
-/** The built-in roster query name (`useLiveQuery`-able like any app query). */
-export declare const PRESENCE_ROSTER_QUERY = "$presence.roster";
-/** One present connection as returned by the roster query. Keyed by `id` so list deltas apply. */
-export interface PresenceMember {
-    /** The connection id that heartbeats this membership. */
-    id: string;
-    meta?: unknown;
-    lastSeen: number;
-}
-/**
- * The presence preset's server half. Heartbeats arrive as `{ t: 'presence' }`
- * frames on the live socket (routed here by the engine); the roster is a
- * built-in live query invalidated per room. Departure is immediate: the WS
- * close hook reaps the member without waiting out the TTL. Staleness (an
- * ungraceful drop the transport never noticed) is filtered AT READ TIME —
- * no timers, per the edge rules (`setInterval` is forbidden).
- *
- * Scope note: the roster lives in this log scope (one process on node, one
- * room-DO on Cloudflare — where it is exactly the room's roster).
- */
-export declare class PresenceService {
-    private readonly ttlMs;
-    readonly enabled: boolean;
-    private readonly rooms;
-    private readonly roomsByClient;
-    private invalidator?;
-    constructor(ttlMs?: number, enabled?: boolean);
-    /** Wired by the engine so beats/reaps invalidate through the live driver. */
-    bindInvalidator(invalidator: (tags: string[]) => void): void;
-    beat(room: string, clientId: string, meta?: unknown): void;
-    /** Immediate departure on socket close — peers see it without a TTL wait. */
-    reap(clientId: string): void;
-    roster(room: string): PresenceMember[];
-}
-/** The built-in resolver backing `$presence.roster`. Registered by `LiveModule` unless presence is disabled. */
-export declare class PresenceResolver {
-    private readonly presence;
-    constructor(presence: PresenceService);
-    roster(args: {
-        room: string;
-    }): PresenceMember[];
-}

package/dist/live/presence.js

@@ -1,130 +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 { Inject, Injectable } from "../index.js";
-import { LiveQuery, LiveResolver } from "./live.decorators.js";
-/** The invalidation tag for one room's roster. `$`-prefixed: never collides with app tags. */ export const presenceTag = (room)=>`$presence:${room}`;
-/** The built-in roster query name (`useLiveQuery`-able like any app query). */ export const PRESENCE_ROSTER_QUERY = '$presence.roster';
-/**
- * The presence preset's server half. Heartbeats arrive as `{ t: 'presence' }`
- * frames on the live socket (routed here by the engine); the roster is a
- * built-in live query invalidated per room. Departure is immediate: the WS
- * close hook reaps the member without waiting out the TTL. Staleness (an
- * ungraceful drop the transport never noticed) is filtered AT READ TIME —
- * no timers, per the edge rules (`setInterval` is forbidden).
- *
- * Scope note: the roster lives in this log scope (one process on node, one
- * room-DO on Cloudflare — where it is exactly the room's roster).
- */ export class PresenceService {
-    ttlMs;
-    enabled;
-    rooms = new Map();
-    roomsByClient = new Map();
-    invalidator;
-    constructor(ttlMs = 30_000, enabled = true){
-        this.ttlMs = ttlMs;
-        this.enabled = enabled;
-    }
-    /** Wired by the engine so beats/reaps invalidate through the live driver. */ bindInvalidator(invalidator) {
-        this.invalidator = invalidator;
-    }
-    beat(room, clientId, meta) {
-        if (!this.enabled) return;
-        let state = this.rooms.get(room);
-        if (!state) {
-            state = {
-                members: new Map()
-            };
-            this.rooms.set(room, state);
-        }
-        state.members.set(clientId, {
-            meta,
-            lastSeen: Date.now()
-        });
-        let joined = this.roomsByClient.get(clientId);
-        if (!joined) {
-            joined = new Set();
-            this.roomsByClient.set(clientId, joined);
-        }
-        joined.add(room);
-        this.invalidator?.([
-            presenceTag(room)
-        ]);
-    }
-    /** Immediate departure on socket close — peers see it without a TTL wait. */ reap(clientId) {
-        const joined = this.roomsByClient.get(clientId);
-        if (!joined) return;
-        this.roomsByClient.delete(clientId);
-        for (const room of joined){
-            const state = this.rooms.get(room);
-            if (!state) continue;
-            state.members.delete(clientId);
-            if (state.members.size === 0) this.rooms.delete(room);
-            this.invalidator?.([
-                presenceTag(room)
-            ]);
-        }
-    }
-    roster(room) {
-        const state = this.rooms.get(room);
-        if (!state) return [];
-        const oldestAlive = Date.now() - this.ttlMs;
-        return [
-            ...state.members.entries()
-        ].filter(([, member])=>member.lastSeen >= oldestAlive).map(([id, member])=>({
-                id,
-                meta: member.meta,
-                lastSeen: member.lastSeen
-            }));
-    }
-}
-export class PresenceResolver {
-    presence;
-    constructor(presence){
-        this.presence = presence;
-    }
-    roster(args) {
-        return this.presence.roster(args.room);
-    }
-}
-_ts_decorate([
-    LiveQuery(PRESENCE_ROSTER_QUERY, {
-        tags: (args)=>[
-                presenceTag(args.room)
-            ],
-        parse: (args)=>{
-            const room = args?.room;
-            if (typeof room !== 'string' || room.length === 0) {
-                throw new Error("presence roster args require a non-empty 'room' string");
-            }
-            return {
-                room
-            };
-        }
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object
-    ]),
-    _ts_metadata("design:returntype", Array)
-], PresenceResolver.prototype, "roster", null);
-PresenceResolver = _ts_decorate([
-    LiveResolver(),
-    Injectable(),
-    _ts_param(0, Inject(PresenceService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof PresenceService === "undefined" ? Object : PresenceService
-    ])
-], PresenceResolver);

package/dist/metadata.d.ts

@@ -1,10 +0,0 @@
-declare global {
-    namespace Reflect {
-        function defineMetadata(key: string, value: unknown, target: object, propertyKey?: string | symbol): void;
-        function getMetadata(key: string, target: object, propertyKey?: string | symbol): unknown;
-        function getOwnMetadata(key: string, target: object, propertyKey?: string | symbol): unknown;
-        function metadata(key: string, value: unknown): (target: object, propertyKey?: string | symbol) => void;
-    }
-}
-export declare function defineMetadata(key: string, value: unknown, target: object, propertyKey?: string | symbol): void;
-export declare function getMetadata<T = unknown>(key: string, target: object, propertyKey?: string | symbol): T | undefined;

package/dist/metadata.js

@@ -1,20 +0,0 @@
-// Single funnel: every Reflect.* metadata write/read routes into MetadataRegistry.
-// SWC emits Reflect.metadata('design:paramtypes', ...) calls in compiled code;
-// the polyfill catches those and parks them in the registry alongside vela's typed slots.
-import { MetadataRegistry } from "./registry/metadata.registry.js";
-export function defineMetadata(key, value, target, propertyKey) {
-    MetadataRegistry.setReflectMetadata(target, key, value, propertyKey);
-}
-export function getMetadata(key, target, propertyKey) {
-    return MetadataRegistry.getReflectMetadata(target, key, propertyKey);
-}
-if (typeof Reflect.defineMetadata !== 'function') {
-    Reflect.defineMetadata = defineMetadata;
-    Reflect.getMetadata = getMetadata;
-    Reflect.getOwnMetadata = getMetadata;
-    Reflect.metadata = (key, value)=>{
-        return (target, propertyKey)=>{
-            defineMetadata(key, value, target, propertyKey);
-        };
-    };
-}

package/dist/module/configurable-module.builder.d.ts

@@ -1,56 +0,0 @@
-import type { DynamicModule } from '../registry/types';
-import type { ConfigurableModuleBuilderOptions, ConfigurableModuleExtras, ConfigurableModuleExtrasTransform, ConfigurableModuleHost, DefineConfigurableModuleSpec } from './configurable-module.types';
-/**
- * Blessed key-derivation helper for hand-written `forRoot` statics: the one
- * documented way to derive a `DynamicModule.key` from an options bag so
- * identical configurations dedup (HMR-idempotent) and distinct ones coexist.
- * Alias of {@link stableHash} with a module-authoring name.
- */
-export declare const moduleKey: (options: unknown) => string;
-/**
- * NestJS-parity builder that generates `forRoot`/`forRootAsync` (and `key`,
- * `global`, factory-param inference) from a tiny spec — so a module is just its
- * tokens + options type + service + a `@Module({...})` bag, while vela keeps its
- * encapsulation (`exports`/visibility) and multi-instance `key` dedup.
- *
- * Since 1.11 this is a thin adapter over {@link defineModule} — the single
- * authoring engine. Prefer `defineModule` for new modules: it additionally
- * supports contributions (providers/controllers/imports/exports/global
- * components) computed as functions of the options.
- *
- * @example
- * ```ts
- * const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } =
- *   new ConfigurableModuleBuilder<FooOptions>({ moduleName: 'Foo' }).build();
- *
- * @Module({
- *   providers: [FooService], // derived providers inject MODULE_OPTIONS_TOKEN
- *   exports: [FooService],
- * })
- * export class FooModule extends ConfigurableModuleClass {}
- * ```
- */
-export declare class ConfigurableModuleBuilder<Opts, MethodKey extends string = 'forRoot', FactoryMethodKey extends string = 'create', Extras extends ConfigurableModuleExtras = {
-    isGlobal?: boolean;
-}> {
-    private readonly options;
-    private classMethodName;
-    private factoryMethodName;
-    private extrasDefaults;
-    private extrasTransform;
-    constructor(options?: ConfigurableModuleBuilderOptions);
-    /** Declare extra call-site keys (e.g. `isGlobal`) + how they reshape the definition. */
-    setExtras<NewExtras extends ConfigurableModuleExtras>(defaults: NewExtras, transform: ConfigurableModuleExtrasTransform<NewExtras>): ConfigurableModuleBuilder<Opts, MethodKey, FactoryMethodKey, NewExtras>;
-    /** Rename the sync static (default `forRoot`); the async static becomes `<name>Async`. */
-    setClassMethodName<NewMethodKey extends string>(name: NewMethodKey): ConfigurableModuleBuilder<Opts, NewMethodKey, FactoryMethodKey, Extras>;
-    /** Rename the method a `useClass`/`useExisting` options factory must implement (default `create`). */
-    setFactoryMethodName<NewFactoryMethodKey extends string>(name: NewFactoryMethodKey): ConfigurableModuleBuilder<Opts, MethodKey, NewFactoryMethodKey, Extras>;
-    build(): ConfigurableModuleHost<Opts, MethodKey, FactoryMethodKey, Extras>;
-}
-/**
- * Lower-level engine for cases a class-mixin can't express — chiefly a
- * runtime-generated module class whose providers depend on a call-time arg
- * (Cloudflare binding modules). Returns an object with a single static named by
- * `spec.methodName` (default `forRoot`).
- */
-export declare function defineConfigurableModule<Args>(spec: DefineConfigurableModuleSpec<Args>): Record<string, (args: Args) => DynamicModule>;

package/dist/module/configurable-module.builder.js

@@ -1,84 +0,0 @@
-import { defineModule } from "./define-module.js";
-import { stableHash } from "./stable-hash.js";
-/**
- * Blessed key-derivation helper for hand-written `forRoot` statics: the one
- * documented way to derive a `DynamicModule.key` from an options bag so
- * identical configurations dedup (HMR-idempotent) and distinct ones coexist.
- * Alias of {@link stableHash} with a module-authoring name.
- */ export const moduleKey = stableHash;
-/**
- * NestJS-parity builder that generates `forRoot`/`forRootAsync` (and `key`,
- * `global`, factory-param inference) from a tiny spec — so a module is just its
- * tokens + options type + service + a `@Module({...})` bag, while vela keeps its
- * encapsulation (`exports`/visibility) and multi-instance `key` dedup.
- *
- * Since 1.11 this is a thin adapter over {@link defineModule} — the single
- * authoring engine. Prefer `defineModule` for new modules: it additionally
- * supports contributions (providers/controllers/imports/exports/global
- * components) computed as functions of the options.
- *
- * @example
- * ```ts
- * const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } =
- *   new ConfigurableModuleBuilder<FooOptions>({ moduleName: 'Foo' }).build();
- *
- * @Module({
- *   providers: [FooService], // derived providers inject MODULE_OPTIONS_TOKEN
- *   exports: [FooService],
- * })
- * export class FooModule extends ConfigurableModuleClass {}
- * ```
- */ export class ConfigurableModuleBuilder {
-    options;
-    classMethodName = 'forRoot';
-    factoryMethodName = 'create';
-    extrasDefaults;
-    extrasTransform;
-    constructor(options = {}){
-        this.options = options;
-    }
-    /** Declare extra call-site keys (e.g. `isGlobal`) + how they reshape the definition. */ setExtras(defaults, transform) {
-        this.extrasDefaults = defaults;
-        this.extrasTransform = transform;
-        return this;
-    }
-    /** Rename the sync static (default `forRoot`); the async static becomes `<name>Async`. */ setClassMethodName(name) {
-        this.classMethodName = name;
-        return this;
-    }
-    /** Rename the method a `useClass`/`useExisting` options factory must implement (default `create`). */ setFactoryMethodName(name) {
-        this.factoryMethodName = name;
-        return this;
-    }
-    build() {
-        return defineModule({
-            name: this.options.moduleName ?? 'ConfigurableModule',
-            optionsToken: this.options.optionsInjectionToken,
-            extras: this.extrasDefaults,
-            transform: this.extrasTransform,
-            methodName: this.classMethodName,
-            factoryMethodName: this.factoryMethodName
-        });
-    }
-}
-/**
- * Lower-level engine for cases a class-mixin can't express — chiefly a
- * runtime-generated module class whose providers depend on a call-time arg
- * (Cloudflare binding modules). Returns an object with a single static named by
- * `spec.methodName` (default `forRoot`).
- */ export function defineConfigurableModule(spec) {
-    const methodName = spec.methodName ?? 'forRoot';
-    return {
-        [methodName] (args) {
-            const definition = {
-                module: spec.module,
-                key: spec.keyFrom(args),
-                providers: spec.providers(args)
-            };
-            if (spec.imports) definition.imports = spec.imports(args);
-            if (spec.exports) definition.exports = spec.exports;
-            if (spec.global) definition.global = true;
-            return definition;
-        }
-    };
-}