@owlmeans/queue 0.1.18-rc.40 → 0.1.18-rc.42

package/README.md

@@ -16,7 +16,7 @@ and on the driver only where the application wires itself up.
 ## Installation
 
 ```bash
-bun add @owlmeans/queue@^0.1.18-rc.40
+bun add @owlmeans/queue@^0.1.18-rc.42
 ```
 
 ## Concepts
@@ -114,19 +114,20 @@ When a producer needs a job id, a delay or retries, pass the same protocol objec
 helpers. Never pass its alias.
 
 ```ts
-import { enqueueProtocol, waitForProtocol } from '@owlmeans/queue'
+import { queueProtocolOf } from '@owlmeans/queue'
 
-const queued = await enqueueProtocol(context, appProtocols.invoice.capture, {
+const queue = queueProtocolOf(context)
+const queued = await queue.enqueue(appProtocols.invoice.capture, {
   body: { invoiceId },
 }, {
   id: `capture:${invoiceId}:${attemptSequence}`,   // derived from what the job is about
   delay: 250, attempts: 3, backoff: { type: 'exponential', delay: 250 },
 })
 
-const receipt = await waitForProtocol(context, appProtocols.invoice.capture, queued, { timeout: 120_000 })
+const receipt = await queue.waitFor(appProtocols.invoice.capture, queued, { timeout: 120_000 })
 ```
 
-`queueJobOf(req)` gives a protocol handler `{ id, name, queue, attempt, touch }` when it must compare
+`queueBridgeHelper.queueJobOf(req)` gives a protocol handler `{ id, name, queue, attempt, touch }` when it must compare
 the broker job with a claim it persisted.
 
 ### Processors, hooks and job graphs
@@ -220,7 +221,7 @@ await jobs.take(jobId)                    // cancel and return
 
 ## Guards and errors
 
-`handleJob` rebuilds the request from the envelope and runs the entrypoint's guards the way the
+`entrypointJobsOf(ctx).handle` rebuilds the request from the envelope and runs the entrypoint's guards the way the
 HTTP boundary does, attaching the entity. A guarded queued entrypoint therefore needs the
 producer's credentials in the envelope `headers`. `cfg.queue.envelopeTtl` (seconds) bounds how long
 after `enqueuedAt` an envelope is still accepted; past it, the job answers `EnvelopeExpired`.
@@ -235,17 +236,17 @@ not the job, so read the job back to learn what became of it.
 |---|---|---|
 | `declareQueue(cfg, name, jobs, opts?)` | function | Declare a queue and the job names it accepts; re-declaring replaces |
 | `listenQueues(cfg, ...names)` | function | Name the queues this process consumes |
-| `queueOf(cfg, name)`, `queueOfJob(cfg, job)`, `isListening(cfg, name)` | function | Read declarations back; `queueOf` throws `UnknownQueue` |
+| `queueConfigOf(cfg)` — `.queueOf(name)`, `.queueOfJob(job)`, `.isListening(name)` | helper | Read declarations back; `queueOf` throws `UnknownQueue` |
 | `declareSchedule(cfg, schedule)` | function | Declare a recurring job after checking it; re-declaring an id replaces |
-| `schedulesOf(cfg, queue?)` | function | The declared schedules, of one queue when named |
-| `assertSchedule(cfg, schedule)`, `assertSchedules(cfg)` | function | Check one schedule, or every declared one plus duplicate ids |
-| `enqueueProtocol(ctx, protocol, request, options?)` | function | Enqueue a QUEUE protocol with `JobOptions`, typed by the protocol |
-| `waitForProtocol(ctx, protocol, job, { timeout }?)` | function | Wait for that job and unwrap the typed reply |
-| `queueJobOf(request)` | function | `QueueJobMeta` of the broker job behind a handler's request, or `null` |
+| `queueConfigOf(cfg).schedulesOf(queue?)` | helper | The declared schedules, of one queue when named |
+| `queueConfigOf(cfg)` — `.assertSchedule(schedule)`, `.assertSchedules()` | helper | Check one schedule, or every declared one plus duplicate ids |
+| `queueProtocolOf(ctx).enqueue(protocol, request, options?)` | helper | Enqueue a QUEUE protocol with `JobOptions`, typed by the protocol |
+| `queueProtocolOf(ctx).waitFor(protocol, job, { timeout }?)` | helper | Wait for that job and unwrap the typed reply |
+| `queueBridgeHelper.queueJobOf(request)` | helper | `QueueJobMeta` of the broker job behind a handler's request, or `null` |
 | `appendQueueTransport(ctx, alias?)`, `makeQueueTransport(alias?)` | function | Register the QUEUE transport so `call()` routes through the broker |
 | `queueWorkerMiddleware(alias?)` | function | Start the worker at the Ready stage, only in a process that listens |
-| `handleJob(ctx, job)`, `entrypointProcessor(ctx)`, `servedJobs(ctx)` | function | The bridge a driver dispatches entrypoint jobs through |
-| `requestOf(envelope)`, `assertFresh(envelope, ttl?)` | function | Rebuild a request from an envelope; enforce `envelopeTtl` |
+| `entrypointJobsOf(ctx)` — `.handle(job)`, `.processor()`, `.served()` | helper | The bridge a driver dispatches entrypoint jobs through |
+| `queueBridgeHelper` — `.requestOf(envelope, path)`, `.assertFresh(envelope, ttl?)` | helper | Rebuild a request from an envelope; enforce `envelopeTtl` |
 | `QueueConfig`, `QueueDeclaration`, `QueueWorkerOptions`, `JobOptions`, `ScheduleDeclaration` | type | Configuration shapes |
 | `QueueResource<D, R>` | type | A queue as a resource, plus `queue`, `wait`, `flow`, `counts`, `close` |
 | `JobRecord<D, R>`, `JobEvent<R>`, `FlowSpec<D>` | type | A job as a record, a lifecycle event, a graph node |
@@ -263,7 +264,7 @@ not the job, so read the job back to learn what became of it.
 ## Common pitfalls
 
 - **Queueing work the request could finish.** It adds a second process to deploy and a place to fail.
-- **Passing alias strings to `enqueueProtocol`/`waitForProtocol`.** They take the protocol object and
+- **Passing alias strings to `queueProtocolOf(ctx).enqueue`/`.waitFor`.** They take the protocol object and
   reject strings and non-QUEUE declarations.
 - **Enqueueing a job name the queue did not declare.** It throws `UnknownJobName` rather than
   parking a job nothing can process.
@@ -301,7 +302,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.48
+npx @owlmeans/agent-skills@^0.1.18-rc.51
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/queue",
-  "version": "0.1.18-rc.40",
-  "generatedAt": "2026-10-05T08:32:19.092Z",
+  "version": "0.1.18-rc.42",
+  "generatedAt": "2026-10-06T11:45:57.655Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/queue/SKILL.md

@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/queue
 
 **Layer:** Infra
-**Install:** `"@owlmeans/queue": "^0.1.18-rc.40"` in `dependencies`
+**Install:** `"@owlmeans/queue": "^0.1.18-rc.42"` in `dependencies`
 
 Backend transport contracts only. It carries no broker code — a driver package
 (`@owlmeans/redis-queue`) implements them. Depend on this one from a shared backend package;
@@ -19,8 +19,8 @@ application wires itself up.
 
 A queued call is an immutable entrypoint protocol whose route names `QUEUE_PROTOCOL`.
 Ordinary calls use `ctx.entrypoint(protocol).call(request)`. Code that needs broker options or a
-job handle uses `enqueueProtocol(ctx, protocol, request, options)` and
-`waitForProtocol(ctx, protocol, job)`. Both derive queue and job name from the protocol object and
+job handle uses `queueProtocolOf(ctx).enqueue(protocol, request, options)` and
+`queueProtocolOf(ctx).waitFor(protocol, job)`. Both derive queue and job name from the protocol object and
 preserve its exact request/reply pair; raw strings and non-queue declarations are rejected.
 
 That is what makes it worth having: moving a service-to-service call onto the broker is a change
@@ -61,7 +61,8 @@ protocol(
 )
 ```
 
-Import `job`, `QUEUE_PROTOCOL`, `isQueueRoute` and `queueRouteOptions` from `@owlmeans/queue`.
+Import `job`, `QUEUE_PROTOCOL` and `queueRouteHelper` (`isQueueRoute`, `queueRouteOptions`) from
+`@owlmeans/queue`.
 The generic route package deliberately knows none of the queue option shape.
 
 The alias appears in `declareQueue(...jobs)` only because the broker is a string-keyed adapter.
@@ -70,15 +71,16 @@ Application producers and handlers keep the protocol object.
 When an admission record owns single flight, select the job id atomically first, then enqueue it:
 
 ```typescript
-const queued = await enqueueProtocol(context, tokenBalance.reconcile, {
+const queue = queueProtocolOf(context)
+const queued = await queue.enqueue(tokenBalance.reconcile, {
   body: { projectionId },
 }, { id: claimId, delay: 250, attempts: 3, backoff: { type: 'exponential', delay: 250 } })
-const result = await waitForProtocol(context, tokenBalance.reconcile, queued)
+const result = await queue.waitFor(tokenBalance.reconcile, queued)
 ```
 
 Per-call `id`, delay, attempts, backoff and retention belong here; putting them into an alias-based
-helper forfeits protocol inference. `queueJobOf(request)` exposes `{ id, name, queue, attempt }` to
-the rare protocol handler that must compare a broker job with its persisted claim.
+helper forfeits protocol inference. `queueBridgeHelper.queueJobOf(request)` exposes `{ id, name,
+queue, attempt }` to the rare protocol handler that must compare a broker job with its persisted claim.
 
 `reply: false` makes it fire-and-forget: the call resolves `Accepted` with `{ id, queue }` as soon
 as the BROKER has accepted the enqueue — before any worker has picked the job up, so the resolution
@@ -160,11 +162,11 @@ declareSchedule(cfg, {
 })
 ```
 
-- **Declare it in the shared package, after its queue.** `declareSchedule` runs `assertSchedule`
-  first: the queue must be declared (`UnknownQueue`) and must accept the job name
-  (`UnknownJobName`), exactly one of `every` (a positive integer of milliseconds) and `pattern`
-  (cron), `tz` and `immediately` only with a pattern, never `immediately` with `startDate`, and
-  `opts.id` / `opts.delay` refused — the broker names and places every run
+- **Declare it in the shared package, after its queue.** `declareSchedule` runs
+  `queueConfigOf(cfg).assertSchedule` first: the queue must be declared (`UnknownQueue`) and must
+  accept the job name (`UnknownJobName`), exactly one of `every` (a positive integer of
+  milliseconds) and `pattern` (cron), `tz` and `immediately` only with a pattern, never
+  `immediately` with `startDate`, and `opts.id` / `opts.delay` refused — the broker names and places every run
   (`ScheduleMisdeclared`, message `<id>:<reason>`). Re-declaring an id replaces it.
 - **The id is the identity.** Changing any other field updates the schedule in place; renaming the
   id is one schedule removed and another created.
@@ -179,13 +181,13 @@ declareSchedule(cfg, {
 - **The processor obeys every rule above** — `touch()` through the sweep, and safe to run twice,
   because a restart mid-sweep re-runs it from the start.
 
-`schedulesOf(cfg, queue?)` reads the declarations back; `assertSchedules(cfg)` checks all of them,
-including one written into `cfg.queue.schedules` directly, and refuses a duplicate id.
+`queueConfigOf(cfg).schedulesOf(queue?)` reads the declarations back; `.assertSchedules()` checks
+all of them, including one written into `cfg.queue.schedules` directly, and refuses a duplicate id.
 Which recurring work belongs on a schedule at all is `scheduled-jobs`.
 
 ## A queued call is still a guarded call
 
-`handleJob` rebuilds the request from the envelope and runs the entrypoint as the HTTP boundary
+`entrypointJobsOf(ctx).handle(job)` rebuilds the request from the envelope and runs the entrypoint as the HTTP boundary
 would: the declared guards are tried in order, the first that matches authorizes, the entity is
 attached, and only then does the handler run. A queued entrypoint with guards therefore needs the
 producer's credentials on the envelope's `headers`, and an unauthorized job answers
@@ -214,18 +216,18 @@ that listens to nothing registers no worker and pays nothing.
 
 `canServeModule` in `@owlmeans/server-api/utils` excludes QUEUE routes, the same way it excludes
 sockets: the worker takes those jobs off the broker, and mounting them on the HTTP server too would
-answer every call twice. `servedJobs` is the mirror image — the entrypoints this process both serves and
-listens to, grouped by queue, which is what a driver binds.
+answer every call twice. `entrypointJobsOf(ctx).served()` is the mirror image — the entrypoints
+this process both serves and listens to, grouped by queue, which is what a driver binds.
 
 ## Key exports
 
 | Export | Description |
 |--------|-------------|
-| `enqueueProtocol` / `waitForProtocol` | Typed protocol-object enqueue and result wait; validates protocol kind and queue configuration. |
-| `queueJobOf(request)` / `QueueJobMeta` | Explicit broker identity boundary for a protocol handler, including `touch()` for long work. |
+| `queueProtocolOf(ctx)` — `enqueue` / `waitFor` | Typed protocol-object enqueue and result wait; validates protocol kind and queue configuration. |
+| `queueBridgeHelper.queueJobOf(request)` / `QueueJobMeta` | Explicit broker identity boundary for a protocol handler, including `touch()` for long work. |
 | `declareQueue` / `listenQueues` | Configuration — what exists, and what this process consumes |
-| `declareSchedule` / `schedulesOf` / `assertSchedule` / `assertSchedules` | Recurring jobs — declare, read back, check |
-| `queueOf` / `queueOfJob` / `isListening` | Reading it back; `queueOf` throws `UnknownQueue` |
+| `declareSchedule`; `queueConfigOf(cfg)` — `schedulesOf` / `assertSchedule` / `assertSchedules` | Recurring jobs — declare, read back, check |
+| `queueConfigOf(cfg)` — `queueOf` / `queueOfJob` / `isListening` | Reading it back; `queueOf` throws `UnknownQueue` |
 | `QueueConfig` / `QueueDeclaration` / `QueueWorkerOptions` / `JobOptions` / `ScheduleDeclaration` | The configuration shapes |
 | `QueueResource<D, R>` | A queue addressed as a resource, plus `wait` / `flow` / `counts` / `close` |
 | `JobRecord<D, R>` / `JobState` / `isSettled` / `JobEvent` / `JobEventType` | The record shape and lifecycle |
@@ -236,8 +238,8 @@ listens to, grouped by queue, which is what a driver binds.
 | `QueueAppend` | The `ctx.jobs(queue?)` mixin a driver installs; `QueueDriver` is what a driver supplies |
 | `appendQueueTransport` / `makeQueueTransport` | Binds the QUEUE protocol so `call()` routes through the broker |
 | `queueWorkerMiddleware` | Starts the worker at Ready stage |
-| `handleJob` / `servedJobs` / `entrypointProcessor` | The bridge a driver dispatches through |
-| `requestOf` / `assertFresh` / `JobEnvelope` / `JobReply` | The envelope, and rebuilding a request from it |
+| `entrypointJobsOf(ctx)` — `handle` / `served` / `processor` | The bridge a driver dispatches through |
+| `queueBridgeHelper` — `requestOf` / `assertFresh`; `JobEnvelope` / `JobReply` | The envelope, and rebuilding a request from it |
 | Errors | `QueueError`, `QueueTimeout`, `UnknownJob`, `UnknownJobName`, `UnknownQueue`, `QueueNotListening`, `JobNotServed`, `EnvelopeExpired`, `ScheduleMisdeclared` |
 | Constants | `DEFAULT_ALIAS` (`queue`), `DEFAULT_JOB_TIMEOUT` (60 000 ms), `DEFAULT_ATTEMPTS` (1) |
 

package/agent-meta/skills/scheduled-jobs/SKILL.md

@@ -129,7 +129,7 @@ worker.process<Record<string, never>, SweepReport>(APP_MAINTENANCE, 'app:mainten
 ## Testing
 
 - **The declaration** is category A in the application's own shared package: build the config,
-  `assertSchedules(cfg)`, and pin ids and job names against the queue declaration.
+  `queueConfigOf(cfg).assertSchedules()`, and pin ids and job names against the queue declaration.
 - **The processor** is tested as a function over a fake `JobContext` or a real context — it is
   ordinary code with a `touch`.
 - **Against a broker** (Redis-gated): the worker's Ready-stage start is not awaited by

package/build/bridge/types.d.ts

@@ -0,0 +1,25 @@
+import type { BasicContext } from '@owlmeans/context';
+import type { AbstractRequest } from '@owlmeans/entrypoint';
+import type { JobEnvelope, QueueJobMeta } from '../types.js';
+/** The envelope ↔ request bridge a queued entrypoint call crosses. */
+export interface QueueBridgeHelper {
+    /**
+     * Rebuild the request the producer described. A queued call is still a call: the same guards, the
+     * same filter, the same handler run against it — only the wire is different.
+     */
+    requestOf: (envelope: JobEnvelope, path: string, context?: BasicContext<any>, job?: QueueJobMeta) => AbstractRequest;
+    /** Read broker identity only where an entrypoint truly needs to bind work to an admission claim. */
+    queueJobOf: (request: unknown) => QueueJobMeta | null;
+    /**
+     * Freshness is judged from when the job was ENQUEUED, not from now.
+     *
+     * A signed envelope proves who produced it, and a replay window keeps a captured one from being
+     * useful forever. But a job can legitimately sit behind a long backlog, and judging it on pickup
+     * would reject exactly the work that a busy queue delayed — so the producer's timestamp is what
+     * the window applies to.
+     *
+     * @throws {EnvelopeExpired}
+     */
+    assertFresh: (envelope: JobEnvelope, ttl?: number) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/bridge/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/bridge/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE5D,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,YAAY,KAAK,eAAe,CAAA;IACpH,oGAAoG;IACpG,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,YAAY,GAAG,IAAI,CAAA;IACrD;;;;;;;;;OASG;IACH,WAAW,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3D"}

package/build/bridge/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/bridge/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/bridge/types.ts"],"names":[],"mappings":""}

package/build/bridge.d.ts

@@ -1,30 +1,7 @@
-import type { AbstractRequest } from '@owlmeans/entrypoint';
-import type { BasicContext } from '@owlmeans/context';
-import type { Config, Context, JobContext, JobEnvelope, JobReply, QueueJobMeta } from './types.js';
-/**
- * Rebuild the request the producer described. A queued call is still a call: the same guards, the
- * same filter, the same handler run against it — only the wire is different.
- */
-export declare const requestOf: (envelope: JobEnvelope, path: string, context?: BasicContext<any>, job?: QueueJobMeta) => AbstractRequest;
-/** Read broker identity only where an entrypoint truly needs to bind work to an admission claim. */
+import type { QueueJobMeta } from './types.js';
+import type { QueueBridgeHelper } from './bridge/types.js';
+export declare const createQueueBridgeHelper: () => QueueBridgeHelper;
+export declare const queueBridgeHelper: QueueBridgeHelper;
+/** @deprecated compat:factory-refactor — use `queueBridgeHelper.queueJobOf(…)` */
 export declare const queueJobOf: (request: unknown) => QueueJobMeta | null;
-/**
- * Freshness is judged from when the job was ENQUEUED, not from now.
- *
- * A signed envelope proves who produced it, and a replay window keeps a captured one from being
- * useful forever. But a job can legitimately sit behind a long backlog, and judging it on pickup
- * would reject exactly the work that a busy queue delayed — so the producer's timestamp is what
- * the window applies to.
- *
- * @throws {EnvelopeExpired}
- */
-export declare const assertFresh: (envelope: JobEnvelope, ttl?: number) => void;
-/**
- * Run one queued entrypoint call and describe the outcome.
- *
- * It never throws for a DOMAIN failure — the error is marshalled into the returned reply so the
- * producer can rebuild it as its own class, and so the broker does not count a legitimate refusal
- * as a job to retry. Infrastructure failures are left to propagate: those are what retries are for.
- */
-export declare const handleJob: <C extends Config, T extends Context<C>>(context: T, job: JobContext<JobEnvelope>) => Promise<JobReply>;
 //# sourceMappingURL=bridge.d.ts.map

package/build/bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAkC,MAAM,sBAAsB,CAAA;AAC3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAMrD,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAGlG;;;GAGG;AACH,eAAO,MAAM,SAAS,aACV,WAAW,QAAQ,MAAM,YAAY,YAAY,CAAC,GAAG,CAAC,QAAQ,YAAY,KACnF,eAWD,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,UAAU,YAAa,OAAO,KAAG,YAAY,GAAG,IAK5D,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,aAAc,WAAW,QAAQ,MAAM,KAAG,IAQjE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAU,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,WAC3D,CAAC,OAAO,UAAU,CAAC,WAAW,CAAC,KACvC,OAAO,CAAC,QAAQ,CA2DlB,CAAA"}
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAG1D,eAAO,MAAM,uBAAuB,QAAO,iBAkC1C,CAAA;AAED,eAAO,MAAM,iBAAiB,mBAA4B,CAAA;AAE1D,kFAAkF;AAClF,eAAO,MAAM,UAAU,YAAa,OAAO,KAAG,YAAY,GAAG,IAA6C,CAAA"}

package/build/bridge.js

@@ -1,108 +1,37 @@
-import { EntrypointOutcome, provideResponse } from '@owlmeans/entrypoint';
-import { AuthorizationError } from '@owlmeans/auth';
-import { attachEntity } from '@owlmeans/auth-common';
-import { ResilientError } from '@owlmeans/error';
-import { EnvelopeExpired, JobNotServed } from './errors.js';
-/**
- * Rebuild the request the producer described. A queued call is still a call: the same guards, the
- * same filter, the same handler run against it — only the wire is different.
- */
-export const requestOf = (envelope, path, context, job) => ({
-    alias: envelope.alias,
-    params: (envelope.params ?? {}),
-    body: envelope.body,
-    headers: (envelope.headers ?? {}),
-    query: (envelope.query ?? {}),
-    path,
-    // Handlers reach their context through `original._ctx`, which the HTTP boundary sets on the raw
-    // Fastify request. There is no raw request here, so the shape is supplied deliberately — a
-    // handler must not have to know which transport delivered it.
-    original: context != null || job != null ? { _ctx: context, _job: job } : undefined,
-});
-/** Read broker identity only where an entrypoint truly needs to bind work to an admission claim. */
-export const queueJobOf = (request) => {
-    if (request == null || typeof request !== 'object' || !('original' in request))
-        return null;
-    const original = request.original;
-    if (original == null || typeof original !== 'object' || !('_job' in original))
-        return null;
-    return original._job ?? null;
-};
-/**
- * Freshness is judged from when the job was ENQUEUED, not from now.
- *
- * A signed envelope proves who produced it, and a replay window keeps a captured one from being
- * useful forever. But a job can legitimately sit behind a long backlog, and judging it on pickup
- * would reject exactly the work that a busy queue delayed — so the producer's timestamp is what
- * the window applies to.
- *
- * @throws {EnvelopeExpired}
- */
-export const assertFresh = (envelope, ttl) => {
-    if (ttl == null || envelope.enqueuedAt == null) {
-        return;
-    }
-    const age = (Date.now() - new Date(envelope.enqueuedAt).getTime()) / 1000;
-    if (age > ttl) {
-        throw new EnvelopeExpired(`${envelope.alias}: ${Math.round(age)}s > ${ttl}s`);
-    }
-};
-/**
- * Run one queued entrypoint call and describe the outcome.
- *
- * It never throws for a DOMAIN failure — the error is marshalled into the returned reply so the
- * producer can rebuild it as its own class, and so the broker does not count a legitimate refusal
- * as a job to retry. Infrastructure failures are left to propagate: those are what retries are for.
- */
-export const handleJob = async (context, job) => {
-    const envelope = job.data;
-    try {
-        assertFresh(envelope, context.cfg.queue?.envelopeTtl);
-        const entrypoint = context.entrypoint(envelope.alias);
-        if (entrypoint.handle == null) {
-            throw new JobNotServed(envelope.alias);
-        }
-        const request = requestOf(envelope, entrypoint.path(), context, {
-            id: job.id, name: job.name, queue: job.queue, attempt: job.attempt, touch: job.touch,
-        });
-        const response = provideResponse();
-        const guards = entrypoint.getGuards();
-        if (guards.length > 0) {
-            let matched;
-            for (const alias of guards) {
-                const guard = context.service(alias);
-                if (await guard.match(request, response)) {
-                    matched = guard;
-                    break;
-                }
-            }
-            if (matched == null) {
-                throw new AuthorizationError(`queue:${envelope.alias}`);
-            }
-            const auth = provideResponse();
-            if (!await matched.handle(request, auth)) {
-                throw new AuthorizationError(`queue:${envelope.alias}:${matched.alias}`);
-            }
-            request.auth = auth.value;
-            const entity = await attachEntity(context, request);
-            if (entity != null) {
-                request.entity = entity;
-            }
-        }
-        await entrypoint.handle(request, response);
-        if (response.error != null) {
-            return { error: ResilientError.marshal(response.error).message };
+import { EnvelopeExpired } from './errors.js';
+export const createQueueBridgeHelper = () => {
+    const requestOf = (envelope, path, context, job) => ({
+        alias: envelope.alias,
+        params: (envelope.params ?? {}),
+        body: envelope.body,
+        headers: (envelope.headers ?? {}),
+        query: (envelope.query ?? {}),
+        path,
+        // Handlers reach their context through `original._ctx`, which the HTTP boundary sets on the raw
+        // Fastify request. There is no raw request here, so the shape is supplied deliberately — a
+        // handler must not have to know which transport delivered it.
+        original: context != null || job != null ? { _ctx: context, _job: job } : undefined,
+    });
+    const queueJobOf = (request) => {
+        if (request == null || typeof request !== 'object' || !('original' in request))
+            return null;
+        const original = request.original;
+        if (original == null || typeof original !== 'object' || !('_job' in original))
+            return null;
+        return original._job ?? null;
+    };
+    const assertFresh = (envelope, ttl) => {
+        if (ttl == null || envelope.enqueuedAt == null) {
+            return;
         }
-        return { value: response.value, outcome: response.outcome ?? EntrypointOutcome.Ok };
-    }
-    catch (e) {
-        // A refusal the caller must see as its own class — `ContentRefused`, `AgentLocked` — travels
-        // in the reply. Only a broker- or connection-level fault should ever reach the retry logic:
-        // retrying a refusal just spends the work again to be refused identically.
-        if (e instanceof ResilientError) {
-            return { error: ResilientError.marshal(e).message };
+        const age = (Date.now() - new Date(envelope.enqueuedAt).getTime()) / 1000;
+        if (age > ttl) {
+            throw new EnvelopeExpired(`${envelope.alias}: ${Math.round(age)}s > ${ttl}s`);
         }
-        throw e;
-    }
+    };
+    return { requestOf, queueJobOf, assertFresh };
 };
+export const queueBridgeHelper = createQueueBridgeHelper();
+/** @deprecated compat:factory-refactor — use `queueBridgeHelper.queueJobOf(…)` */
+export const queueJobOf = (request) => queueBridgeHelper.queueJobOf(request);
 //# sourceMappingURL=bridge.js.map

package/build/bridge.js.map

@@ -1 +1 @@
-{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAsB,EAAE;IAC7D,MAAM,SAAS,GAAG,CAChB,QAAqB,EAAE,IAAY,EAAE,OAA2B,EAAE,GAAkB,EACnE,EAAE,CAAC,CAAC;QACrB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,MAAM,EAAE,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAA8B;QAC5D,IAAI,EAAE,QAAQ,CAAC,IAA+B;QAC9C,OAAO,EAAE,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAA+B;QAC/D,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,CAA6B;QACzD,IAAI;QACJ,gGAAgG;QAChG,2FAA2F;QAC3F,8DAA8D;QAC9D,QAAQ,EAAE,OAAO,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS;KACpF,CAAC,CAAA;IAEF,MAAM,UAAU,GAAG,CAAC,OAAgB,EAAuB,EAAE;QAC3D,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,CAAC,UAAU,IAAI,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;QAC3F,MAAM,QAAQ,GAAI,OAAkC,CAAC,QAAQ,CAAA;QAC7D,IAAI,QAAQ,IAAI,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,IAAI,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAA;QAC1F,OAAQ,QAAoC,CAAC,IAAI,IAAI,IAAI,CAAA;IAC3D,CAAC,CAAA;IAED,MAAM,WAAW,GAAG,CAAC,QAAqB,EAAE,GAAY,EAAQ,EAAE;QAChE,IAAI,GAAG,IAAI,IAAI,IAAI,QAAQ,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;YAC/C,OAAM;QACR,CAAC;QACD,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAA;QACzE,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,eAAe,CAAC,GAAG,QAAQ,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC,CAAA;QAC/E,CAAC;IACH,CAAC,CAAA;IAED,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,CAAA;AAC/C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,uBAAuB,EAAE,CAAA;AAE1D,kFAAkF;AAClF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,OAAgB,EAAuB,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA"}

package/build/config.d.ts

@@ -13,21 +13,6 @@ export declare const declareQueue: <C extends Config>(cfg: C, name: string, jobs
  * worker, which is why it lives in the process's own config and never in a declaration.
  */
 export declare const listenQueues: <C extends Config>(cfg: C, ...names: string[]) => C;
-/**
- * @throws {UnknownQueue}
- */
-export declare const queueOf: <C extends Config>(cfg: C, name: string) => QueueDeclaration;
-export declare const queueOfJob: <C extends Config>(cfg: C, job: string) => QueueDeclaration | undefined;
-export declare const isListening: <C extends Config>(cfg: C, name: string) => boolean;
-/**
- * Whether the broker can carry a schedule out as written. Nothing is recorded or changed.
- *
- * @throws {ScheduleMisdeclared} naming the schedule id and the reason.
- * @throws {UnknownQueue} when the schedule's queue is not declared.
- * @throws {UnknownJobName} when that queue does not accept the schedule's job name — a scheduled
- * run of a name nothing declares would fail on every tick instead of once, at declaration.
- */
-export declare const assertSchedule: <C extends Config>(cfg: C, schedule: ScheduleDeclaration) => void;
 /**
  * Add a recurring job to the shared configuration. Declare the queue first — a schedule is checked
  * against it here. Declaring an id twice replaces, like `declareQueue`.
@@ -38,13 +23,12 @@ export declare const assertSchedule: <C extends Config>(cfg: C, schedule: Schedu
  * @throws {ScheduleMisdeclared} / {UnknownQueue} / {UnknownJobName} — see `assertSchedule`.
  */
 export declare const declareSchedule: <C extends Config>(cfg: C, schedule: ScheduleDeclaration) => C;
-/** The declared schedules, of one queue when it is named. */
+/** @deprecated compat:factory-refactor — use `queueConfigOf(cfg).queueOfJob(…)` */
+export declare const queueOfJob: <C extends Config>(cfg: C, job: string) => QueueDeclaration | undefined;
+/** @deprecated compat:factory-refactor — use `queueConfigOf(cfg).isListening(…)` */
+export declare const isListening: <C extends Config>(cfg: C, name: string) => boolean;
+/** @deprecated compat:factory-refactor — use `queueConfigOf(cfg).schedulesOf(…)` */
 export declare const schedulesOf: <C extends Config>(cfg: C, queue?: string) => ScheduleDeclaration[];
-/**
- * Check every declared schedule, including any written into the configuration without
- * `declareSchedule`, and refuse two under one id.
- *
- * @throws {ScheduleMisdeclared} / {UnknownQueue} / {UnknownJobName} for the first one that fails.
- */
+/** @deprecated compat:factory-refactor — use `queueConfigOf(cfg).assertSchedules()` */
 export declare const assertSchedules: <C extends Config>(cfg: C) => void;
 //# sourceMappingURL=config.d.ts.map

package/build/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,mBAAmB,EAC9E,MAAM,YAAY,CAAA;AAGnB;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,OACtC,CAAC,QAAQ,MAAM,QAAQ,MAAM,EAAE,SAAS;IAAE,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,KAClG,CAcF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,YAAY,MAAM,EAAE,KAAG,CAM3E,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,QAAQ,MAAM,KAAG,gBAQhE,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,OAAO,MAAM,KAAG,gBAAgB,GAAG,SACpB,CAAA;AAElE,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,QAAQ,MAAM,KAAG,OACzB,CAAA;AAM5C;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,YAAY,mBAAmB,KAAG,IAoDxF,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,YAAY,mBAAmB,KAAG,CAezF,CAAA;AAED,6DAA6D;AAC7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,UAAU,MAAM,KAAG,mBAAmB,EACE,CAAA;AAE5F;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,KAAG,IAS1D,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,mBAAmB,EAC9E,MAAM,YAAY,CAAA;AAGnB;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,OACtC,CAAC,QAAQ,MAAM,QAAQ,MAAM,EAAE,SAAS;IAAE,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,KAClG,CAcF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,YAAY,MAAM,EAAE,KAAG,CAM3E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,YAAY,mBAAmB,KAAG,CAezF,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,OAAO,MAAM,KAAG,gBAAgB,GAAG,SAClD,CAAA;AAEpC,oFAAoF;AACpF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,QAAQ,MAAM,KAAG,OAC/B,CAAA;AAEtC,oFAAoF;AACpF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,UAAU,MAAM,KAAG,mBAAmB,EACnD,CAAA;AAEvC,uFAAuF;AACvF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,OAAO,CAAC,KAAG,IAA4C,CAAA"}