@ddd-ts-kit/redis 0.0.0-stage → 0.1.1

package/dist/keys/prefix-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-pattern.d.ts","sourceRoot":"","sources":["../../src/keys/prefix-pattern.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/keys/prefix-pattern.js

@@ -0,0 +1,5 @@
+/** The glob pattern matching every key that starts with the prefix, whatever it contains. */
+export function prefixPattern(prefix) {
+    return `${prefix.replaceAll(/[\\*?[\]]/g, '\\$&')}*`;
+}
+//# sourceMappingURL=prefix-pattern.js.map

package/dist/keys/prefix-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-pattern.js","sourceRoot":"","sources":["../../src/keys/prefix-pattern.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG,CAAC;AACvD,CAAC"}

package/dist/lock/redis-lock.d.ts

@@ -0,0 +1,31 @@
+import { inspect } from 'node:util';
+import type { Redis } from 'ioredis';
+import { type AcquireOptions, type Lock, type LockHandle, type WaitingOptions } from '@ddd-ts-kit/kernel';
+export interface RedisLockOptions extends WaitingOptions {
+    /** Prefix of the keys, typically the bounded context. Default `lock`. */
+    readonly namespace?: string;
+}
+/**
+ * The single-instance lock of the Redis documentation: `SET key owner NX PX ttl`, released by
+ * compare-and-delete so that a holder whose lock expired cannot free the lock of the next one.
+ *
+ * What it guarantees: at most one holder at a time as long as the server keeps its data and
+ * the holder finishes within `ttlMs`. What it does not: it is not a consensus lock. A
+ * failover to a replica that had not received the key, a restart without persistence, an
+ * eviction, or a holder paused longer than the ttl each let two holders in. The fencing
+ * token narrows that, for a resource able to compare tokens; its counter lives in the same
+ * server and starts again if that server loses it.
+ */
+export declare class RedisLock implements Lock {
+    private readonly client;
+    private readonly namespace;
+    private readonly waiting;
+    constructor(client: Redis, options?: RedisLockOptions);
+    acquire(key: string, options: AcquireOptions): Promise<LockHandle | undefined>;
+    /** What a serialisation shows: a name, never the client, whose options carry the password. */
+    toJSON(): string;
+    /** What `console.log` and `util.inspect` show: the same. */
+    [inspect.custom](): string;
+    private attempt;
+}
+//# sourceMappingURL=redis-lock.d.ts.map

package/dist/lock/redis-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-lock.d.ts","sourceRoot":"","sources":["../../src/lock/redis-lock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAa,KAAK,cAAc,EAAE,KAAK,IAAI,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIrH,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,yEAAyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAkBD;;;;;;;;;;GAUG;AACH,qBAAa,SAAU,YAAW,IAAI;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IAEzC,YAAY,MAAM,EAAE,KAAK,EAAE,OAAO,GAAE,gBAAqB,EAKxD;IAED,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAE7E;IAED,8FAA8F;IAC9F,MAAM,IAAI,MAAM,CAEf;IAED,4DAA4D;IAC5D,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAEzB;YAEa,OAAO;CAiBtB"}

package/dist/lock/redis-lock.js

@@ -0,0 +1,66 @@
+import { randomBytes } from 'node:crypto';
+import { inspect } from 'node:util';
+import { acquiring } from '@ddd-ts-kit/kernel';
+import { namespaced } from '../keys/namespaced.js';
+import { conceal } from '../secrecy/conceal.js';
+/** Takes the lock if it is free and numbers the acquisition, in one step. KEYS: lock, counter. ARGV: owner, ttl. */
+const ACQUIRE = `
+if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then
+  return redis.call('INCR', KEYS[2])
+end
+return 0`;
+/** Deletes the lock only while it still holds the value of this owner. KEYS: lock. ARGV: owner. */
+const RELEASE = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('DEL', KEYS[1])
+end
+return 0`;
+const DESCRIPTION = 'RedisLock [client concealed]';
+/**
+ * The single-instance lock of the Redis documentation: `SET key owner NX PX ttl`, released by
+ * compare-and-delete so that a holder whose lock expired cannot free the lock of the next one.
+ *
+ * What it guarantees: at most one holder at a time as long as the server keeps its data and
+ * the holder finishes within `ttlMs`. What it does not: it is not a consensus lock. A
+ * failover to a replica that had not received the key, a restart without persistence, an
+ * eviction, or a holder paused longer than the ttl each let two holders in. The fencing
+ * token narrows that, for a resource able to compare tokens; its counter lives in the same
+ * server and starts again if that server loses it.
+ */
+export class RedisLock {
+    client;
+    namespace;
+    waiting;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.namespace = options.namespace ?? 'lock';
+        this.waiting = options;
+        conceal(this);
+    }
+    acquire(key, options) {
+        return acquiring(() => this.attempt(key, options.ttlMs), options.waitMs ?? 0, this.waiting);
+    }
+    /** What a serialisation shows: a name, never the client, whose options carry the password. */
+    toJSON() {
+        return DESCRIPTION;
+    }
+    /** What `console.log` and `util.inspect` show: the same. */
+    [inspect.custom]() {
+        return DESCRIPTION;
+    }
+    async attempt(key, ttlMs) {
+        // The braces make both keys hash to one slot, which a cluster requires of a script.
+        const lockKey = namespaced(this.namespace, `{${key}}`);
+        const owner = randomBytes(16).toString('hex');
+        const ttl = String(Math.max(1, Math.ceil(ttlMs)));
+        const token = Number(await this.client.eval(ACQUIRE, 2, lockKey, `${lockKey}:fence`, owner, ttl));
+        if (token === 0) {
+            return undefined;
+        }
+        const release = async () => {
+            await this.client.eval(RELEASE, 1, lockKey, owner);
+        };
+        return { key, fencingToken: token, release };
+    }
+}
+//# sourceMappingURL=redis-lock.js.map

package/dist/lock/redis-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-lock.js","sourceRoot":"","sources":["../../src/lock/redis-lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,SAAS,EAAwE,MAAM,oBAAoB,CAAC;AACrH,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAOhD,oHAAoH;AACpH,MAAM,OAAO,GAAG;;;;SAIP,CAAC;AAEV,mGAAmG;AACnG,MAAM,OAAO,GAAG;;;;SAIP,CAAC;AAEV,MAAM,WAAW,GAAG,8BAA8B,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,MAAM,OAAO,SAAS;IACH,MAAM,CAAQ;IAEd,SAAS,CAAS;IAElB,OAAO,CAAiB;IAEzC,YAAY,MAAa,EAAE,OAAO,GAAqB,EAAE;QACvD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,MAAM,CAAC;QAC7C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,OAAO,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC;IAED,OAAO,CAAC,GAAW,EAAE,OAAuB;QAC1C,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9F,CAAC;IAED,8FAA8F;IAC9F,MAAM;QACJ,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,4DAA4D;IAC5D,CAAC,OAAO,CAAC,MAAM,CAAC;QACd,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,KAAa;QAC9C,oFAAoF;QACpF,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,GAAG,CAAC,CAAC;QACvD,MAAM,KAAK,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC9C,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAClD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;QAElG,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YAChB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,IAAmB,EAAE;YACxC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QACrD,CAAC,CAAC;QAEF,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC/C,CAAC;CACF"}

package/dist/rate-limiter/redis-rate-limiter.d.ts

@@ -0,0 +1,35 @@
+import { inspect } from 'node:util';
+import type { Redis } from 'ioredis';
+import { type Clock, type RateLimit, type RateLimitDecision, type RateLimiter } from '@ddd-ts-kit/kernel';
+export interface RedisRateLimiterOptions {
+    /** Prefix of the keys. Default `rate`. */
+    readonly namespace?: string;
+    /**
+     * The instants come from the caller, not from the server: every instance must run on a
+     * synchronized clock, and a skew between two of them shifts the window by as much.
+     */
+    readonly clock?: Clock;
+    /**
+     * What to answer while the server is away. `throw` (default) lets the caller decide;
+     * `allow` keeps the application serving without a limit; `deny` refuses every call.
+     */
+    readonly onError?: 'throw' | 'allow' | 'deny';
+}
+/**
+ * An exact sliding window, as a sorted set of the instants of the allowed calls: one member
+ * per call, so a key costs memory in proportion to its limit. For limits in the tens of
+ * thousands per window, count in a coarser key instead.
+ */
+export declare class RedisRateLimiter implements RateLimiter {
+    private readonly client;
+    private readonly namespace;
+    private readonly clock;
+    private readonly onError;
+    constructor(client: Redis, options?: RedisRateLimiterOptions);
+    consume(key: string, limit: RateLimit): Promise<RateLimitDecision>;
+    /** What a serialisation shows: a name, never the client, whose options carry the password. */
+    toJSON(): string;
+    /** What `console.log` and `util.inspect` show: the same. */
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=redis-rate-limiter.d.ts.map

package/dist/rate-limiter/redis-rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-rate-limiter.d.ts","sourceRoot":"","sources":["../../src/rate-limiter/redis-rate-limiter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAC;AAK5B,MAAM,WAAW,uBAAuB;IACtC,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IAEvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;CAC/C;AAuBD;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAE9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD,YAAY,MAAM,EAAE,KAAK,EAAE,OAAO,GAAE,uBAA4B,EAM/D;IAEK,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAoBvE;IAED,8FAA8F;IAC9F,MAAM,IAAI,MAAM,CAEf;IAED,4DAA4D;IAC5D,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAEzB;CACF"}

package/dist/rate-limiter/redis-rate-limiter.js

@@ -0,0 +1,77 @@
+import { randomBytes } from 'node:crypto';
+import { inspect } from 'node:util';
+import { SystemClock, rateLimitDecisionOf, } from '@ddd-ts-kit/kernel';
+import { namespaced } from '../keys/namespaced.js';
+import { listOf } from '../replies/list-of.js';
+import { conceal } from '../secrecy/conceal.js';
+/**
+ * Forgets the calls that left the window, then counts and records this one in the same step:
+ * two concurrent calls cannot both take the last place. Lua is kept to comparisons, the
+ * arithmetic is done by the caller. KEYS: calls. ARGV: cutoff, limit, now, member, window.
+ * Answers allowed, calls in the window, score of the oldest.
+ */
+const CONSUME = `
+redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[1])
+local calls = redis.call('ZCARD', KEYS[1])
+local allowed = 0
+if calls < tonumber(ARGV[2]) then
+  redis.call('ZADD', KEYS[1], ARGV[3], ARGV[4])
+  redis.call('PEXPIRE', KEYS[1], ARGV[5])
+  calls = calls + 1
+  allowed = 1
+end
+local oldest = redis.call('ZRANGE', KEYS[1], 0, 0, 'WITHSCORES')
+return {allowed, calls, oldest[2]}`;
+const DESCRIPTION = 'RedisRateLimiter [client concealed]';
+/**
+ * An exact sliding window, as a sorted set of the instants of the allowed calls: one member
+ * per call, so a key costs memory in proportion to its limit. For limits in the tens of
+ * thousands per window, count in a coarser key instead.
+ */
+export class RedisRateLimiter {
+    client;
+    namespace;
+    clock;
+    onError;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.namespace = options.namespace ?? 'rate';
+        this.clock = options.clock ?? new SystemClock();
+        this.onError = options.onError ?? 'throw';
+        conceal(this);
+    }
+    async consume(key, limit) {
+        const now = this.clock.now().getTime();
+        try {
+            const answer = await this.client.eval(CONSUME, 1, namespaced(this.namespace, key), ...argumentsOf(now, limit));
+            const [allowed, calls, oldest] = listOf(answer);
+            return rateLimitDecisionOf({ allowed: Number(allowed) === 1, calls: Number(calls), oldest: Number(oldest ?? now), now }, limit);
+        }
+        catch (error) {
+            if (this.onError === 'throw') {
+                throw error;
+            }
+            const allowed = this.onError === 'allow';
+            return { allowed, remaining: 0, retryAfterMs: allowed ? 0 : limit.windowMs };
+        }
+    }
+    /** What a serialisation shows: a name, never the client, whose options carry the password. */
+    toJSON() {
+        return DESCRIPTION;
+    }
+    /** What `console.log` and `util.inspect` show: the same. */
+    [inspect.custom]() {
+        return DESCRIPTION;
+    }
+}
+function argumentsOf(now, limit) {
+    const member = `${now}-${randomBytes(8).toString('hex')}`;
+    return [
+        String(now - limit.windowMs),
+        String(limit.limit),
+        String(now),
+        member,
+        String(Math.max(1, Math.ceil(limit.windowMs))),
+    ];
+}
+//# sourceMappingURL=redis-rate-limiter.js.map

package/dist/rate-limiter/redis-rate-limiter.js.map

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

package/dist/relay/redis-relay-signal.d.ts

@@ -0,0 +1,36 @@
+import { inspect } from 'node:util';
+import type { Redis } from 'ioredis';
+export interface RedisRelaySignalOptions {
+    /** One channel per outbox. Default `ddd-ts-kit:outbox`. */
+    readonly channel?: string;
+}
+/**
+ * The `RelaySignal` of `@ddd-ts-kit/events` between processes, over publish/subscribe: the
+ * process that appended to the outbox calls `notify`, and a relay built with `wakeOn` in any
+ * other process ticks at once instead of at its next interval.
+ *
+ * Same semantics as the in-memory signal: a hint, never a delivery. Publish/subscribe keeps
+ * nothing for a subscriber that is away, so a notification sent while the relay reconnects
+ * is lost, and the event goes out at the next poll. Keep the interval of the relay.
+ */
+export declare class RedisRelaySignal {
+    private readonly client;
+    private readonly channel;
+    private readonly listeners;
+    private subscriber;
+    constructor(client: Redis, options?: RedisRelaySignalOptions);
+    subscribe(listener: () => void): {
+        unsubscribe(): void;
+    };
+    /** Never fails: a notification that cannot be sent only delays the publication. */
+    notify(): Promise<void>;
+    /** Closes the connection this signal opened to listen. The client it was given stays open. */
+    close(): Promise<void>;
+    /** What a serialisation shows: a name, never the client, whose options carry the password. */
+    toJSON(): string;
+    /** What `console.log` and `util.inspect` show: the same. */
+    [inspect.custom](): string;
+    /** A connection in subscriber mode accepts no other command, hence one of its own. */
+    private listen;
+}
+//# sourceMappingURL=redis-relay-signal.d.ts.map

package/dist/relay/redis-relay-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-relay-signal.d.ts","sourceRoot":"","sources":["../../src/relay/redis-relay-signal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIrC,MAAM,WAAW,uBAAuB;IACtC,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IAEnD,OAAO,CAAC,UAAU,CAAoB;IAEtC,YAAY,MAAM,EAAE,KAAK,EAAE,OAAO,GAAE,uBAA4B,EAI/D;IAED,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG;QAAE,WAAW,IAAI,IAAI,CAAA;KAAE,CAKvD;IAED,mFAAmF;IAC7E,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAM5B;IAED,8FAA8F;IACxF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAS3B;IAED,8FAA8F;IAC9F,MAAM,IAAI,MAAM,CAEf;IAED,4DAA4D;IAC5D,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAEzB;IAED,sFAAsF;IACtF,OAAO,CAAC,MAAM;CAmBf"}

package/dist/relay/redis-relay-signal.js

@@ -0,0 +1,72 @@
+import { inspect } from 'node:util';
+import { closeRedis } from '../connection/close-redis.js';
+import { conceal } from '../secrecy/conceal.js';
+const DESCRIPTION = 'RedisRelaySignal [client concealed]';
+/**
+ * The `RelaySignal` of `@ddd-ts-kit/events` between processes, over publish/subscribe: the
+ * process that appended to the outbox calls `notify`, and a relay built with `wakeOn` in any
+ * other process ticks at once instead of at its next interval.
+ *
+ * Same semantics as the in-memory signal: a hint, never a delivery. Publish/subscribe keeps
+ * nothing for a subscriber that is away, so a notification sent while the relay reconnects
+ * is lost, and the event goes out at the next poll. Keep the interval of the relay.
+ */
+export class RedisRelaySignal {
+    client;
+    channel;
+    listeners = new Set();
+    subscriber;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.channel = options.channel ?? 'ddd-ts-kit:outbox';
+        conceal(this);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        this.subscriber ??= this.listen();
+        return { unsubscribe: () => void this.listeners.delete(listener) };
+    }
+    /** Never fails: a notification that cannot be sent only delays the publication. */
+    async notify() {
+        try {
+            await this.client.publish(this.channel, '');
+        }
+        catch {
+            return;
+        }
+    }
+    /** Closes the connection this signal opened to listen. The client it was given stays open. */
+    async close() {
+        this.listeners.clear();
+        const subscriber = this.subscriber;
+        this.subscriber = undefined;
+        if (subscriber !== undefined) {
+            await closeRedis(subscriber);
+        }
+    }
+    /** What a serialisation shows: a name, never the client, whose options carry the password. */
+    toJSON() {
+        return DESCRIPTION;
+    }
+    /** What `console.log` and `util.inspect` show: the same. */
+    [inspect.custom]() {
+        return DESCRIPTION;
+    }
+    /** A connection in subscriber mode accepts no other command, hence one of its own. */
+    listen() {
+        const subscriber = this.client.duplicate();
+        subscriber.on('message', (channel) => {
+            if (channel !== this.channel) {
+                return;
+            }
+            for (const listener of [...this.listeners]) {
+                listener();
+            }
+        });
+        // Without a handler ioredis prints connection errors; it reconnects and subscribes again by itself.
+        subscriber.on('error', () => undefined);
+        subscriber.subscribe(this.channel).catch(() => undefined);
+        return subscriber;
+    }
+}
+//# sourceMappingURL=redis-relay-signal.js.map

package/dist/relay/redis-relay-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-relay-signal.js","sourceRoot":"","sources":["../../src/relay/redis-relay-signal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAOhD,MAAM,WAAW,GAAG,qCAAqC,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,OAAO,gBAAgB;IACV,MAAM,CAAQ;IAEd,OAAO,CAAS;IAEhB,SAAS,GAAG,IAAI,GAAG,EAAc,CAAC;IAE3C,UAAU,CAAoB;IAEtC,YAAY,MAAa,EAAE,OAAO,GAA4B,EAAE;QAC9D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,mBAAmB,CAAC;QACtD,OAAO,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC;IAED,SAAS,CAAC,QAAoB;QAC5B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;QAElC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IACrE,CAAC;IAED,mFAAmF;IACnF,KAAK,CAAC,MAAM;QACV,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAC9C,CAAC;QAAC,MAAM,CAAC;YACP,OAAO;QACT,CAAC;IACH,CAAC;IAED,8FAA8F;IAC9F,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QAEnC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAE5B,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,UAAU,CAAC,UAAU,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,8FAA8F;IAC9F,MAAM;QACJ,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,4DAA4D;IAC5D,CAAC,OAAO,CAAC,MAAM,CAAC;QACd,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,sFAAsF;IAC9E,MAAM;QACZ,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QAE3C,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;YACnC,IAAI,OAAO,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC7B,OAAO;YACT,CAAC;YAED,KAAK,MAAM,QAAQ,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC3C,QAAQ,EAAE,CAAC;YACb,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,oGAAoG;QACpG,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QACxC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAE1D,OAAO,UAAU,CAAC;IACpB,CAAC;CACF"}

package/dist/relay/relay-wake-up-middleware.d.ts

@@ -0,0 +1,11 @@
+import type { BusMiddleware } from '@ddd-ts-kit/kernel';
+/**
+ * Notifies after each command that succeeded. Install it before `unitOfWorkMiddleware`, so
+ * that the notification leaves once the transaction that appended to the outbox has
+ * committed. A command that published nothing wakes the relay for nothing, which costs one
+ * empty claim.
+ */
+export declare function relayWakeUpMiddleware(signal: {
+    notify(): Promise<void>;
+}): BusMiddleware;
+//# sourceMappingURL=relay-wake-up-middleware.d.ts.map

package/dist/relay/relay-wake-up-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-wake-up-middleware.d.ts","sourceRoot":"","sources":["../../src/relay/relay-wake-up-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,aAAa,CAUxF"}

package/dist/relay/relay-wake-up-middleware.js

@@ -0,0 +1,16 @@
+/**
+ * Notifies after each command that succeeded. Install it before `unitOfWorkMiddleware`, so
+ * that the notification leaves once the transaction that appended to the outbox has
+ * committed. A command that published nothing wakes the relay for nothing, which costs one
+ * empty claim.
+ */
+export function relayWakeUpMiddleware(signal) {
+    return async (_message, next, info) => {
+        const result = await next();
+        if (info.kind === 'command') {
+            void signal.notify().catch(() => undefined);
+        }
+        return result;
+    };
+}
+//# sourceMappingURL=relay-wake-up-middleware.js.map

package/dist/relay/relay-wake-up-middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-wake-up-middleware.js","sourceRoot":"","sources":["../../src/relay/relay-wake-up-middleware.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAmC;IACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;QACpC,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QAE5B,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5B,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/replies/list-of.d.ts

@@ -0,0 +1,3 @@
+/** A reply of the server read as a list: anything else, `null` included, is an empty one. */
+export declare function listOf(reply: unknown): readonly unknown[];
+//# sourceMappingURL=list-of.d.ts.map

package/dist/replies/list-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-of.d.ts","sourceRoot":"","sources":["../../src/replies/list-of.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,OAAO,EAAE,CAEzD"}

package/dist/replies/list-of.js

@@ -0,0 +1,8 @@
+/** A reply of the server read as a list: anything else, `null` included, is an empty one. */
+export function listOf(reply) {
+    return isList(reply) ? reply : [];
+}
+function isList(value) {
+    return Array.isArray(value);
+}
+//# sourceMappingURL=list-of.js.map

package/dist/replies/list-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-of.js","sourceRoot":"","sources":["../../src/replies/list-of.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,MAAM,UAAU,MAAM,CAAC,KAAc;IACnC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACpC,CAAC;AAED,SAAS,MAAM,CAAC,KAAc;IAC5B,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC"}

package/dist/secrecy/conceal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Takes the fields an instance holds so far out of enumeration: `Object.keys`, a spread and a
+ * comparison no longer reach the client or the connection behind them, whose options carry
+ * credentials. Called last in a constructor, next to a `toJSON` and an inspection method that
+ * answer a name: nothing the instance is shown through leads to what it holds.
+ */
+export declare function conceal(instance: object): void;
+//# sourceMappingURL=conceal.d.ts.map

package/dist/secrecy/conceal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conceal.d.ts","sourceRoot":"","sources":["../../src/secrecy/conceal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAI9C"}

package/dist/secrecy/conceal.js

@@ -0,0 +1,12 @@
+/**
+ * Takes the fields an instance holds so far out of enumeration: `Object.keys`, a spread and a
+ * comparison no longer reach the client or the connection behind them, whose options carry
+ * credentials. Called last in a constructor, next to a `toJSON` and an inspection method that
+ * answer a name: nothing the instance is shown through leads to what it holds.
+ */
+export function conceal(instance) {
+    for (const field of Object.keys(instance)) {
+        Object.defineProperty(instance, field, { enumerable: false });
+    }
+}
+//# sourceMappingURL=conceal.js.map

package/dist/secrecy/conceal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conceal.js","sourceRoot":"","sources":["../../src/secrecy/conceal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,QAAgB;IACtC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1C,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IAChE,CAAC;AACH,CAAC"}

package/dist/streams/bury.d.ts

@@ -0,0 +1,13 @@
+import type { Redis } from 'ioredis';
+import type { Entry } from './codec/entry.js';
+export interface DeadLetter {
+    /** The stream the entry was read from, and the group it is pending in. */
+    readonly stream: string;
+    readonly group: string;
+    readonly deadStream: string;
+    readonly entry: Entry;
+    /** Why it died, as fields added to the copy: codes only. */
+    readonly annotations: Readonly<Record<string, string>>;
+}
+export declare function bury(client: Redis, letter: DeadLetter): Promise<void>;
+//# sourceMappingURL=bury.d.ts.map

package/dist/streams/bury.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bury.d.ts","sourceRoot":"","sources":["../../src/streams/bury.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAG9C,MAAM,WAAW,UAAU;IACzB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAEtB,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxD;AAWD,wBAAsB,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAI3E"}

package/dist/streams/bury.js

@@ -0,0 +1,14 @@
+import { fieldsWith } from './codec/fields-with.js';
+/**
+ * Copies the entry to the dead stream, then acknowledges it. A script, not a `MULTI`: a
+ * transaction would acknowledge even if the copy failed. KEYS: dead stream, stream.
+ * ARGV: group, entry id, then the fields of the copy.
+ */
+const BURY = `
+redis.call('XADD', KEYS[1], '*', unpack(ARGV, 3))
+return redis.call('XACK', KEYS[2], ARGV[1], ARGV[2])`;
+export async function bury(client, letter) {
+    const { stream, group, deadStream, entry } = letter;
+    await client.eval(BURY, 2, deadStream, stream, group, entry.id, ...fieldsWith(entry, letter.annotations));
+}
+//# sourceMappingURL=bury.js.map

package/dist/streams/bury.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bury.js","sourceRoot":"","sources":["../../src/streams/bury.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAgBpD;;;;GAIG;AACH,MAAM,IAAI,GAAG;;qDAEwC,CAAC;AAEtD,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,MAAa,EAAE,MAAkB;IAC1D,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IAEpD,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,GAAG,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;AAC5G,CAAC"}

package/dist/streams/claim-due.d.ts

@@ -0,0 +1,18 @@
+import type { Redis } from 'ioredis';
+import type { Delivery } from './delivery.js';
+export interface RedeliverySettings {
+    /** The consumer name, which is the name of its group. */
+    readonly consumer: string;
+    readonly instance: string;
+    readonly batchSize: number;
+    readonly retryDelayMs: number;
+    readonly visibilityTimeoutMs: number;
+}
+/**
+ * Takes back what is due in the pending entry list of the group for one stream: the entries
+ * this instance failed, once the retry delay has passed, and those another instance has left
+ * idle for longer than the visibility timeout. `XCLAIM` counts a delivery; the attempt is the
+ * counter of the pending entry list after it.
+ */
+export declare function claimDue(reader: Redis, stream: string, settings: RedeliverySettings): Promise<Delivery[]>;
+//# sourceMappingURL=claim-due.d.ts.map

package/dist/streams/claim-due.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-due.d.ts","sourceRoot":"","sources":["../../src/streams/claim-due.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC;AAQD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAe/G"}

package/dist/streams/claim-due.js

@@ -0,0 +1,41 @@
+import { entriesOf } from './codec/entries-of.js';
+import { pendingOf } from './codec/pending-of.js';
+/**
+ * Takes back what is due in the pending entry list of the group for one stream: the entries
+ * this instance failed, once the retry delay has passed, and those another instance has left
+ * idle for longer than the visibility timeout. `XCLAIM` counts a delivery; the attempt is the
+ * counter of the pending entry list after it.
+ */
+export async function claimDue(reader, stream, settings) {
+    const { consumer, instance, batchSize, retryDelayMs, visibilityTimeoutMs } = settings;
+    const [failedHere, idle] = await Promise.all([
+        reader.xpending(stream, consumer, 'IDLE', retryDelayMs, '-', '+', batchSize, instance),
+        reader.xpending(stream, consumer, 'IDLE', visibilityTimeoutMs, '-', '+', batchSize),
+    ]);
+    const abandoned = pendingOf(idle).filter((entry) => entry.consumer !== instance);
+    const claimant = new Claimant(reader, settings);
+    return [
+        ...(await claimant.claim({ stream, pending: pendingOf(failedHere), minIdleMs: retryDelayMs })),
+        ...(await claimant.claim({ stream, pending: abandoned, minIdleMs: visibilityTimeoutMs })),
+    ];
+}
+class Claimant {
+    reader;
+    settings;
+    constructor(reader, settings) {
+        this.reader = reader;
+        this.settings = settings;
+    }
+    /** An entry another instance claimed in the meantime is no longer idle, and is not answered. */
+    async claim({ stream, pending, minIdleMs }) {
+        if (pending.length === 0) {
+            return [];
+        }
+        const { consumer, instance } = this.settings;
+        const ids = pending.map((entry) => entry.id);
+        const claimed = entriesOf(await this.reader.call('XCLAIM', stream, consumer, instance, minIdleMs, ...ids));
+        const deliveries = new Map(pending.map((entry) => [entry.id, entry.deliveries]));
+        return claimed.map((entry) => ({ stream, entry, attempt: (deliveries.get(entry.id) ?? 0) + 1 }));
+    }
+}
+//# sourceMappingURL=claim-due.js.map

package/dist/streams/claim-due.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-due.js","sourceRoot":"","sources":["../../src/streams/claim-due.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAsBlD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,MAAa,EAAE,MAAc,EAAE,QAA4B;IACxF,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,mBAAmB,EAAE,GAAG,QAAQ,CAAC;IAEtF,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC3C,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,QAAQ,CAAC;QACtF,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,mBAAmB,EAAE,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC;KACpF,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;IACjF,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAEhD,OAAO;QACL,GAAG,CAAC,MAAM,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;QAC9F,GAAG,CAAC,MAAM,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,mBAAmB,EAAE,CAAC,CAAC;KAC1F,CAAC;AACJ,CAAC;AAED,MAAM,QAAQ;IAEO,MAAM;IACN,QAAQ;IAF3B,YACmB,MAAa,EACb,QAA4B;sBAD5B,MAAM;wBACN,QAAQ;IACxB,CAAC;IAEJ,gGAAgG;IAChG,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAS;QAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC7C,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QAC3G,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAEjF,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACnG,CAAC;CACF"}

package/dist/streams/codec/decode.d.ts

@@ -0,0 +1,5 @@
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+import type { Entry } from './entry.js';
+/** The envelope exactly as published, or `undefined` for an entry that does not hold one (poison). */
+export declare function decode(entry: Entry): IntegrationEvent | undefined;
+//# sourceMappingURL=decode.d.ts.map

package/dist/streams/codec/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/streams/codec/decode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAaxC,sGAAsG;AACtG,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,gBAAgB,GAAG,SAAS,CAgBjE"}

package/dist/streams/codec/decode.js

@@ -0,0 +1,40 @@
+import { ENVELOPE_FIELD } from './entry-fields.js';
+/** The envelope exactly as published, or `undefined` for an entry that does not hold one (poison). */
+export function decode(entry) {
+    const body = parsed(entry.fields.get(ENVELOPE_FIELD));
+    if (!isEnvelope(body)) {
+        return undefined;
+    }
+    return {
+        id: body.id,
+        type: body.type,
+        version: body.version,
+        occurredAt: body.occurredAt,
+        payload: body.payload,
+        ...(typeof body.traceparent === 'string' ? { traceparent: body.traceparent } : {}),
+        ...(typeof body.correlationId === 'string' ? { correlationId: body.correlationId } : {}),
+    };
+}
+function parsed(envelope) {
+    try {
+        return envelope === undefined ? undefined : JSON.parse(envelope);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isEnvelope(body) {
+    if (typeof body !== 'object' || body === null) {
+        return false;
+    }
+    return (hasText(body, 'id') &&
+        hasText(body, 'type') &&
+        hasText(body, 'occurredAt') &&
+        'version' in body &&
+        typeof body.version === 'number');
+}
+function hasText(body, field) {
+    const value = Reflect.get(body, field);
+    return typeof value === 'string' && value.length > 0;
+}
+//# sourceMappingURL=decode.js.map

package/dist/streams/codec/decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../../src/streams/codec/decode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAYnD,sGAAsG;AACtG,MAAM,UAAU,MAAM,CAAC,KAAY;IACjC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;IAEtD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,GAAG,CAAC,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClF,GAAG,CAAC,OAAO,IAAI,CAAC,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzF,CAAC;AACJ,CAAC;AAED,SAAS,MAAM,CAAC,QAA4B;IAC1C,IAAI,CAAC;QACH,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACnE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAS,UAAU,CAAC,IAAa;IAC/B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,CACL,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC;QACnB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,IAAI,EAAE,YAAY,CAAC;QAC3B,SAAS,IAAI,IAAI;QACjB,OAAO,IAAI,CAAC,OAAO,KAAK,QAAQ,CACjC,CAAC;AACJ,CAAC;AAED,SAAS,OAAO,CAAC,IAAY,EAAE,KAAa;IAC1C,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAEhD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AACvD,CAAC"}