@velajs/vela 1.18.0 → 1.19.1

package/dist/pipeline/scoped-components.d.ts

@@ -1,26 +0,0 @@
-import type { Container } from '../container/container';
-import type { ComponentType, Constructor } from '../registry/types';
-import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from './types';
-export interface ResolvedComponentMap {
-    guard: CanActivate;
-    pipe: PipeTransform;
-    interceptor: NestInterceptor;
-    filter: ExceptionFilter;
-    middleware: NestMiddleware;
-}
-/**
- * Public seam for custom dispatchers: the `@UseGuards`/`@UsePipes`/
- * `@UseInterceptors`/`@UseFilters` components scoped to a handler (class-level
- * then method-level, declaration order), resolved to instances through the
- * given container (classes constructed with DI; instances passed through).
- *
- * Order is preserved exactly as declared — conventions stay with the CALLER:
- * filters run closest-first, so dispatchers reverse them
- * (`resolveScopedComponents('filter', ...).reverse()`), and app-wide `APP_*`
- * components are a separate, transport-specific decision.
- *
- * Promoted to the public API by the QueueModule work (the "openness proof"):
- * it was the one capability custom entrypoint dispatchers needed that only
- * the internal `ComponentManager` provided.
- */
-export declare function resolveScopedComponents<T extends ComponentType>(type: T, targetClass: Constructor, methodName: string | symbol, container: Container): ResolvedComponentMap[T][];

package/dist/pipeline/scoped-components.js

@@ -1,27 +0,0 @@
-import { ComponentManager } from "./component.manager.js";
-const RESOLVERS = {
-    guard: ComponentManager.resolveGuards.bind(ComponentManager),
-    pipe: ComponentManager.resolvePipes.bind(ComponentManager),
-    interceptor: ComponentManager.resolveInterceptors.bind(ComponentManager),
-    filter: ComponentManager.resolveFilters.bind(ComponentManager),
-    middleware: ComponentManager.resolveMiddleware.bind(ComponentManager)
-};
-/**
- * Public seam for custom dispatchers: the `@UseGuards`/`@UsePipes`/
- * `@UseInterceptors`/`@UseFilters` components scoped to a handler (class-level
- * then method-level, declaration order), resolved to instances through the
- * given container (classes constructed with DI; instances passed through).
- *
- * Order is preserved exactly as declared — conventions stay with the CALLER:
- * filters run closest-first, so dispatchers reverse them
- * (`resolveScopedComponents('filter', ...).reverse()`), and app-wide `APP_*`
- * components are a separate, transport-specific decision.
- *
- * Promoted to the public API by the QueueModule work (the "openness proof"):
- * it was the one capability custom entrypoint dispatchers needed that only
- * the internal `ComponentManager` provided.
- */ export function resolveScopedComponents(type, targetClass, methodName, container) {
-    const scoped = ComponentManager.getScopedComponents(type, targetClass, methodName);
-    const resolve = RESOLVERS[type];
-    return resolve(scoped, container);
-}

package/dist/pipeline/tokens.d.ts

@@ -1,33 +0,0 @@
-import { InjectionToken } from '../container/types';
-import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from './types';
-/**
- * Register global guards via module providers instead of app.useGlobalGuards().
- *
- * @example
- * ```ts
- * @Module({
- *   providers: [
- *     AuthGuard,
- *     { provide: APP_GUARD, useClass: AuthGuard },
- *   ],
- * })
- * class AppModule {}
- * ```
- */
-export declare const APP_GUARD: InjectionToken<CanActivate>;
-/**
- * Register global pipes via module providers.
- */
-export declare const APP_PIPE: InjectionToken<PipeTransform<unknown, unknown>>;
-/**
- * Register global interceptors via module providers.
- */
-export declare const APP_INTERCEPTOR: InjectionToken<NestInterceptor>;
-/**
- * Register global filters via module providers.
- */
-export declare const APP_FILTER: InjectionToken<ExceptionFilter<unknown>>;
-/**
- * Register global middleware via module providers.
- */
-export declare const APP_MIDDLEWARE: InjectionToken<NestMiddleware>;

package/dist/pipeline/tokens.js

@@ -1,27 +0,0 @@
-import { InjectionToken } from "../container/types.js";
-/**
- * Register global guards via module providers instead of app.useGlobalGuards().
- *
- * @example
- * ```ts
- * @Module({
- *   providers: [
- *     AuthGuard,
- *     { provide: APP_GUARD, useClass: AuthGuard },
- *   ],
- * })
- * class AppModule {}
- * ```
- */ export const APP_GUARD = new InjectionToken('APP_GUARD');
-/**
- * Register global pipes via module providers.
- */ export const APP_PIPE = new InjectionToken('APP_PIPE');
-/**
- * Register global interceptors via module providers.
- */ export const APP_INTERCEPTOR = new InjectionToken('APP_INTERCEPTOR');
-/**
- * Register global filters via module providers.
- */ export const APP_FILTER = new InjectionToken('APP_FILTER');
-/**
- * Register global middleware via module providers.
- */ export const APP_MIDDLEWARE = new InjectionToken('APP_MIDDLEWARE');

package/dist/pipeline/types.d.ts

@@ -1,64 +0,0 @@
-import type { Context } from 'hono';
-import type { Type } from '../container/types';
-/**
- * HTTP-specific arguments host returned by `ExecutionContext.switchToHttp()`.
- * In Vela/Hono, the `Context` object holds both request and response state.
- *
- * - `getRequest()` — the Web `Request` object
- * - `getResponse()` — the Hono `Context` (use `c.header()`, `c.setCookie()`, etc.)
- */
-export interface HttpArgumentsHost {
-    getRequest<T = Request>(): T;
-    getResponse<T = Context>(): T;
-}
-/**
- * WebSocket-specific arguments host returned by `ExecutionContext.switchToWs()`.
- * Populated by `@velajs/vela/websocket` when a gateway message is dispatched.
- *
- * - `getClient()` — the connected socket (`WsClient`)
- * - `getData()` — the inbound message payload (the envelope's `data`)
- * - `getPattern()` — the subscribed event name that matched
- */
-export interface WsArgumentsHost {
-    getClient<T = unknown>(): T;
-    getData<T = unknown>(): T;
-    getPattern<T = string>(): T;
-}
-/** The transport a component is executing under. `'http'` for routes, `'ws'` for gateway messages. */
-export type ContextType = 'http' | 'ws';
-export interface ExecutionContext {
-    getType<T extends string = ContextType>(): T;
-    getClass(): Type;
-    getHandler(): string | symbol;
-    /** Returns the Hono `Context` directly. Throws on a WebSocket context. */
-    getContext<T = Context>(): T;
-    /** Shorthand for `switchToHttp().getRequest()` — returns the Web `Request`. Throws on a WebSocket context. */
-    getRequest(): Request;
-    /** Switch to the HTTP arguments host. Throws on a WebSocket context. */
-    switchToHttp(): HttpArgumentsHost;
-    /** Switch to the WebSocket arguments host. Throws on an HTTP context. */
-    switchToWs(): WsArgumentsHost;
-}
-export interface CanActivate {
-    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
-}
-export interface CallHandler {
-    handle(): Promise<unknown>;
-}
-export interface NestInterceptor {
-    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
-}
-export interface ArgumentMetadata {
-    type: string;
-    metatype?: Type;
-    data?: string;
-}
-export interface PipeTransform<T = unknown, R = unknown> {
-    transform(value: T, metadata: ArgumentMetadata): R | Promise<R>;
-}
-export interface ExceptionFilter<T = unknown> {
-    catch(exception: T, context: ExecutionContext): unknown | Promise<unknown>;
-}
-export interface NestMiddleware {
-    use(c: import('hono').Context, next: import('hono').Next): Promise<Response | void>;
-}

package/dist/pipeline/types.js

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

package/dist/plugin/plugin.d.ts

@@ -1,31 +0,0 @@
-import { InjectionToken } from '../container/types';
-import type { Type } from '../container/types';
-import type { DynamicModule } from '../registry/types';
-export interface Plugin {
-    id: string;
-    version: string;
-    module: Type | DynamicModule;
-    dependsOn?: string[];
-    metadata?: Record<string, unknown>;
-}
-/**
- * Freeze and validate a plugin manifest. Returns the same object so it can
- * be used in `composePlugins([definePlugin(...), ...])`.
- */
-export declare function definePlugin(plugin: Plugin): Plugin;
-export declare class PluginRegistry {
-    private byId;
-    constructor(plugins: readonly Plugin[]);
-    list(): Plugin[];
-    get(id: string): Plugin | undefined;
-    dependents(id: string): Plugin[];
-}
-export declare const PLUGIN_REGISTRY_TOKEN: InjectionToken<PluginRegistry>;
-export declare class PluginRootModule {
-}
-/**
- * Compose a list of plugins into a single dynamic module that imports each
- * plugin's module in dependency order, registers a `PluginRegistry`, and
- * exposes it globally so any plugin can introspect peers.
- */
-export declare function composePlugins(plugins: readonly Plugin[]): DynamicModule;

package/dist/plugin/plugin.js

@@ -1,111 +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 { InjectionToken } from "../container/types.js";
-import { Module } from "../module/decorators.js";
-/**
- * Freeze and validate a plugin manifest. Returns the same object so it can
- * be used in `composePlugins([definePlugin(...), ...])`.
- */ export function definePlugin(plugin) {
-    if (!plugin.id) throw new Error('Plugin requires an id');
-    if (!plugin.version) throw new Error('Plugin requires a version');
-    if (!plugin.module) throw new Error('Plugin requires a module');
-    return Object.freeze({
-        ...plugin
-    });
-}
-export class PluginRegistry {
-    byId;
-    constructor(plugins){
-        this.byId = new Map();
-        for (const p of plugins){
-            if (this.byId.has(p.id)) {
-                throw new Error(`Duplicate plugin id: '${p.id}'`);
-            }
-            this.byId.set(p.id, p);
-        }
-    }
-    list() {
-        return [
-            ...this.byId.values()
-        ];
-    }
-    get(id) {
-        return this.byId.get(id);
-    }
-    dependents(id) {
-        return this.list().filter((p)=>p.dependsOn?.includes(id) ?? false);
-    }
-}
-export const PLUGIN_REGISTRY_TOKEN = new InjectionToken('PLUGIN_REGISTRY');
-export class PluginRootModule {
-}
-PluginRootModule = _ts_decorate([
-    Module({})
-], PluginRootModule);
-/**
- * Topologically sort plugins so each plugin's dependencies appear first.
- * Throws on missing dependencies and cycles.
- */ function topologicalSort(plugins) {
-    const byId = new Map();
-    for (const p of plugins){
-        if (byId.has(p.id)) {
-            throw new Error(`Duplicate plugin id: '${p.id}'`);
-        }
-        byId.set(p.id, p);
-    }
-    const result = [];
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (p, path)=>{
-        if (visited.has(p.id)) return;
-        if (visiting.has(p.id)) {
-            const cycle = [
-                ...path,
-                p.id
-            ].join(' -> ');
-            throw new Error(`Plugin cycle detected: ${cycle}`);
-        }
-        visiting.add(p.id);
-        for (const depId of p.dependsOn ?? []){
-            const dep = byId.get(depId);
-            if (!dep) {
-                throw new Error(`Plugin '${p.id}' depends on missing plugin '${depId}'`);
-            }
-            visit(dep, [
-                ...path,
-                p.id
-            ]);
-        }
-        visiting.delete(p.id);
-        visited.add(p.id);
-        result.push(p);
-    };
-    for (const p of plugins)visit(p, []);
-    return result;
-}
-/**
- * Compose a list of plugins into a single dynamic module that imports each
- * plugin's module in dependency order, registers a `PluginRegistry`, and
- * exposes it globally so any plugin can introspect peers.
- */ export function composePlugins(plugins) {
-    const sorted = topologicalSort(plugins);
-    const registry = new PluginRegistry(sorted);
-    return {
-        module: PluginRootModule,
-        imports: sorted.map((p)=>p.module),
-        providers: [
-            {
-                provide: PLUGIN_REGISTRY_TOKEN,
-                useValue: registry
-            }
-        ],
-        exports: [
-            PLUGIN_REGISTRY_TOKEN
-        ],
-        global: true
-    };
-}

package/dist/queue/inline.driver.d.ts

@@ -1,30 +0,0 @@
-import type { QueueDriver } from './queue.types';
-export interface InlineQueueOptions {
-    /**
-     * `immediate` (default): deliver on a microtask after `enqueue` resolves —
-     * `add()` resolving does NOT mean the job was handled. Handler errors are
-     * routed to the binding's error hook (container diagnostics), never thrown
-     * into the detached microtask.
-     *
-     * `manual`: buffer until `flush()` — deterministic delivery for tests.
-     */
-    mode?: 'immediate' | 'manual';
-}
-export interface InlineQueueDriver extends QueueDriver {
-    /**
-     * Deliver everything buffered (manual mode; also drains jobs enqueued
-     * before the driver was bound). Resolves with the delivered count; rejects
-     * with an `AggregateError` after attempting ALL buffered jobs if any
-     * handler error went unclaimed — the awaiter exists here, so the
-     * platform-retry rethrow contract is meaningful.
-     */
-    flush(): Promise<number>;
-    /** Jobs currently buffered (unbound immediate + all manual). */
-    readonly size: number;
-}
-/**
- * In-process driver for dev, tests, and single-isolate apps. Edge-pure: no
- * timers — `immediate` mode uses `queueMicrotask`. `delayMs` is not
- * supported (warns once through the bound error hook's diagnostics side).
- */
-export declare function inline(options?: InlineQueueOptions): InlineQueueDriver;

package/dist/queue/inline.driver.js

@@ -1,58 +0,0 @@
-/**
- * In-process driver for dev, tests, and single-isolate apps. Edge-pure: no
- * timers — `immediate` mode uses `queueMicrotask`. `delayMs` is not
- * supported (warns once through the bound error hook's diagnostics side).
- */ export function inline(options = {}) {
-    const mode = options.mode ?? 'immediate';
-    const buffer = [];
-    let dispatch;
-    let onError;
-    let warnedDelay = false;
-    const deliverDetached = (job)=>{
-        queueMicrotask(()=>{
-            void dispatch(job).catch((error)=>onError?.(error, job));
-        });
-    };
-    return {
-        kind: 'inline',
-        get size () {
-            return buffer.length;
-        },
-        async enqueue (job, addOptions) {
-            if (addOptions?.delayMs !== undefined && !warnedDelay) {
-                warnedDelay = true;
-                console.warn(`[vela] inline() queue driver does not support delayMs — job '${job.name}' delivers without delay.`);
-            }
-            if (mode === 'manual' || !dispatch) {
-                buffer.push(job);
-                return;
-            }
-            deliverDetached(job);
-        },
-        bind (fn, hooks) {
-            dispatch = fn;
-            onError = hooks?.onError;
-            if (mode === 'immediate' && buffer.length > 0) {
-                for (const job of buffer.splice(0))deliverDetached(job);
-            }
-        },
-        async flush () {
-            if (!dispatch) return 0;
-            const jobs = buffer.splice(0);
-            const errors = [];
-            let delivered = 0;
-            for (const job of jobs){
-                try {
-                    await dispatch(job);
-                    delivered++;
-                } catch (error) {
-                    errors.push(error);
-                }
-            }
-            if (errors.length > 0) {
-                throw new AggregateError(errors, `queue flush: ${errors.length} of ${jobs.length} jobs failed (${delivered} delivered)`);
-            }
-            return delivered;
-        }
-    };
-}

package/dist/queue/queue.binding.d.ts

@@ -1,23 +0,0 @@
-import type { Container, DiscoveryService } from '../index';
-import type { QueueDriver } from './queue.types';
-/**
- * Wires a `QueueModule` instance's driver to the app: binds in-process
- * delivery to the dispatch core and validates that no other module instance
- * provides the same queue names.
- *
- * Delivery resolves processors from the per-app `EntrypointRegistry` once it
- * exists (registered into the container at the end of
- * `callOnApplicationBootstrap`); deliveries that arrive earlier (a producer's
- * `onModuleInit` calling `add()`) fall back to `DiscoveryService` with
- * `deferLazy` — identical entries, no buffering, no lost jobs.
- *
- * Every `QueueClient` injects this binding, so the driver is always bound
- * before the first `add()` — including when the module materializes lazily.
- */
-export declare class QueueDispatchBinding {
-    private readonly container;
-    private readonly discovery;
-    constructor(container: Container, discovery: DiscoveryService, driver: QueueDriver, queues: string[]);
-    private deliver;
-    private routeError;
-}

package/dist/queue/queue.binding.js

@@ -1,53 +0,0 @@
-import { EntrypointRegistry } from "../index.js";
-import { dispatchJobToEntries } from "./queue.dispatch.js";
-import { PROCESSOR_METADATA, queueToken } from "./queue.tokens.js";
-/**
- * Wires a `QueueModule` instance's driver to the app: binds in-process
- * delivery to the dispatch core and validates that no other module instance
- * provides the same queue names.
- *
- * Delivery resolves processors from the per-app `EntrypointRegistry` once it
- * exists (registered into the container at the end of
- * `callOnApplicationBootstrap`); deliveries that arrive earlier (a producer's
- * `onModuleInit` calling `add()`) fall back to `DiscoveryService` with
- * `deferLazy` — identical entries, no buffering, no lost jobs.
- *
- * Every `QueueClient` injects this binding, so the driver is always bound
- * before the first `add()` — including when the module materializes lazily.
- */ export class QueueDispatchBinding {
-    container;
-    discovery;
-    constructor(container, discovery, driver, queues){
-        this.container = container;
-        this.discovery = discovery;
-        for (const queue of queues){
-            const owners = container.getOwnerModuleIds(queueToken(queue));
-            if (owners.length > 1) {
-                throw new Error(`Queue '${queue}' is provided by multiple QueueModule instances (${owners.join(', ')}). ` + `Queue names must be unique per app — either dedup the forRoot options or rename the queue.`);
-            }
-        }
-        driver.bind?.((job)=>this.deliver(job), {
-            onError: (error, job)=>this.routeError(error, job)
-        });
-    }
-    async deliver(job) {
-        const entries = this.container.has(EntrypointRegistry) ? this.container.resolve(EntrypointRegistry).ofKind('queue').map((ep)=>({
-                token: ep.token,
-                meta: ep.meta
-            })) : this.discovery.providersWithMeta(PROCESSOR_METADATA, {
-            deferLazy: true
-        }).map((found)=>({
-                token: found.token,
-                meta: found.meta
-            }));
-        await dispatchJobToEntries(this.container, entries, job);
-    }
-    routeError(error, job) {
-        const mode = this.container.getDiagnostics();
-        if (mode === 'silent') return;
-        if (mode === 'throw') {
-            throw error instanceof Error ? error : new Error(String(error));
-        }
-        console.error(`[vela] unhandled error processing queue job '${job.name}' on '${job.queue}':`, error);
-    }
-}

package/dist/queue/queue.client.d.ts

@@ -1,20 +0,0 @@
-import type { AddJobOptions, QueueDriver, QueueJob } from './queue.types';
-/**
- * Producer handle for one named queue — inject via `queueToken(name)`:
- *
- * ```ts
- * constructor(@Inject(queueToken('email')) private readonly email: QueueClient) {}
- * await this.email.add('welcome', { userId });
- * ```
- *
- * `add()` resolves when the DRIVER accepted the job, not when a processor
- * handled it (the inline driver's `immediate` mode delivers on a following
- * microtask; platform drivers deliver in another isolate entirely).
- */
-export declare class QueueClient {
-    private readonly queue;
-    private readonly driver;
-    constructor(queue: string, driver: QueueDriver);
-    get name(): string;
-    add<T>(jobName: string, data: T, options?: AddJobOptions): Promise<QueueJob<T>>;
-}

package/dist/queue/queue.client.js

@@ -1,33 +0,0 @@
-/**
- * Producer handle for one named queue — inject via `queueToken(name)`:
- *
- * ```ts
- * constructor(@Inject(queueToken('email')) private readonly email: QueueClient) {}
- * await this.email.add('welcome', { userId });
- * ```
- *
- * `add()` resolves when the DRIVER accepted the job, not when a processor
- * handled it (the inline driver's `immediate` mode delivers on a following
- * microtask; platform drivers deliver in another isolate entirely).
- */ export class QueueClient {
-    queue;
-    driver;
-    constructor(queue, driver){
-        this.queue = queue;
-        this.driver = driver;
-    }
-    get name() {
-        return this.queue;
-    }
-    async add(jobName, data, options = {}) {
-        const job = {
-            id: crypto.randomUUID(),
-            queue: this.queue,
-            name: jobName,
-            data,
-            attempt: 1
-        };
-        await this.driver.enqueue(job, options);
-        return job;
-    }
-}

package/dist/queue/queue.decorators.d.ts

@@ -1,23 +0,0 @@
-import type { ProcessMetadata } from './queue.types';
-/**
- * Marks a provider class as a processor for one queue:
- *
- * ```ts
- * @Processor('email')
- * @Injectable()
- * class EmailProcessor {
- *   @Process('welcome')
- *   async sendWelcome(job: QueueJob<{ userId: string }>) { ... }
- * }
- * ```
- */
-export declare function Processor(queueName: string): ClassDecorator;
-/**
- * Marks a processor method as the handler for a job name. Omit the name for
- * the wildcard handler (receives every job on the queue that has no named
- * handler). Named handlers win over the wildcard; a duplicate registration
- * for the same name is first-wins with a diagnostics warning at dispatch.
- */
-export declare function Process(jobName?: string): MethodDecorator;
-/** `@Process` entries declared on a processor class (declaration order). */
-export declare function getProcessHandlers(processorClass: object): ProcessMetadata[];

package/dist/queue/queue.decorators.js

@@ -1,46 +0,0 @@
-import { createDiscoverableDecorator, defineMetadata, getMetadata, registerEntrypointKind } from "../index.js";
-import { PROCESS_METADATA, PROCESSOR_METADATA } from "./queue.tokens.js";
-const ProcessorMeta = createDiscoverableDecorator(PROCESSOR_METADATA);
-// The open entrypoint kind: adapters enumerate processors via
-// `app.entrypoints.ofKind<ProcessorMetadata>('queue')`. Declared at import
-// time next to the decorator — zero kernel involvement.
-registerEntrypointKind({
-    kind: 'queue',
-    metaKey: PROCESSOR_METADATA,
-    level: 'class'
-});
-/**
- * Marks a provider class as a processor for one queue:
- *
- * ```ts
- * @Processor('email')
- * @Injectable()
- * class EmailProcessor {
- *   @Process('welcome')
- *   async sendWelcome(job: QueueJob<{ userId: string }>) { ... }
- * }
- * ```
- */ export function Processor(queueName) {
-    return ProcessorMeta({
-        queueName
-    });
-}
-/**
- * Marks a processor method as the handler for a job name. Omit the name for
- * the wildcard handler (receives every job on the queue that has no named
- * handler). Named handlers win over the wildcard; a duplicate registration
- * for the same name is first-wins with a diagnostics warning at dispatch.
- */ export function Process(jobName) {
-    return (target, propertyKey)=>{
-        const ctor = target.constructor;
-        const existing = getMetadata(PROCESS_METADATA, ctor) ?? [];
-        existing.push({
-            jobName,
-            methodName: propertyKey
-        });
-        defineMetadata(PROCESS_METADATA, existing, ctor);
-    };
-}
-/** `@Process` entries declared on a processor class (declaration order). */ export function getProcessHandlers(processorClass) {
-    return getMetadata(PROCESS_METADATA, processorClass) ?? [];
-}

package/dist/queue/queue.dispatch.d.ts

@@ -1,36 +0,0 @@
-import type { Container, EntrypointRegistry, Token } from '../index';
-import type { ProcessorMetadata, QueueJob } from './queue.types';
-export interface QueueDispatchResult {
-    /** Processors that ran a handler for this job. */
-    handled: number;
-}
-/** One dispatchable processor: its class token + `@Processor` meta. */
-export interface QueueEntry {
-    token: Token;
-    meta: ProcessorMetadata;
-}
-/**
- * Deliver one job to every `@Processor` of its queue — the primitive both the
- * in-core `inline()` driver and platform adapters call.
- *
- * Each matching processor runs inside `runInEntrypointScope` (request-scoped
- * dependencies rebuild per job) and is re-resolved BY TOKEN through the async
- * seam, so processors living in `lazy: true` modules materialize cleanly on
- * first dispatch — async providers and lifecycle hooks included. Scoped
- * guards/interceptors/filters run through `PipelineRunner`
- * (`getType() === 'queue'`, `getPayload()` is the job); app-wide `APP_*`
- * components deliberately do NOT apply (cloudflare queue/scheduled parity —
- * documented divergence from the WebSocket dispatcher).
- *
- * Errors no scoped filter claims RETHROW so awaiting platforms keep their
- * retry semantics; fire-and-forget callers (inline `immediate` mode) must
- * catch — `QueueDispatchBinding` routes those to diagnostics.
- */
-export declare function dispatchQueueJob(container: Container, entrypoints: EntrypointRegistry, job: QueueJob): Promise<QueueDispatchResult>;
-/**
- * Entry-list core shared by `dispatchQueueJob` (registry) and the in-process
- * driver binding (discovery fallback before the registry exists). Entries are
- * tokens + meta ONLY — every processor is re-resolved by token in its own
- * scope, so request-scoped and lazy-module processors work on both paths.
- */
-export declare function dispatchJobToEntries(container: Container, entries: QueueEntry[], job: QueueJob): Promise<QueueDispatchResult>;