@owlmeans/queue 0.1.18-rc.7 → 0.1.18-rc.9

package/build/errors.d.ts

@@ -0,0 +1,59 @@
+import { ResilientError } from '@owlmeans/error';
+export declare class QueueError extends ResilientError {
+    static typeName: string;
+    constructor(message?: string);
+}
+/**
+ * The caller stopped waiting. The job is untouched — it may still be queued, running, or already
+ * finished; only the wait ended. Read the job back to learn which.
+ */
+export declare class QueueTimeout extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+/** No job with that id in this queue — it never existed, or it was removed after completing. */
+export declare class UnknownJob extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+/**
+ * A job name the queue does not declare. Declaring every job a queue accepts is what keeps an
+ * enqueue from succeeding into a queue where nothing can ever process it.
+ */
+export declare class UnknownJobName extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+/** A queue asked for that no declaration names. */
+export declare class UnknownQueue extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+/**
+ * This process was asked to consume a queue it does not listen to. Which queues a process
+ * consumes is configuration (`cfg.queue.listen`), so this is a deployment question, not a code
+ * one — the same binary is a producer or a worker depending on it.
+ */
+export declare class QueueNotListening extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+/**
+ * The job named an entrypoint this process does not serve. Unlike a missing queue this is not a
+ * declaration problem: the alias exists, but nothing here elevated it, so the job was taken by a
+ * worker that cannot run it.
+ */
+export declare class JobNotServed extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+/**
+ * The signed envelope is older than the configured lifetime. Freshness is judged from when the
+ * producer enqueued the job, not from when a worker picked it up, so a long backlog does not
+ * invalidate work that was legitimate when it was submitted.
+ */
+export declare class EnvelopeExpired extends QueueError {
+    static typeName: string;
+    constructor(msg: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,qBAAa,UAAW,SAAQ,cAAc;IAC5C,OAAuB,QAAQ,SAAe;IAE9C,YAAY,OAAO,GAAE,MAAgB,EAEpC;CACF;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C,OAAuB,QAAQ,SAAkC;IAEjE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF;AAED,gGAAgG;AAChG,qBAAa,UAAW,SAAQ,UAAU;IACxC,OAAuB,QAAQ,SAAqC;IAEpE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF;AAED;;;GAGG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAC5C,OAAuB,QAAQ,SAAyC;IAExE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF;AAED,mDAAmD;AACnD,qBAAa,YAAa,SAAQ,UAAU;IAC1C,OAAuB,QAAQ,SAAuC;IAEtE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;IAC/C,OAAuB,QAAQ,SAAuC;IAEtE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF;AAED;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C,OAAuB,QAAQ,SAAuC;IAEtE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF;AAED;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAuB,QAAQ,SAA0C;IAEzE,YAAY,GAAG,EAAE,MAAM,EAGtB;CACF"}

package/build/errors.js

@@ -0,0 +1,90 @@
+import { ResilientError } from '@owlmeans/error';
+export class QueueError extends ResilientError {
+    static typeName = 'QueueError';
+    constructor(message = 'error') {
+        super(QueueError.typeName, `queue:${message}`);
+    }
+}
+/**
+ * The caller stopped waiting. The job is untouched — it may still be queued, running, or already
+ * finished; only the wait ended. Read the job back to learn which.
+ */
+export class QueueTimeout extends QueueError {
+    static typeName = `${QueueError.typeName}Timeout`;
+    constructor(msg) {
+        super(`timeout:${msg}`);
+        this.type = QueueTimeout.typeName;
+    }
+}
+/** No job with that id in this queue — it never existed, or it was removed after completing. */
+export class UnknownJob extends QueueError {
+    static typeName = `${QueueError.typeName}UnknownJob`;
+    constructor(msg) {
+        super(`unknown-job:${msg}`);
+        this.type = UnknownJob.typeName;
+    }
+}
+/**
+ * A job name the queue does not declare. Declaring every job a queue accepts is what keeps an
+ * enqueue from succeeding into a queue where nothing can ever process it.
+ */
+export class UnknownJobName extends QueueError {
+    static typeName = `${QueueError.typeName}UnknownJobName`;
+    constructor(msg) {
+        super(`unknown-job-name:${msg}`);
+        this.type = UnknownJobName.typeName;
+    }
+}
+/** A queue asked for that no declaration names. */
+export class UnknownQueue extends QueueError {
+    static typeName = `${QueueError.typeName}UnknownQueue`;
+    constructor(msg) {
+        super(`unknown-queue:${msg}`);
+        this.type = UnknownQueue.typeName;
+    }
+}
+/**
+ * This process was asked to consume a queue it does not listen to. Which queues a process
+ * consumes is configuration (`cfg.queue.listen`), so this is a deployment question, not a code
+ * one — the same binary is a producer or a worker depending on it.
+ */
+export class QueueNotListening extends QueueError {
+    static typeName = `${QueueError.typeName}NotListening`;
+    constructor(msg) {
+        super(`not-listening:${msg}`);
+        this.type = QueueNotListening.typeName;
+    }
+}
+/**
+ * The job named an entrypoint this process does not serve. Unlike a missing queue this is not a
+ * declaration problem: the alias exists, but nothing here elevated it, so the job was taken by a
+ * worker that cannot run it.
+ */
+export class JobNotServed extends QueueError {
+    static typeName = `${QueueError.typeName}JobNotServed`;
+    constructor(msg) {
+        super(`job-not-served:${msg}`);
+        this.type = JobNotServed.typeName;
+    }
+}
+/**
+ * The signed envelope is older than the configured lifetime. Freshness is judged from when the
+ * producer enqueued the job, not from when a worker picked it up, so a long backlog does not
+ * invalidate work that was legitimate when it was submitted.
+ */
+export class EnvelopeExpired extends QueueError {
+    static typeName = `${QueueError.typeName}EnvelopeExpired`;
+    constructor(msg) {
+        super(`envelope-expired:${msg}`);
+        this.type = EnvelopeExpired.typeName;
+    }
+}
+ResilientError.registerErrorClass(QueueError);
+ResilientError.registerErrorClass(QueueTimeout);
+ResilientError.registerErrorClass(UnknownJob);
+ResilientError.registerErrorClass(UnknownJobName);
+ResilientError.registerErrorClass(UnknownQueue);
+ResilientError.registerErrorClass(QueueNotListening);
+ResilientError.registerErrorClass(JobNotServed);
+ResilientError.registerErrorClass(EnvelopeExpired);
+//# sourceMappingURL=errors.js.map

package/build/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,MAAM,OAAO,UAAW,SAAQ,cAAc;IACrC,MAAM,CAAU,QAAQ,GAAG,YAAY,CAAA;IAE9C,YAAY,OAAO,GAAW,OAAO;QACnC,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC,CAAA;IAChD,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,YAAa,SAAQ,UAAU;IACnC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,SAAS,CAAA;IAEjE,YAAY,GAAW;QACrB,KAAK,CAAC,WAAW,GAAG,EAAE,CAAC,CAAA;QACvB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAA;IACnC,CAAC;CACF;AAED,gGAAgG;AAChG,MAAM,OAAO,UAAW,SAAQ,UAAU;IACjC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,YAAY,CAAA;IAEpE,YAAY,GAAW;QACrB,KAAK,CAAC,eAAe,GAAG,EAAE,CAAC,CAAA;QAC3B,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAA;IACjC,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,UAAU;IACrC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,gBAAgB,CAAA;IAExE,YAAY,GAAW;QACrB,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC,CAAA;QAChC,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,QAAQ,CAAA;IACrC,CAAC;CACF;AAED,mDAAmD;AACnD,MAAM,OAAO,YAAa,SAAQ,UAAU;IACnC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,cAAc,CAAA;IAEtE,YAAY,GAAW;QACrB,KAAK,CAAC,iBAAiB,GAAG,EAAE,CAAC,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAA;IACnC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,iBAAkB,SAAQ,UAAU;IACxC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,cAAc,CAAA;IAEtE,YAAY,GAAW;QACrB,KAAK,CAAC,iBAAiB,GAAG,EAAE,CAAC,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC,QAAQ,CAAA;IACxC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,YAAa,SAAQ,UAAU;IACnC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,cAAc,CAAA;IAEtE,YAAY,GAAW;QACrB,KAAK,CAAC,kBAAkB,GAAG,EAAE,CAAC,CAAA;QAC9B,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAA;IACnC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,eAAgB,SAAQ,UAAU;IACtC,MAAM,CAAU,QAAQ,GAAG,GAAG,UAAU,CAAC,QAAQ,iBAAiB,CAAA;IAEzE,YAAY,GAAW;QACrB,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC,CAAA;QAChC,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAA;IACtC,CAAC;CACF;AAED,cAAc,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAA;AAC7C,cAAc,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;AAC/C,cAAc,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAA;AAC7C,cAAc,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAA;AACjD,cAAc,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;AAC/C,cAAc,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAA;AACpD,cAAc,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;AAC/C,cAAc,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAA"}

package/build/index.d.ts

@@ -1 +1,8 @@
+export * from './types.js';
+export * from './consts.js';
+export * from './errors.js';
+export * from './config.js';
+export * from './transport.js';
+export * from './bridge.js';
+export * from './worker.js';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -1,2 +1,8 @@
-"use strict";
+export * from './types.js';
+export * from './consts.js';
+export * from './errors.js';
+export * from './config.js';
+export * from './transport.js';
+export * from './bridge.js';
+export * from './worker.js';
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/transport.d.ts

@@ -0,0 +1,15 @@
+import type { EntrypointTransport } from '@owlmeans/entrypoint';
+import type { Config, Context } from './types.js';
+/**
+ * The producing half of the bridge: it turns a call on a QUEUE entrypoint into a job, and the
+ * job's outcome back into a reply.
+ *
+ * Registering it is the whole opt-in. `apiHandler` looks up a transport by the route's protocol,
+ * so a consumer writes `ep.call(...)` against a declaration it shares with every other kind of
+ * entrypoint and never learns which one carried it. That is also why the envelope is built from
+ * the request rather than from the entrypoint: the far side rebuilds a request, and anything only
+ * HTTP understands would not survive the trip anyway.
+ */
+export declare const makeQueueTransport: (alias?: string) => EntrypointTransport;
+export declare const appendQueueTransport: <C extends Config, T extends Context<C> = Context<C>>(context: T, alias?: string) => T;
+//# sourceMappingURL=transport.d.ts.map

package/build/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAqC,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAKlG,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAsC,MAAM,YAAY,CAAA;AAIrF;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,WAAW,MAAM,wBAmD/C,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,WAC7E,CAAC,UAAU,MAAM,KACzB,CAMF,CAAA"}

package/build/transport.js

@@ -0,0 +1,62 @@
+import { assertContext, createService } from '@owlmeans/context';
+import { EntrypointOutcome, transportAlias } from '@owlmeans/entrypoint';
+import { RouteProtocols } from '@owlmeans/route';
+import { ResilientError } from '@owlmeans/error';
+import { DEFAULT_JOB_TIMEOUT } from './consts.js';
+import { UnknownQueue } from './errors.js';
+/**
+ * The producing half of the bridge: it turns a call on a QUEUE entrypoint into a job, and the
+ * job's outcome back into a reply.
+ *
+ * Registering it is the whole opt-in. `apiHandler` looks up a transport by the route's protocol,
+ * so a consumer writes `ep.call(...)` against a declaration it shares with every other kind of
+ * entrypoint and never learns which one carried it. That is also why the envelope is built from
+ * the request rather than from the entrypoint: the far side rebuilds a request, and anything only
+ * HTTP understands would not survive the trip anyway.
+ */
+export const makeQueueTransport = (alias = transportAlias(RouteProtocols.QUEUE)) => {
+    const location = `queue-transport:${alias}`;
+    const service = createService(alias, {
+        protocol: RouteProtocols.QUEUE,
+        handle: (async (req, res) => {
+            const context = assertContext(service.ctx, location);
+            const entrypoint = context.entrypoint(req.alias);
+            const route = entrypoint.route.route;
+            if (route.queue == null) {
+                throw new UnknownQueue(`${req.alias}: route declares no queue`);
+            }
+            const jobs = context.jobs(route.queue);
+            const envelope = {
+                alias: req.alias,
+                params: req.params,
+                body: req.body,
+                query: req.query,
+                headers: req.headers,
+                enqueuedAt: new Date().toISOString(),
+            };
+            const job = await jobs.create({ queue: route.queue, name: req.alias, data: envelope });
+            // `reply: false` says the caller is not waiting for the work, only for the promise that it
+            // was taken. `Accepted` plus the job's identity is the whole answer — enough to watch it.
+            if (route.reply === false) {
+                res.resolve({ id: job.id, queue: route.queue }, EntrypointOutcome.Accepted);
+                return;
+            }
+            const reply = await jobs.wait(job.id, {
+                timeout: req.timeout ?? route.timeout ?? DEFAULT_JOB_TIMEOUT
+            });
+            // A processor reports a domain failure by returning it, so it crosses the hop as the class
+            // it was thrown as rather than as a string a caller would have to parse.
+            if (reply?.error != null) {
+                throw ResilientError.ensure(reply.error);
+            }
+            res.resolve(reply?.value, reply?.outcome ?? EntrypointOutcome.Ok);
+        })
+    });
+    return service;
+};
+export const appendQueueTransport = (context, alias) => {
+    const service = makeQueueTransport(alias);
+    context.registerService(service);
+    return context;
+};
+//# sourceMappingURL=transport.js.map

package/build/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"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"}

package/build/types.d.ts

@@ -0,0 +1,240 @@
+import type { BasicConfig, BasicContext, InitializedService } from '@owlmeans/context';
+import type { PubSubResource, Resource, ResourceRecord } from '@owlmeans/resource';
+import type { AbstractRequest, AbstractResponse } from '@owlmeans/entrypoint';
+import type { JobEventType, JobState } from './consts.js';
+/**
+ * Everything the monorepo knows about its queues, declared in the shared backend package so that
+ * producer and consumer read the same list. A process becomes a worker by naming queues in
+ * `listen` — nothing in a declaration decides where it runs.
+ */
+export interface QueueConfig {
+    queues?: QueueDeclaration[];
+    /** The queues THIS process consumes. Absent or empty means producer only. */
+    listen?: string[];
+    /** Which db service carries the queues. Defaults to the queue service's own alias. */
+    db?: string;
+    defaults?: JobOptions;
+    /**
+     * How long a signed job envelope stays acceptable, in seconds. It bounds both the freshness
+     * check and the nonce cache, so a job delayed behind a long backlog is still admitted.
+     */
+    envelopeTtl?: number;
+}
+export interface QueueDeclaration {
+    name: string;
+    /**
+     * The job names this queue accepts. A job the queue does not declare is refused at enqueue
+     * time rather than becoming a job nothing can process.
+     */
+    jobs: string[];
+    worker?: QueueWorkerOptions;
+    defaults?: JobOptions;
+}
+export interface QueueWorkerOptions {
+    concurrency?: number;
+    /**
+     * How long a job may hold its lock without reporting progress. A processor that runs longer
+     * than this between `touch()` calls is treated as stalled and its job is handed to someone else.
+     */
+    lockDuration?: number;
+    stalledInterval?: number;
+    maxStalledCount?: number;
+}
+export interface JobOptions {
+    attempts?: number;
+    backoff?: {
+        type: 'fixed' | 'exponential';
+        delay: number;
+    };
+    delay?: number;
+    priority?: number;
+    /**
+     * A caller-chosen identity for the job. Enqueueing the same id twice while the first is still
+     * around is a no-op, which is what makes an admission step safe to retry.
+     */
+    id?: string;
+    removeOnComplete?: boolean | number;
+    removeOnFail?: boolean | number;
+}
+/**
+ * A job as a RECORD — the same shape the resource contract reads and writes, so inspecting a
+ * queue is `list`/`get`/`count` rather than a broker-specific API.
+ */
+export interface JobRecord<D = unknown, R = unknown> extends ResourceRecord {
+    queue: string;
+    name: string;
+    data: D;
+    state?: JobState;
+    result?: R;
+    error?: string;
+    attempts?: number;
+    progress?: unknown;
+    parentId?: string;
+    createdAt?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    opts?: JobOptions;
+}
+export interface JobEvent<R = unknown> {
+    type: JobEventType;
+    id: string;
+    queue: string;
+    /**
+     * Empty when the job is already gone. A broker's completion event carries only an id, so the
+     * name is read back from the job — and a queue that removes jobs on completion has nothing left
+     * to read. Subscribe for the id and the outcome; do not branch on the name.
+     */
+    name: string;
+    result?: R;
+    error?: string;
+    progress?: unknown;
+}
+/** A node of a job graph: children run first, siblings run together. */
+export interface FlowSpec<D = unknown> {
+    name: string;
+    queue?: string;
+    data: D;
+    opts?: JobOptions;
+    children?: FlowSpec[];
+}
+/**
+ * One queue, addressed as a resource.
+ *
+ * `create` enqueues, `get`/`load`/`list`/`count` inspect, `delete`/`take` cancel. What the base
+ * contract cannot express — waiting for an answer, submitting a graph, releasing the connection —
+ * is added here.
+ *
+ * Three places where the base `Resource` contract reads differently against a broker, because a
+ * job is not a row:
+ * - `create` does NOT throw `RecordExists` for a repeated `opts.id`. Re-enqueueing an id that is
+ *   still around returns the existing job, which is the idempotency that makes an admission step
+ *   safe to retry.
+ * - `WriteOptions.ttl` is refused. A job's lifetime is `removeOnComplete`/`removeOnFail` —
+ *   explicit deletion once it has finished, not expiry while it waits.
+ * - `update`/`save` reach only the job's `data`. Everything else about a job belongs to the
+ *   broker, and an implementation refuses rather than pretending to write it.
+ */
+export interface QueueResource<D = unknown, R = unknown> extends Resource<JobRecord<D, R>>, PubSubResource<JobEvent<R>> {
+    queue: string;
+    /**
+     * Release the connections this queue holds.
+     *
+     * Watching for completions means a blocking connection, and a process that never releases it
+     * does not exit. Nothing else in the resource contract can express that, so it lives here and a
+     * producer calls it on shutdown.
+     */
+    close: () => Promise<void>;
+    /**
+     * Wait for a job's return value.
+     * @throws {QueueTimeout} when the wait elapses — the job itself is left alone.
+     * @throws the processor's own error, rebuilt as its original class.
+     */
+    wait: (id: string, opts?: {
+        timeout?: number;
+    }) => Promise<R>;
+    /** Submit a graph and get its root back. Children complete before their parent starts. */
+    flow: (root: FlowSpec<D>) => Promise<JobRecord<D, R>>;
+    counts: () => Promise<Record<JobState, number>>;
+}
+/**
+ * What a processor is handed. `data` is the job's payload; everything else is the means to stay
+ * alive and to read what the children reported.
+ */
+export interface JobContext<D = unknown> {
+    id: string;
+    name: string;
+    queue: string;
+    attempt: number;
+    data: D;
+    signal: AbortSignal;
+    /**
+     * Renew the lock. A processor that runs a long loop MUST call it as it goes: the broker judges
+     * liveness by the lock, so silence for longer than `lockDuration` is indistinguishable from a
+     * dead worker, and the job is re-run somewhere else while this one is still working on it.
+     */
+    touch: () => Promise<void>;
+    progress: (value: unknown) => Promise<void>;
+    /**
+     * What the children returned, keyed by child job id.
+     *
+     * A broker keys them by its own fully qualified job key; an implementation re-keys to the bare
+     * id, so two children of one parent that live in DIFFERENT queues and happen to share an id
+     * collide here. Give the children of a cross-queue flow distinct ids.
+     */
+    children: <T = unknown>() => Promise<Record<string, T>>;
+    failedChildren: () => Promise<Record<string, string>>;
+}
+export interface JobProcessor<D = unknown, R = unknown> {
+    (job: JobContext<D>): Promise<R>;
+}
+/**
+ * The consuming half. It is registered only in processes that consume: `start()` binds the
+ * queues named in `cfg.listen` and dispatches by job name, to a processor registered here or to
+ * an entrypoint served in this process.
+ */
+export interface QueueWorkerService extends InitializedService {
+    process: <D, R>(queue: string, name: string, processor: JobProcessor<D, R>) => void;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    /** The queues this process actually consumes. Empty in a producer. */
+    listening: () => string[];
+    /**
+     * Bind the application's reactions to job lifecycle events. Registering more than once merges,
+     * so an application composed of several parts can each contribute what it cares about.
+     *
+     * It belongs on the contract rather than on a driver because `onJobDead` is where an
+     * application COMPENSATES — releases the lock the admission step took, marks the record failed —
+     * and that behaviour must not have to be rewritten when the broker changes.
+     */
+    hooks: (hooks: QueueHooks) => void;
+}
+/**
+ * The envelope a queued entrypoint call travels in. It is the request, minus everything that only
+ * means something to HTTP — the transport rebuilds a request from it on the far side.
+ */
+export interface JobEnvelope {
+    alias: string;
+    params?: Record<string, unknown>;
+    body?: unknown;
+    query?: Record<string, unknown>;
+    headers?: Record<string, string | undefined>;
+    /** When the producer enqueued it — freshness is judged here, not at processing time. */
+    enqueuedAt?: string;
+}
+/** What a processor returns for an entrypoint job, so the caller can rebuild the reply. */
+export interface JobReply<T = unknown> {
+    value?: T;
+    outcome?: string;
+    error?: unknown;
+}
+export interface QueueHooks {
+    wrapHandler?: (job: JobContext, next: () => Promise<unknown>) => Promise<unknown>;
+    onJobResult?: (event: JobEvent) => void | Promise<void>;
+    onJobStalled?: (meta: {
+        id: string;
+        queue: string;
+        name: string;
+    }, phase: 'stalled' | 'failed') => void | Promise<void>;
+    /**
+     * The job is finished for good — retries exhausted, or it was dropped. This is where an
+     * application compensates: release the lock the admission step took, mark the record failed.
+     */
+    onJobDead?: (job: JobRecord, reason: string) => void | Promise<void>;
+}
+export interface QueueDriver {
+    resource: <D, R>(queue: string) => QueueResource<D, R>;
+    worker: () => QueueWorkerService;
+}
+export interface Config extends BasicConfig {
+    queue?: QueueConfig;
+}
+export interface Context<C extends Config = Config> extends BasicContext<C> {
+}
+export interface QueueAppend {
+    jobs: <D = unknown, R = unknown>(queue?: string) => QueueResource<D, R>;
+}
+export interface QueueTransportRequest extends AbstractRequest {
+}
+export interface QueueTransportResponse extends AbstractResponse<unknown> {
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEzD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC3B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,sFAAsF;IACtF,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,UAAU,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,QAAQ,CAAC,EAAE,UAAU,CAAA;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IACnC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,CAAE,SAAQ,cAAc;IACzE,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,MAAM,CAAC,EAAE,CAAC,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,IAAI,EAAE,YAAY,CAAA;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,CAAC,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,wEAAwE;AACxE,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,CAAC,CAAA;IACP,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,CACrD,SAAQ,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC9D,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B;;;;OAIG;IACH,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;IAC7D,0FAA0F;IAC1F,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACrD,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAA;CAChD;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,CAAC,CAAA;IACP,MAAM,EAAE,WAAW,CAAA;IACnB;;;;OAIG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3C;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,CAAC,GAAG,OAAO,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAA;IACvD,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CACtD;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACpD,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC5D,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAA;IACnF,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,sEAAsE;IACtE,SAAS,EAAE,MAAM,MAAM,EAAE,CAAA;IACzB;;;;;;;OAOG;IACH,KAAK,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IAC5C,wFAAwF;IACxF,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,2FAA2F;AAC3F,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,KAAK,CAAC,EAAE,CAAC,CAAA;IACT,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACjF,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACvD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACvH;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACrE;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACtD,MAAM,EAAE,MAAM,kBAAkB,CAAA;CACjC;AAED,MAAM,WAAW,MAAO,SAAQ,WAAW;IACzC,KAAK,CAAC,EAAE,WAAW,CAAA;CACpB;AAED,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CACxE;AAED,MAAM,WAAW,qBAAsB,SAAQ,eAAe;CAC7D;AAED,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB,CAAC,OAAO,CAAC;CACxE"}

package/build/types.js

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

package/build/types.js.map

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

package/build/worker.d.ts

@@ -0,0 +1,27 @@
+import type { Middleware } from '@owlmeans/context';
+import type { CommonEntrypoint } from '@owlmeans/entrypoint';
+import type { Config, Context, JobEnvelope, JobProcessor } from './types.js';
+/**
+ * Every queued entrypoint this process both SERVES and LISTENS to, grouped by queue.
+ *
+ * Both halves are required and they answer different questions. Serving is about code — the alias
+ * was elevated here, so a handler exists. Listening is about deployment — this process was
+ * configured to consume that queue. A worker that bound queues by what it can serve would make
+ * every deployment of the same binary a worker for everything it happens to import.
+ */
+export declare const servedJobs: <C extends Config, T extends Context<C>>(context: T) => Map<string, CommonEntrypoint[]>;
+/**
+ * A processor that runs a queued entrypoint call. The driver dispatches by job name, and an
+ * entrypoint job's name IS its alias — which is what lets one worker carry both entrypoint jobs
+ * and the internal steps an application registers with `process()`.
+ */
+export declare const entrypointProcessor: <C extends Config, T extends Context<C>>(context: T) => JobProcessor<JobEnvelope, unknown>;
+/**
+ * Start the worker once the context is ready.
+ *
+ * Ready stage, not Loading: processors are registered while the application wires itself up, and
+ * binding the queues before that finished would take jobs this process cannot yet run. A process
+ * that listens to nothing registers no worker at all, so a producer pays nothing for this.
+ */
+export declare const queueWorkerMiddleware: (alias?: string) => Middleware;
+//# sourceMappingURL=worker.d.ts.map

package/build/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE5D,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAc,WAAW,EAAE,YAAY,EAAsB,MAAM,YAAY,CAAA;AAI5G;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,WACtD,CAAC,KACT,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAoBhC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,WAC/D,CAAC,KACT,YAAY,CAAC,WAAW,EAAE,OAAO,CACmC,CAAA;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,WAAW,MAAM,KAAmB,UAcpE,CAAA"}

package/build/worker.js

@@ -0,0 +1,58 @@
+import { MiddlewareStage, MiddlewareType, AppType } from '@owlmeans/context';
+import { RouteProtocols } from '@owlmeans/route';
+import { handleJob } from './bridge.js';
+import { DEFAULT_ALIAS } from './consts.js';
+/**
+ * Every queued entrypoint this process both SERVES and LISTENS to, grouped by queue.
+ *
+ * Both halves are required and they answer different questions. Serving is about code — the alias
+ * was elevated here, so a handler exists. Listening is about deployment — this process was
+ * configured to consume that queue. A worker that bound queues by what it can serve would make
+ * every deployment of the same binary a worker for everything it happens to import.
+ */
+export const servedJobs = (context) => {
+    const listen = context.cfg.queue?.listen ?? [];
+    const served = new Map();
+    context.entrypoints().forEach(entrypoint => {
+        const route = entrypoint.route.route;
+        if (route.type !== AppType.Backend || route.protocol !== RouteProtocols.QUEUE) {
+            return;
+        }
+        if (route.service != null && route.service !== context.cfg.service) {
+            return;
+        }
+        if (entrypoint.handle == null || route.queue == null || !listen.includes(route.queue)) {
+            return;
+        }
+        served.set(route.queue, [...(served.get(route.queue) ?? []), entrypoint]);
+    });
+    return served;
+};
+/**
+ * A processor that runs a queued entrypoint call. The driver dispatches by job name, and an
+ * entrypoint job's name IS its alias — which is what lets one worker carry both entrypoint jobs
+ * and the internal steps an application registers with `process()`.
+ */
+export const entrypointProcessor = (context) => async (job) => await handleJob(context, job);
+/**
+ * Start the worker once the context is ready.
+ *
+ * Ready stage, not Loading: processors are registered while the application wires itself up, and
+ * binding the queues before that finished would take jobs this process cannot yet run. A process
+ * that listens to nothing registers no worker at all, so a producer pays nothing for this.
+ */
+export const queueWorkerMiddleware = (alias = DEFAULT_ALIAS) => ({
+    type: MiddlewareType.Context,
+    stage: MiddlewareStage.Ready,
+    apply: async (context) => {
+        const ctx = context;
+        if ((ctx.cfg.queue?.listen ?? []).length === 0) {
+            return;
+        }
+        if (!ctx.hasService(alias)) {
+            return;
+        }
+        await ctx.service(alias).start();
+    }
+});
+//# sourceMappingURL=worker.js.map

package/build/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAE5E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,OAAU,EACuB,EAAE;IACnC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,CAAA;IAC9C,MAAM,MAAM,GAAG,IAAI,GAAG,EAA8B,CAAA;IAEpD,OAAO,CAAC,WAAW,EAAoB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC3D,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAA;QACpC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,OAAO,IAAI,KAAK,CAAC,QAAQ,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;YAC9E,OAAM;QACR,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACnE,OAAM;QACR,CAAC;QACD,IAAI,UAAU,CAAC,MAAM,IAAI,IAAI,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACtF,OAAM;QACR,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,CAAA;IAC3E,CAAC,CAAC,CAAA;IAEF,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,OAAU,EAC0B,EAAE,CACtC,KAAK,EAAE,GAA4B,EAAE,EAAE,CAAC,MAAM,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;AAEvE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,KAAK,GAAW,aAAa,EAAc,EAAE,CAAC,CAAC;IACnF,IAAI,EAAE,cAAc,CAAC,OAAO;IAC5B,KAAK,EAAE,eAAe,CAAC,KAAK;IAC5B,KAAK,EAAE,KAAK,EAAC,OAAO,EAAC,EAAE;QACrB,MAAM,GAAG,GAAG,OAAqC,CAAA;QACjD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAM;QACR,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAM;QACR,CAAC;QAED,MAAM,GAAG,CAAC,OAAO,CAAqB,KAAK,CAAC,CAAC,KAAK,EAAE,CAAA;IACtD,CAAC;CACF,CAAC,CAAA"}