@velajs/vela 1.19.0 → 1.19.1

package/dist/queue/index.js

@@ -1,12 +1,384 @@
-// @velajs/vela/queue — first-party queue subsystem, authored entirely on the
-// public API (every vela import in src/queue/* comes from '../index'; the
-// openness audit test enforces it). Deliberately NOT re-exported from the
-// main barrel: @velajs/cloudflare already exports an (unrelated) QueueModule
-// for the CF Queues binding, and subpath-only avoids the collision.
-export { QueueModule, QUEUE_MODULE_OPTIONS } from "./queue.module.js";
-export { Processor, Process, getProcessHandlers } from "./queue.decorators.js";
-export { queueToken, QUEUE_DRIVER, PROCESSOR_METADATA, PROCESS_METADATA } from "./queue.tokens.js";
-export { QueueClient } from "./queue.client.js";
-export { QueueDispatchBinding } from "./queue.binding.js";
-export { dispatchQueueJob } from "./queue.dispatch.js";
-export { inline } from "./inline.driver.js";
+import { C as InjectionToken } from "../decorate-GcSMAbKn.js";
+import { F as shouldFilterCatch, G as getMetadata, L as PipelineRunner, W as defineMetadata } from "../route.manager-DRAZ5X04.js";
+import { n as resolveErrorReporter, t as DiscoveryService } from "../discovery.service-BYm95SSD.js";
+import { t as Container } from "../container-BqUHID4l.js";
+import { _ as EntrypointRegistry, y as registerEntrypointKind } from "../plugin-ByBlVOve.js";
+import { E as runInEntrypointScope, T as buildEntrypointExecutionContext, w as resolveScopedComponents } from "../src-eb5CI6Xn.js";
+import { n as defineModule, r as stableHash } from "../define-module-NOyOZNXD.js";
+import { E as createDiscoverableDecorator } from "../websocket-DXmB-MWJ.js";
+//#region src/queue/inline.driver.ts
+/**
+* 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).
+*/
+function inline(options = {}) {
+	const mode = options.mode ?? "immediate";
+	const buffer = [];
+	let dispatch;
+	let onError;
+	let warnedDelay = false;
+	const deliverDetached = (job) => {
+		queueMicrotask(() => {
+			dispatch(job).catch((error) => onError?.(error, job));
+		});
+	};
+	return {
+		kind: "inline",
+		get size() {
+			return buffer.length;
+		},
+		async enqueue(job, addOptions) {
+			if (addOptions?.delayMs !== void 0 && !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;
+		}
+	};
+}
+//#endregion
+//#region src/queue/queue.client.ts
+/**
+* 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).
+*/
+var QueueClient = class {
+	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;
+	}
+};
+//#endregion
+//#region src/queue/queue.tokens.ts
+const PROCESSOR_METADATA = "vela:queue:processor";
+const PROCESS_METADATA = "vela:queue:process";
+/** The driver in effect for a `QueueModule` instance. */
+const QUEUE_DRIVER = new InjectionToken("vela:queue:driver");
+const TOKEN_STORE_KEY = Symbol.for("vela:queue:client-tokens:v1");
+function tokenStore() {
+	const g = globalThis;
+	return g[TOKEN_STORE_KEY] ??= /* @__PURE__ */ new Map();
+}
+/**
+* The injection token for a named queue's `QueueClient`:
+*
+* ```ts
+* constructor(@Inject(queueToken('email')) private readonly email: QueueClient) {}
+* ```
+*
+* Memoized per name (HMR-stable). Deliberately NO `InjectionToken` default
+* factory: the container resolves default-factory tokens from the root bucket
+* BEFORE walking module imports, which would break the exported-provider
+* path — the token description (`vela:queue:client:<name>`) keeps the
+* no-provider error readable instead.
+*/
+function queueToken(name) {
+	const store = tokenStore();
+	let token = store.get(name);
+	if (!token) {
+		token = new InjectionToken(`vela:queue:client:${name}`);
+		store.set(name, token);
+	}
+	return token;
+}
+//#endregion
+//#region src/queue/queue.decorators.ts
+const ProcessorMeta = createDiscoverableDecorator(PROCESSOR_METADATA);
+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 }>) { ... }
+* }
+* ```
+*/
+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.
+*/
+function Process(jobName) {
+	return (target, propertyKey) => {
+		const ctor = target.constructor;
+		const existing = getMetadata("vela:queue:process", ctor) ?? [];
+		existing.push({
+			jobName,
+			methodName: propertyKey
+		});
+		defineMetadata(PROCESS_METADATA, existing, ctor);
+	};
+}
+/** `@Process` entries declared on a processor class (declaration order). */
+function getProcessHandlers(processorClass) {
+	return getMetadata("vela:queue:process", processorClass) ?? [];
+}
+//#endregion
+//#region src/queue/queue.dispatch.ts
+const warnedDuplicates = /* @__PURE__ */ new WeakSet();
+function selectHandler(container, processorClass, handlers, jobName) {
+	const named = handlers.filter((h) => h.jobName === jobName);
+	const pool = named.length > 0 ? named : handlers.filter((h) => h.jobName === void 0);
+	if (pool.length > 1 && !warnedDuplicates.has(processorClass)) {
+		warnedDuplicates.add(processorClass);
+		const message = `[vela] duplicate ${named.length > 0 ? `@Process('${jobName}')` : "@Process() (wildcard)"} handlers on ${processorClass.name}; keeping the first ('${String(pool[0].methodName)}').`;
+		if (container.getDiagnostics() === "throw") throw new Error(message);
+		if (container.getDiagnostics() === "log") console.warn(message);
+	}
+	return pool[0];
+}
+/**
+* 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.
+*/
+async function dispatchQueueJob(container, entrypoints, job) {
+	return dispatchJobToEntries(container, entrypoints.ofKind("queue").map((ep) => ({
+		token: ep.token,
+		meta: ep.meta
+	})), job);
+}
+/**
+* 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.
+*/
+async function dispatchJobToEntries(container, entries, job) {
+	const processors = entries.filter((entry) => entry.meta.queueName === job.queue);
+	if (processors.length === 0) {
+		if (container.getDiagnostics() === "log") console.warn(`[vela] queue job '${job.name}' on '${job.queue}' has no @Processor('${job.queue}') — dropped.`);
+		return { handled: 0 };
+	}
+	return { handled: (await Promise.all(processors.map((entry) => dispatchToProcessor(container, entry.token, job)))).filter(Boolean).length };
+}
+async function dispatchToProcessor(container, processorClass, job) {
+	const handler = selectHandler(container, processorClass, getProcessHandlers(processorClass), job.name);
+	if (!handler) {
+		if (container.getDiagnostics() === "log") console.warn(`[vela] no @Process('${job.name}') (or wildcard) handler on ${processorClass.name} for queue '${job.queue}' — skipped.`);
+		return false;
+	}
+	return runInEntrypointScope(container, async (scope) => {
+		const instance = await scope.resolveAsync(processorClass);
+		const context = buildEntrypointExecutionContext("queue", processorClass, handler.methodName, job);
+		const guards = resolveScopedComponents("guard", processorClass, handler.methodName, scope);
+		const interceptors = resolveScopedComponents("interceptor", processorClass, handler.methodName, scope);
+		const filters = resolveScopedComponents("filter", processorClass, handler.methodName, scope).reverse();
+		try {
+			await PipelineRunner.run({
+				context,
+				guards,
+				interceptors,
+				resolveArgs: async () => [job],
+				invoke: async (args) => {
+					return instance[handler.methodName].apply(instance, args);
+				}
+			});
+			return true;
+		} catch (error) {
+			resolveErrorReporter(scope).report(error, {
+				edge: "queue",
+				source: `${processorClass.name}.${String(handler.methodName)}`
+			});
+			for (const filter of filters) if (shouldFilterCatch(filter, error)) {
+				await filter.catch(error, context);
+				return true;
+			}
+			throw error;
+		}
+	});
+}
+//#endregion
+//#region src/queue/queue.binding.ts
+/**
+* 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.
+*/
+var QueueDispatchBinding = class {
+	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));
+		resolveErrorReporter(this.container).report(error, {
+			edge: "queue",
+			source: `${job.queue}/${job.name}`,
+			note: "inline driver"
+		});
+	}
+};
+//#endregion
+//#region src/queue/queue.module.ts
+/**
+* First-party queue module — authored 100% on vela's public API (the
+* roadmap's "openness proof"). Producers inject a per-queue `QueueClient`
+* via `queueToken(name)`; consumers are `@Processor`/`@Process` classes in
+* ordinary user modules; platforms deliver through `dispatchQueueJob` or the
+* in-core `inline()` driver.
+*
+* ```ts
+* imports: [QueueModule.forRoot({ queues: ['email'] })]
+* ```
+*
+* `lazy: true` (dogfoods 1.13): the module materializes when an eager
+* producer injects a client (bootstrap — same structural reality that keeps
+* WebSocketModule eager) or, in consumer-only workers, at the first
+* delivered job.
+*
+* `queues` is STRUCTURAL: clients are options-derived providers, so
+* `forRootAsync` callers pass it alongside the factory —
+* `forRootAsync({ queues: ['email'], useFactory: () => ({ driver }) })`.
+* Note that async options inherit the 1.13 lazy-module contract: the module
+* must first materialize through an async seam (an eager producer's injection
+* during the bootstrap sweep — the common case — or
+* `app.materializeLazyModules()`); a synchronous first touch throws the
+* descriptive sync-seam error.
+*/
+const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = defineModule({
+	name: "Queue",
+	lazy: true,
+	key: (o) => stableHash({
+		queues: o.queues ?? [],
+		driver: o.driver?.kind ?? "inline"
+	}),
+	setup: ({ OPTIONS, options }) => {
+		const queues = options.queues;
+		if (!queues || queues.length === 0) throw new Error("QueueModule requires 'queues' as a structural option: QueueModule.forRoot({ queues: ['email'] }) — for forRootAsync, pass it alongside the factory: forRootAsync({ queues: [...], useFactory }).");
+		const clientProviders = queues.map((name) => ({
+			provide: queueToken(name),
+			useFactory: (driver, _binding) => new QueueClient(name, driver),
+			inject: [QUEUE_DRIVER, QueueDispatchBinding]
+		}));
+		return {
+			providers: [
+				{
+					provide: QUEUE_DRIVER,
+					useFactory: (o) => o.driver ?? inline(),
+					inject: [OPTIONS]
+				},
+				{
+					provide: QueueDispatchBinding,
+					useFactory: (container, discovery, driver) => new QueueDispatchBinding(container, discovery, driver, queues),
+					inject: [
+						Container,
+						DiscoveryService,
+						QUEUE_DRIVER
+					]
+				},
+				...clientProviders
+			],
+			exports: [
+				QUEUE_DRIVER,
+				QueueDispatchBinding,
+				...queues.map((name) => queueToken(name))
+			]
+		};
+	}
+});
+var QueueModule = class extends ConfigurableModuleClass {};
+//#endregion
+export { PROCESSOR_METADATA, PROCESS_METADATA, Process, Processor, QUEUE_DRIVER, MODULE_OPTIONS_TOKEN as QUEUE_MODULE_OPTIONS, QueueClient, QueueDispatchBinding, QueueModule, dispatchQueueJob, getProcessHandlers, inline, queueToken };
+
+//# sourceMappingURL=index.js.map

package/dist/queue/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/queue/inline.driver.ts","../../src/queue/queue.client.ts","../../src/queue/queue.tokens.ts","../../src/queue/queue.decorators.ts","../../src/queue/queue.dispatch.ts","../../src/queue/queue.binding.ts","../../src/queue/queue.module.ts"],"sourcesContent":["import type {\n  AddJobOptions,\n  QueueDispatchFn,\n  QueueDriver,\n  QueueDriverBindHooks,\n  QueueJob,\n} from './queue.types';\n\nexport interface InlineQueueOptions {\n  /**\n   * `immediate` (default): deliver on a microtask after `enqueue` resolves —\n   * `add()` resolving does NOT mean the job was handled. Handler errors are\n   * routed to the binding's error hook (container diagnostics), never thrown\n   * into the detached microtask.\n   *\n   * `manual`: buffer until `flush()` — deterministic delivery for tests.\n   */\n  mode?: 'immediate' | 'manual';\n}\n\nexport interface InlineQueueDriver extends QueueDriver {\n  /**\n   * Deliver everything buffered (manual mode; also drains jobs enqueued\n   * before the driver was bound). Resolves with the delivered count; rejects\n   * with an `AggregateError` after attempting ALL buffered jobs if any\n   * handler error went unclaimed — the awaiter exists here, so the\n   * platform-retry rethrow contract is meaningful.\n   */\n  flush(): Promise<number>;\n  /** Jobs currently buffered (unbound immediate + all manual). */\n  readonly size: number;\n}\n\n/**\n * In-process driver for dev, tests, and single-isolate apps. Edge-pure: no\n * timers — `immediate` mode uses `queueMicrotask`. `delayMs` is not\n * supported (warns once through the bound error hook's diagnostics side).\n */\nexport function inline(options: InlineQueueOptions = {}): InlineQueueDriver {\n  const mode = options.mode ?? 'immediate';\n  const buffer: QueueJob[] = [];\n  let dispatch: QueueDispatchFn | undefined;\n  let onError: QueueDriverBindHooks['onError'];\n  let warnedDelay = false;\n\n  const deliverDetached = (job: QueueJob): void => {\n    queueMicrotask(() => {\n      void dispatch!(job).catch((error) => onError?.(error, job));\n    });\n  };\n\n  return {\n    kind: 'inline',\n\n    get size(): number {\n      return buffer.length;\n    },\n\n    async enqueue(job: QueueJob, addOptions?: AddJobOptions): Promise<void> {\n      if (addOptions?.delayMs !== undefined && !warnedDelay) {\n        warnedDelay = true;\n        console.warn(\n          `[vela] inline() queue driver does not support delayMs — job '${job.name}' delivers without delay.`,\n        );\n      }\n      if (mode === 'manual' || !dispatch) {\n        buffer.push(job);\n        return;\n      }\n      deliverDetached(job);\n    },\n\n    bind(fn: QueueDispatchFn, hooks?: QueueDriverBindHooks): void {\n      dispatch = fn;\n      onError = hooks?.onError;\n      if (mode === 'immediate' && buffer.length > 0) {\n        for (const job of buffer.splice(0)) deliverDetached(job);\n      }\n    },\n\n    async flush(): Promise<number> {\n      if (!dispatch) return 0;\n      const jobs = buffer.splice(0);\n      const errors: unknown[] = [];\n      let delivered = 0;\n      for (const job of jobs) {\n        try {\n          await dispatch(job);\n          delivered++;\n        } catch (error) {\n          errors.push(error);\n        }\n      }\n      if (errors.length > 0) {\n        throw new AggregateError(\n          errors,\n          `queue flush: ${errors.length} of ${jobs.length} jobs failed (${delivered} delivered)`,\n        );\n      }\n      return delivered;\n    },\n  };\n}\n","import type { AddJobOptions, QueueDriver, QueueJob } from './queue.types';\n\n/**\n * Producer handle for one named queue — inject via `queueToken(name)`:\n *\n * ```ts\n * constructor(@Inject(queueToken('email')) private readonly email: QueueClient) {}\n * await this.email.add('welcome', { userId });\n * ```\n *\n * `add()` resolves when the DRIVER accepted the job, not when a processor\n * handled it (the inline driver's `immediate` mode delivers on a following\n * microtask; platform drivers deliver in another isolate entirely).\n */\nexport class QueueClient {\n  constructor(\n    private readonly queue: string,\n    private readonly driver: QueueDriver,\n  ) {}\n\n  get name(): string {\n    return this.queue;\n  }\n\n  async add<T>(jobName: string, data: T, options: AddJobOptions = {}): Promise<QueueJob<T>> {\n    const job: QueueJob<T> = {\n      id: crypto.randomUUID(),\n      queue: this.queue,\n      name: jobName,\n      data,\n      attempt: 1,\n    };\n    await this.driver.enqueue(job, options);\n    return job;\n  }\n}\n","import { InjectionToken } from '../index';\nimport type { QueueClient } from './queue.client';\nimport type { QueueDriver } from './queue.types';\n\nexport const PROCESSOR_METADATA = 'vela:queue:processor';\nexport const PROCESS_METADATA = 'vela:queue:process';\n\n/** The driver in effect for a `QueueModule` instance. */\nexport const QUEUE_DRIVER = new InjectionToken<QueueDriver>('vela:queue:driver');\n\n// Token identity must survive Vite HMR re-evals (a consumer module that was\n// NOT re-evaluated still holds the token minted by the previous generation),\n// so the name → token map is anchored on globalThis exactly like the\n// entrypoint kind store and MetadataRegistry state.\nconst TOKEN_STORE_KEY = Symbol.for('vela:queue:client-tokens:v1');\n\nfunction tokenStore(): Map<string, InjectionToken<QueueClient>> {\n  const g = globalThis as unknown as Record<\n    symbol,\n    Map<string, InjectionToken<QueueClient>> | undefined\n  >;\n  return (g[TOKEN_STORE_KEY] ??= new Map());\n}\n\n/**\n * The injection token for a named queue's `QueueClient`:\n *\n * ```ts\n * constructor(@Inject(queueToken('email')) private readonly email: QueueClient) {}\n * ```\n *\n * Memoized per name (HMR-stable). Deliberately NO `InjectionToken` default\n * factory: the container resolves default-factory tokens from the root bucket\n * BEFORE walking module imports, which would break the exported-provider\n * path — the token description (`vela:queue:client:<name>`) keeps the\n * no-provider error readable instead.\n */\nexport function queueToken(name: string): InjectionToken<QueueClient> {\n  const store = tokenStore();\n  let token = store.get(name);\n  if (!token) {\n    token = new InjectionToken<QueueClient>(`vela:queue:client:${name}`);\n    store.set(name, token);\n  }\n  return token;\n}\n","import {\n  createDiscoverableDecorator,\n  defineMetadata,\n  getMetadata,\n  registerEntrypointKind,\n} from '../index';\nimport { PROCESS_METADATA, PROCESSOR_METADATA } from './queue.tokens';\nimport type { ProcessMetadata, ProcessorMetadata } from './queue.types';\n\nconst ProcessorMeta = createDiscoverableDecorator<ProcessorMetadata>(PROCESSOR_METADATA);\n\n// The open entrypoint kind: adapters enumerate processors via\n// `app.entrypoints.ofKind<ProcessorMetadata>('queue')`. Declared at import\n// time next to the decorator — zero kernel involvement.\nregisterEntrypointKind({ kind: 'queue', metaKey: PROCESSOR_METADATA, level: 'class' });\n\n/**\n * Marks a provider class as a processor for one queue:\n *\n * ```ts\n * @Processor('email')\n * @Injectable()\n * class EmailProcessor {\n *   @Process('welcome')\n *   async sendWelcome(job: QueueJob<{ userId: string }>) { ... }\n * }\n * ```\n */\nexport function Processor(queueName: string): ClassDecorator {\n  return ProcessorMeta({ queueName }) as ClassDecorator;\n}\n\n/**\n * Marks a processor method as the handler for a job name. Omit the name for\n * the wildcard handler (receives every job on the queue that has no named\n * handler). Named handlers win over the wildcard; a duplicate registration\n * for the same name is first-wins with a diagnostics warning at dispatch.\n */\nexport function Process(jobName?: string): MethodDecorator {\n  return (target: object, propertyKey: string | symbol) => {\n    const ctor = target.constructor;\n    const existing = (getMetadata(PROCESS_METADATA, ctor) as ProcessMetadata[] | undefined) ?? [];\n    existing.push({ jobName, methodName: propertyKey });\n    defineMetadata(PROCESS_METADATA, existing, ctor);\n  };\n}\n\n/** `@Process` entries declared on a processor class (declaration order). */\nexport function getProcessHandlers(processorClass: object): ProcessMetadata[] {\n  return (getMetadata(PROCESS_METADATA, processorClass) as ProcessMetadata[] | undefined) ?? [];\n}\n","import {\n  buildEntrypointExecutionContext,\n  PipelineRunner,\n  resolveErrorReporter,\n  resolveScopedComponents,\n  runInEntrypointScope,\n  shouldFilterCatch,\n} from '../index';\nimport type { Container, EntrypointRegistry, Token, Type } from '../index';\nimport { getProcessHandlers } from './queue.decorators';\nimport type { ProcessMetadata, ProcessorMetadata, QueueJob } from './queue.types';\n\nexport interface QueueDispatchResult {\n  /** Processors that ran a handler for this job. */\n  handled: number;\n}\n\n/** One dispatchable processor: its class token + `@Processor` meta. */\nexport interface QueueEntry {\n  token: Token;\n  meta: ProcessorMetadata;\n}\n\nconst warnedDuplicates = new WeakSet<object>();\n\nfunction selectHandler(\n  container: Container,\n  processorClass: Type,\n  handlers: ProcessMetadata[],\n  jobName: string,\n): ProcessMetadata | undefined {\n  const named = handlers.filter((h) => h.jobName === jobName);\n  const pool = named.length > 0 ? named : handlers.filter((h) => h.jobName === undefined);\n  if (pool.length > 1 && !warnedDuplicates.has(processorClass)) {\n    warnedDuplicates.add(processorClass);\n    const label = named.length > 0 ? `@Process('${jobName}')` : '@Process() (wildcard)';\n    const message =\n      `[vela] duplicate ${label} handlers on ${processorClass.name}; ` +\n      `keeping the first ('${String(pool[0]!.methodName)}').`;\n    if (container.getDiagnostics() === 'throw') throw new Error(message);\n    if (container.getDiagnostics() === 'log') console.warn(message);\n  }\n  return pool[0];\n}\n\n/**\n * Deliver one job to every `@Processor` of its queue — the primitive both the\n * in-core `inline()` driver and platform adapters call.\n *\n * Each matching processor runs inside `runInEntrypointScope` (request-scoped\n * dependencies rebuild per job) and is re-resolved BY TOKEN through the async\n * seam, so processors living in `lazy: true` modules materialize cleanly on\n * first dispatch — async providers and lifecycle hooks included. Scoped\n * guards/interceptors/filters run through `PipelineRunner`\n * (`getType() === 'queue'`, `getPayload()` is the job); app-wide `APP_*`\n * components deliberately do NOT apply (cloudflare queue/scheduled parity —\n * documented divergence from the WebSocket dispatcher).\n *\n * Errors no scoped filter claims RETHROW so awaiting platforms keep their\n * retry semantics; fire-and-forget callers (inline `immediate` mode) must\n * catch — `QueueDispatchBinding` routes those to diagnostics.\n */\nexport async function dispatchQueueJob(\n  container: Container,\n  entrypoints: EntrypointRegistry,\n  job: QueueJob,\n): Promise<QueueDispatchResult> {\n  const entries = entrypoints\n    .ofKind<ProcessorMetadata>('queue')\n    .map((ep) => ({ token: ep.token, meta: ep.meta }));\n  return dispatchJobToEntries(container, entries, job);\n}\n\n/**\n * Entry-list core shared by `dispatchQueueJob` (registry) and the in-process\n * driver binding (discovery fallback before the registry exists). Entries are\n * tokens + meta ONLY — every processor is re-resolved by token in its own\n * scope, so request-scoped and lazy-module processors work on both paths.\n */\nexport async function dispatchJobToEntries(\n  container: Container,\n  entries: QueueEntry[],\n  job: QueueJob,\n): Promise<QueueDispatchResult> {\n  const processors = entries.filter((entry) => entry.meta.queueName === job.queue);\n\n  if (processors.length === 0) {\n    if (container.getDiagnostics() === 'log') {\n      console.warn(\n        `[vela] queue job '${job.name}' on '${job.queue}' has no @Processor('${job.queue}') — dropped.`,\n      );\n    }\n    return { handled: 0 };\n  }\n\n  // All matching processors receive the job; the first unclaimed error\n  // rejects the whole dispatch (platform retries the delivery — CF parity).\n  const outcomes = await Promise.all(\n    processors.map((entry) => dispatchToProcessor(container, entry.token as Type, job)),\n  );\n  return { handled: outcomes.filter(Boolean).length };\n}\n\nasync function dispatchToProcessor(\n  container: Container,\n  processorClass: Type,\n  job: QueueJob,\n): Promise<boolean> {\n  const handler = selectHandler(\n    container,\n    processorClass,\n    getProcessHandlers(processorClass),\n    job.name,\n  );\n  if (!handler) {\n    if (container.getDiagnostics() === 'log') {\n      console.warn(\n        `[vela] no @Process('${job.name}') (or wildcard) handler on ` +\n          `${processorClass.name} for queue '${job.queue}' — skipped.`,\n      );\n    }\n    return false;\n  }\n\n  return runInEntrypointScope(container, async (scope) => {\n    // Async seam: materializes lazy processor modules (drainAsync awaits\n    // their async providers/hooks) and rebuilds request-scoped processors.\n    const instance = (await scope.resolveAsync(processorClass)) as Record<string | symbol, unknown>;\n    const context = buildEntrypointExecutionContext(\n      'queue',\n      processorClass,\n      handler.methodName,\n      job,\n    );\n\n    const guards = resolveScopedComponents('guard', processorClass, handler.methodName, scope);\n    const interceptors = resolveScopedComponents(\n      'interceptor',\n      processorClass,\n      handler.methodName,\n      scope,\n    );\n    // Closest-first: handler/class filters reversed by the caller (WS/CF convention).\n    const filters = resolveScopedComponents(\n      'filter',\n      processorClass,\n      handler.methodName,\n      scope,\n    ).reverse();\n\n    try {\n      await PipelineRunner.run({\n        context,\n        guards,\n        interceptors,\n        resolveArgs: async () => [job],\n        invoke: async (args) => {\n          const method = instance[handler.methodName] as (...a: unknown[]) => unknown;\n          return method.apply(instance, args);\n        },\n      });\n      return true;\n    } catch (error) {\n      // Report BEFORE the filter loop and BEFORE any rethrow — every dispatch\n      // error reaches the exception handler, whether a scoped filter claims it\n      // or it rethrows to preserve platform retry semantics.\n      resolveErrorReporter(scope).report(error, {\n        edge: 'queue',\n        source: `${processorClass.name}.${String(handler.methodName)}`,\n      });\n      for (const filter of filters) {\n        if (shouldFilterCatch(filter, error)) {\n          await filter.catch(error, context);\n          return true;\n        }\n      }\n      throw error; // unclaimed → platform retry semantics stay intact\n    }\n  });\n}\n","import { EntrypointRegistry, resolveErrorReporter } from '../index';\nimport type { Container, DiscoveryService } from '../index';\nimport { dispatchJobToEntries } from './queue.dispatch';\nimport type { QueueEntry } from './queue.dispatch';\nimport { PROCESSOR_METADATA, queueToken } from './queue.tokens';\nimport type { ProcessorMetadata, QueueDriver, QueueJob } from './queue.types';\n\n/**\n * Wires a `QueueModule` instance's driver to the app: binds in-process\n * delivery to the dispatch core and validates that no other module instance\n * provides the same queue names.\n *\n * Delivery resolves processors from the per-app `EntrypointRegistry` once it\n * exists (registered into the container at the end of\n * `callOnApplicationBootstrap`); deliveries that arrive earlier (a producer's\n * `onModuleInit` calling `add()`) fall back to `DiscoveryService` with\n * `deferLazy` — identical entries, no buffering, no lost jobs.\n *\n * Every `QueueClient` injects this binding, so the driver is always bound\n * before the first `add()` — including when the module materializes lazily.\n */\nexport class QueueDispatchBinding {\n  constructor(\n    private readonly container: Container,\n    private readonly discovery: DiscoveryService,\n    driver: QueueDriver,\n    queues: string[],\n  ) {\n    for (const queue of queues) {\n      const owners = container.getOwnerModuleIds(queueToken(queue));\n      if (owners.length > 1) {\n        throw new Error(\n          `Queue '${queue}' is provided by multiple QueueModule instances (${owners.join(', ')}). ` +\n            `Queue names must be unique per app — either dedup the forRoot options or rename the queue.`,\n        );\n      }\n    }\n\n    driver.bind?.((job) => this.deliver(job), {\n      onError: (error, job) => this.routeError(error, job),\n    });\n  }\n\n  private async deliver(job: QueueJob): Promise<void> {\n    const entries: QueueEntry[] = this.container.has(EntrypointRegistry)\n      ? this.container\n          .resolve(EntrypointRegistry)\n          .ofKind<ProcessorMetadata>('queue')\n          .map((ep) => ({ token: ep.token, meta: ep.meta }))\n      : this.discovery\n          .providersWithMeta<ProcessorMetadata>(PROCESSOR_METADATA, { deferLazy: true })\n          .map((found) => ({ token: found.token, meta: found.meta }));\n\n    await dispatchJobToEntries(this.container, entries, job);\n  }\n\n  private routeError(error: unknown, job: QueueJob): void {\n    const mode = this.container.getDiagnostics();\n    if (mode === 'silent') return;\n    if (mode === 'throw') {\n      throw error instanceof Error ? error : new Error(String(error));\n    }\n    // Fire-and-forget (inline `immediate`) deliveries have no awaiter to rethrow\n    // into — route their unclaimed errors to the exception handler instead of a\n    // bare console.error.\n    resolveErrorReporter(this.container).report(error, {\n      edge: 'queue',\n      source: `${job.queue}/${job.name}`,\n      note: 'inline driver',\n    });\n  }\n}\n","import { Container, defineModule, DiscoveryService, stableHash } from '../index';\nimport type { ProviderOptions } from '../index';\nimport { inline } from './inline.driver';\nimport { QueueClient } from './queue.client';\nimport { QueueDispatchBinding } from './queue.binding';\nimport { QUEUE_DRIVER, queueToken } from './queue.tokens';\nimport type { QueueDriver, QueueModuleOptions } from './queue.types';\n\n/**\n * First-party queue module — authored 100% on vela's public API (the\n * roadmap's \"openness proof\"). Producers inject a per-queue `QueueClient`\n * via `queueToken(name)`; consumers are `@Processor`/`@Process` classes in\n * ordinary user modules; platforms deliver through `dispatchQueueJob` or the\n * in-core `inline()` driver.\n *\n * ```ts\n * imports: [QueueModule.forRoot({ queues: ['email'] })]\n * ```\n *\n * `lazy: true` (dogfoods 1.13): the module materializes when an eager\n * producer injects a client (bootstrap — same structural reality that keeps\n * WebSocketModule eager) or, in consumer-only workers, at the first\n * delivered job.\n *\n * `queues` is STRUCTURAL: clients are options-derived providers, so\n * `forRootAsync` callers pass it alongside the factory —\n * `forRootAsync({ queues: ['email'], useFactory: () => ({ driver }) })`.\n * Note that async options inherit the 1.13 lazy-module contract: the module\n * must first materialize through an async seam (an eager producer's injection\n * during the bootstrap sweep — the common case — or\n * `app.materializeLazyModules()`); a synchronous first touch throws the\n * descriptive sync-seam error.\n */\nconst { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = defineModule<QueueModuleOptions>({\n  name: 'Queue',\n  lazy: true,\n  key: (o) => stableHash({ queues: o.queues ?? [], driver: o.driver?.kind ?? 'inline' }),\n  setup: ({ OPTIONS, options }) => {\n    const queues = options.queues;\n    if (!queues || queues.length === 0) {\n      throw new Error(\n        \"QueueModule requires 'queues' as a structural option: \" +\n          \"QueueModule.forRoot({ queues: ['email'] }) — for forRootAsync, pass it alongside \" +\n          'the factory: forRootAsync({ queues: [...], useFactory }).',\n      );\n    }\n\n    const clientProviders: ProviderOptions[] = queues.map((name) => ({\n      provide: queueToken(name),\n      useFactory: (driver: QueueDriver, _binding: QueueDispatchBinding) =>\n        new QueueClient(name, driver),\n      inject: [QUEUE_DRIVER, QueueDispatchBinding],\n    }));\n\n    return {\n      providers: [\n        {\n          provide: QUEUE_DRIVER,\n          useFactory: (o: QueueModuleOptions) => o.driver ?? inline(),\n          inject: [OPTIONS],\n        },\n        {\n          provide: QueueDispatchBinding,\n          useFactory: (container: Container, discovery: DiscoveryService, driver: QueueDriver) =>\n            new QueueDispatchBinding(container, discovery, driver, queues),\n          inject: [Container, DiscoveryService, QUEUE_DRIVER],\n        },\n        ...clientProviders,\n      ],\n      exports: [QUEUE_DRIVER, QueueDispatchBinding, ...queues.map((name) => queueToken(name))],\n    };\n  },\n});\n\nexport class QueueModule extends ConfigurableModuleClass {}\nexport { MODULE_OPTIONS_TOKEN as QUEUE_MODULE_OPTIONS };\n"],"mappings":";;;;;;;;;;;;;;AAsCA,SAAgB,OAAO,UAA8B,CAAC,GAAsB;CAC1E,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,SAAqB,CAAC;CAC5B,IAAI;CACJ,IAAI;CACJ,IAAI,cAAc;CAElB,MAAM,mBAAmB,QAAwB;EAC/C,qBAAqB;GACnB,SAAe,GAAG,CAAC,CAAC,OAAO,UAAU,UAAU,OAAO,GAAG,CAAC;EAC5D,CAAC;CACH;CAEA,OAAO;EACL,MAAM;EAEN,IAAI,OAAe;GACjB,OAAO,OAAO;EAChB;EAEA,MAAM,QAAQ,KAAe,YAA2C;GACtE,IAAI,YAAY,YAAY,KAAA,KAAa,CAAC,aAAa;IACrD,cAAc;IACd,QAAQ,KACN,gEAAgE,IAAI,KAAK,0BAC3E;GACF;GACA,IAAI,SAAS,YAAY,CAAC,UAAU;IAClC,OAAO,KAAK,GAAG;IACf;GACF;GACA,gBAAgB,GAAG;EACrB;EAEA,KAAK,IAAqB,OAAoC;GAC5D,WAAW;GACX,UAAU,OAAO;GACjB,IAAI,SAAS,eAAe,OAAO,SAAS,GAC1C,KAAK,MAAM,OAAO,OAAO,OAAO,CAAC,GAAG,gBAAgB,GAAG;EAE3D;EAEA,MAAM,QAAyB;GAC7B,IAAI,CAAC,UAAU,OAAO;GACtB,MAAM,OAAO,OAAO,OAAO,CAAC;GAC5B,MAAM,SAAoB,CAAC;GAC3B,IAAI,YAAY;GAChB,KAAK,MAAM,OAAO,MAChB,IAAI;IACF,MAAM,SAAS,GAAG;IAClB;GACF,SAAS,OAAO;IACd,OAAO,KAAK,KAAK;GACnB;GAEF,IAAI,OAAO,SAAS,GAClB,MAAM,IAAI,eACR,QACA,gBAAgB,OAAO,OAAO,MAAM,KAAK,OAAO,gBAAgB,UAAU,YAC5E;GAEF,OAAO;EACT;CACF;AACF;;;;;;;;;;;;;;;ACxFA,IAAa,cAAb,MAAyB;CAEJ;CACA;CAFnB,YACE,OACA,QACA;EAFiB,KAAA,QAAA;EACA,KAAA,SAAA;CAChB;CAEH,IAAI,OAAe;EACjB,OAAO,KAAK;CACd;CAEA,MAAM,IAAO,SAAiB,MAAS,UAAyB,CAAC,GAAyB;EACxF,MAAM,MAAmB;GACvB,IAAI,OAAO,WAAW;GACtB,OAAO,KAAK;GACZ,MAAM;GACN;GACA,SAAS;EACX;EACA,MAAM,KAAK,OAAO,QAAQ,KAAK,OAAO;EACtC,OAAO;CACT;AACF;;;AC/BA,MAAa,qBAAqB;AAClC,MAAa,mBAAmB;;AAGhC,MAAa,eAAe,IAAI,eAA4B,mBAAmB;AAM/E,MAAM,kBAAkB,OAAO,IAAI,6BAA6B;AAEhE,SAAS,aAAuD;CAC9D,MAAM,IAAI;CAIV,OAAQ,EAAE,qCAAqB,IAAI,IAAI;AACzC;;;;;;;;;;;;;;AAeA,SAAgB,WAAW,MAA2C;CACpE,MAAM,QAAQ,WAAW;CACzB,IAAI,QAAQ,MAAM,IAAI,IAAI;CAC1B,IAAI,CAAC,OAAO;EACV,QAAQ,IAAI,eAA4B,qBAAqB,MAAM;EACnE,MAAM,IAAI,MAAM,KAAK;CACvB;CACA,OAAO;AACT;;;ACpCA,MAAM,gBAAgB,4BAA+C,kBAAkB;AAKvF,uBAAuB;CAAE,MAAM;CAAS,SAAS;CAAoB,OAAO;AAAQ,CAAC;;;;;;;;;;;;;AAcrF,SAAgB,UAAU,WAAmC;CAC3D,OAAO,cAAc,EAAE,UAAU,CAAC;AACpC;;;;;;;AAQA,SAAgB,QAAQ,SAAmC;CACzD,QAAQ,QAAgB,gBAAiC;EACvD,MAAM,OAAO,OAAO;EACpB,MAAM,WAAY,YAAA,sBAA8B,IAAI,KAAuC,CAAC;EAC5F,SAAS,KAAK;GAAE;GAAS,YAAY;EAAY,CAAC;EAClD,eAAe,kBAAkB,UAAU,IAAI;CACjD;AACF;;AAGA,SAAgB,mBAAmB,gBAA2C;CAC5E,OAAQ,YAAA,sBAA8B,cAAc,KAAuC,CAAC;AAC9F;;;AC3BA,MAAM,mCAAmB,IAAI,QAAgB;AAE7C,SAAS,cACP,WACA,gBACA,UACA,SAC6B;CAC7B,MAAM,QAAQ,SAAS,QAAQ,MAAM,EAAE,YAAY,OAAO;CAC1D,MAAM,OAAO,MAAM,SAAS,IAAI,QAAQ,SAAS,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS;CACtF,IAAI,KAAK,SAAS,KAAK,CAAC,iBAAiB,IAAI,cAAc,GAAG;EAC5D,iBAAiB,IAAI,cAAc;EAEnC,MAAM,UACJ,oBAFY,MAAM,SAAS,IAAI,aAAa,QAAQ,MAAM,wBAEhC,eAAe,eAAe,KAAK,wBACtC,OAAO,KAAK,EAAE,CAAE,UAAU,EAAE;EACrD,IAAI,UAAU,eAAe,MAAM,SAAS,MAAM,IAAI,MAAM,OAAO;EACnE,IAAI,UAAU,eAAe,MAAM,OAAO,QAAQ,KAAK,OAAO;CAChE;CACA,OAAO,KAAK;AACd;;;;;;;;;;;;;;;;;;AAmBA,eAAsB,iBACpB,WACA,aACA,KAC8B;CAI9B,OAAO,qBAAqB,WAHZ,YACb,OAA0B,OAAO,CAAC,CAClC,KAAK,QAAQ;EAAE,OAAO,GAAG;EAAO,MAAM,GAAG;CAAK,EACJ,GAAG,GAAG;AACrD;;;;;;;AAQA,eAAsB,qBACpB,WACA,SACA,KAC8B;CAC9B,MAAM,aAAa,QAAQ,QAAQ,UAAU,MAAM,KAAK,cAAc,IAAI,KAAK;CAE/E,IAAI,WAAW,WAAW,GAAG;EAC3B,IAAI,UAAU,eAAe,MAAM,OACjC,QAAQ,KACN,qBAAqB,IAAI,KAAK,QAAQ,IAAI,MAAM,uBAAuB,IAAI,MAAM,cACnF;EAEF,OAAO,EAAE,SAAS,EAAE;CACtB;CAOA,OAAO,EAAE,UAAS,MAHK,QAAQ,IAC7B,WAAW,KAAK,UAAU,oBAAoB,WAAW,MAAM,OAAe,GAAG,CAAC,CACpF,EAAA,CAC2B,OAAO,OAAO,CAAC,CAAC,OAAO;AACpD;AAEA,eAAe,oBACb,WACA,gBACA,KACkB;CAClB,MAAM,UAAU,cACd,WACA,gBACA,mBAAmB,cAAc,GACjC,IAAI,IACN;CACA,IAAI,CAAC,SAAS;EACZ,IAAI,UAAU,eAAe,MAAM,OACjC,QAAQ,KACN,uBAAuB,IAAI,KAAK,8BAC3B,eAAe,KAAK,cAAc,IAAI,MAAM,aACnD;EAEF,OAAO;CACT;CAEA,OAAO,qBAAqB,WAAW,OAAO,UAAU;EAGtD,MAAM,WAAY,MAAM,MAAM,aAAa,cAAc;EACzD,MAAM,UAAU,gCACd,SACA,gBACA,QAAQ,YACR,GACF;EAEA,MAAM,SAAS,wBAAwB,SAAS,gBAAgB,QAAQ,YAAY,KAAK;EACzF,MAAM,eAAe,wBACnB,eACA,gBACA,QAAQ,YACR,KACF;EAEA,MAAM,UAAU,wBACd,UACA,gBACA,QAAQ,YACR,KACF,CAAC,CAAC,QAAQ;EAEV,IAAI;GACF,MAAM,eAAe,IAAI;IACvB;IACA;IACA;IACA,aAAa,YAAY,CAAC,GAAG;IAC7B,QAAQ,OAAO,SAAS;KAEtB,OADe,SAAS,QAAQ,WACnB,CAAC,MAAM,UAAU,IAAI;IACpC;GACF,CAAC;GACD,OAAO;EACT,SAAS,OAAO;GAId,qBAAqB,KAAK,CAAC,CAAC,OAAO,OAAO;IACxC,MAAM;IACN,QAAQ,GAAG,eAAe,KAAK,GAAG,OAAO,QAAQ,UAAU;GAC7D,CAAC;GACD,KAAK,MAAM,UAAU,SACnB,IAAI,kBAAkB,QAAQ,KAAK,GAAG;IACpC,MAAM,OAAO,MAAM,OAAO,OAAO;IACjC,OAAO;GACT;GAEF,MAAM;EACR;CACF,CAAC;AACH;;;;;;;;;;;;;;;;;AC9JA,IAAa,uBAAb,MAAkC;CAEb;CACA;CAFnB,YACE,WACA,WACA,QACA,QACA;EAJiB,KAAA,YAAA;EACA,KAAA,YAAA;EAIjB,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,SAAS,UAAU,kBAAkB,WAAW,KAAK,CAAC;GAC5D,IAAI,OAAO,SAAS,GAClB,MAAM,IAAI,MACR,UAAU,MAAM,mDAAmD,OAAO,KAAK,IAAI,EAAE,8FAEvF;EAEJ;EAEA,OAAO,QAAQ,QAAQ,KAAK,QAAQ,GAAG,GAAG,EACxC,UAAU,OAAO,QAAQ,KAAK,WAAW,OAAO,GAAG,EACrD,CAAC;CACH;CAEA,MAAc,QAAQ,KAA8B;EAClD,MAAM,UAAwB,KAAK,UAAU,IAAI,kBAAkB,IAC/D,KAAK,UACF,QAAQ,kBAAkB,CAAC,CAC3B,OAA0B,OAAO,CAAC,CAClC,KAAK,QAAQ;GAAE,OAAO,GAAG;GAAO,MAAM,GAAG;EAAK,EAAE,IACnD,KAAK,UACF,kBAAqC,oBAAoB,EAAE,WAAW,KAAK,CAAC,CAAC,CAC7E,KAAK,WAAW;GAAE,OAAO,MAAM;GAAO,MAAM,MAAM;EAAK,EAAE;EAEhE,MAAM,qBAAqB,KAAK,WAAW,SAAS,GAAG;CACzD;CAEA,WAAmB,OAAgB,KAAqB;EACtD,MAAM,OAAO,KAAK,UAAU,eAAe;EAC3C,IAAI,SAAS,UAAU;EACvB,IAAI,SAAS,SACX,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;EAKhE,qBAAqB,KAAK,SAAS,CAAC,CAAC,OAAO,OAAO;GACjD,MAAM;GACN,QAAQ,GAAG,IAAI,MAAM,GAAG,IAAI;GAC5B,MAAM;EACR,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtCA,MAAM,EAAE,yBAAyB,yBAAyB,aAAiC;CACzF,MAAM;CACN,MAAM;CACN,MAAM,MAAM,WAAW;EAAE,QAAQ,EAAE,UAAU,CAAC;EAAG,QAAQ,EAAE,QAAQ,QAAQ;CAAS,CAAC;CACrF,QAAQ,EAAE,SAAS,cAAc;EAC/B,MAAM,SAAS,QAAQ;EACvB,IAAI,CAAC,UAAU,OAAO,WAAW,GAC/B,MAAM,IAAI,MACR,kMAGF;EAGF,MAAM,kBAAqC,OAAO,KAAK,UAAU;GAC/D,SAAS,WAAW,IAAI;GACxB,aAAa,QAAqB,aAChC,IAAI,YAAY,MAAM,MAAM;GAC9B,QAAQ,CAAC,cAAc,oBAAoB;EAC7C,EAAE;EAEF,OAAO;GACL,WAAW;IACT;KACE,SAAS;KACT,aAAa,MAA0B,EAAE,UAAU,OAAO;KAC1D,QAAQ,CAAC,OAAO;IAClB;IACA;KACE,SAAS;KACT,aAAa,WAAsB,WAA6B,WAC9D,IAAI,qBAAqB,WAAW,WAAW,QAAQ,MAAM;KAC/D,QAAQ;MAAC;MAAW;MAAkB;KAAY;IACpD;IACA,GAAG;GACL;GACA,SAAS;IAAC;IAAc;IAAsB,GAAG,OAAO,KAAK,SAAS,WAAW,IAAI,CAAC;GAAC;EACzF;CACF;AACF,CAAC;AAED,IAAa,cAAb,cAAiC,wBAAwB,CAAC"}

package/dist/request-context-C3nCGJNd.js

@@ -0,0 +1,26 @@
+import { C as InjectionToken } from "./decorate-GcSMAbKn.js";
+//#region src/http/request-context.ts
+const REQUEST_CONTEXT = new InjectionToken("vela.RequestContext");
+function createRequestContext(c) {
+	const bag = /* @__PURE__ */ new Map();
+	const inboundId = c.req.raw.headers.get("x-request-id");
+	return {
+		id: inboundId && inboundId.length > 0 ? inboundId : crypto.randomUUID(),
+		receivedAt: /* @__PURE__ */ new Date(),
+		request: c.req.raw,
+		hono: c,
+		set(key, value) {
+			bag.set(key, value);
+		},
+		get(key) {
+			return bag.get(key);
+		},
+		has(key) {
+			return bag.has(key);
+		}
+	};
+}
+//#endregion
+export { createRequestContext as n, REQUEST_CONTEXT as t };
+
+//# sourceMappingURL=request-context-C3nCGJNd.js.map

package/dist/request-context-C3nCGJNd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context-C3nCGJNd.js","names":[],"sources":["../src/http/request-context.ts"],"sourcesContent":["import type { Context } from 'hono';\nimport { InjectionToken } from '../container/types';\n\n// Per-request injectable populated by RouteManager. Carries a stable\n// request id, the raw Request, the Hono Context (escape hatch), and a\n// free-form bag for cross-cutting metadata that doesn't merit its own\n// injection token (locale, feature flags, trace ids, …). No\n// AsyncLocalStorage — request scope is carried by the per-request child\n// container.\nexport interface RequestContext {\n  readonly id: string;\n  readonly receivedAt: Date;\n  readonly request: Request;\n  readonly hono: Context;\n  set<T>(key: string | symbol, value: T): void;\n  get<T>(key: string | symbol): T | undefined;\n  has(key: string | symbol): boolean;\n}\n\nexport const REQUEST_CONTEXT = new InjectionToken<RequestContext>('vela.RequestContext');\n\nexport function createRequestContext(c: Context): RequestContext {\n  const bag = new Map<string | symbol, unknown>();\n  const inboundId = c.req.raw.headers.get('x-request-id');\n  const id = inboundId && inboundId.length > 0 ? inboundId : crypto.randomUUID();\n  return {\n    id,\n    receivedAt: new Date(),\n    request: c.req.raw,\n    hono: c,\n    set(key, value) {\n      bag.set(key, value);\n    },\n    get<T>(key: string | symbol): T | undefined {\n      return bag.get(key) as T | undefined;\n    },\n    has(key) {\n      return bag.has(key);\n    },\n  };\n}\n"],"mappings":";;AAmBA,MAAa,kBAAkB,IAAI,eAA+B,qBAAqB;AAEvF,SAAgB,qBAAqB,GAA4B;CAC/D,MAAM,sBAAM,IAAI,IAA8B;CAC9C,MAAM,YAAY,EAAE,IAAI,IAAI,QAAQ,IAAI,cAAc;CAEtD,OAAO;EACL,IAFS,aAAa,UAAU,SAAS,IAAI,YAAY,OAAO,WAAW;EAG3E,4BAAY,IAAI,KAAK;EACrB,SAAS,EAAE,IAAI;EACf,MAAM;EACN,IAAI,KAAK,OAAO;GACd,IAAI,IAAI,KAAK,KAAK;EACpB;EACA,IAAO,KAAqC;GAC1C,OAAO,IAAI,IAAI,GAAG;EACpB;EACA,IAAI,KAAK;GACP,OAAO,IAAI,IAAI,GAAG;EACpB;CACF;AACF"}