@nodii/telemetry 0.12.0 → 0.14.0

package/dist/worker/single-active-lease.js

@@ -0,0 +1,394 @@
+// D402 — SingleActiveLease: the canonical single-active worker lease primitive
+// of the @nodii/telemetry/worker substrate.
+//
+// This UNIFIES the two divergent hand-rolled leases that exist today:
+//   - ts/outbox-dispatcher/src/lease.ts        (SET-NX-EX, renew @ ttl/2,
+//                                                key `lock:outbox:<service>`)
+//   - ts/replica-consumer/src/worker/lease.ts  (renew @ ttl/3,
+//                                                key `nodii:replica-consumer:lease:<svc>:<stream>`)
+// NEITHER carries a fencing token — that is the durability gap D402 closes.
+//
+// D402 (LOCKED) pins the lease terms:
+//   - Acquire : Redis `SET key owner NX EX ttl`; canonical key
+//               `nodii:lease:<service>:<scope>`.
+//   - Renew   : Lua CAS at ttl/2 (renew only if WE still own it).
+//   - Release : Lua CAS-DEL (release only if WE still own it).
+//   - Fencing : the lease carries `(ownerId, fencingToken)`; the token is
+//               MONOTONIC and validated AT THE SIDE-EFFECTING MOMENT (not only
+//               at acquire/dequeue) so a lease-lost worker's stale write cannot
+//               land.
+//   - SIGTERM-safe heartbeat.
+//
+// ── Authored design decisions (D402 leaves the encoding / Lua / validate-API to
+//    the implementer; everything below is the chosen, justified shape) ─────────
+//
+// • Token generation — a Redis `INCR` on a sibling counter key
+//   `nodii:lease:<service>:<scope>:fence`, captured at acquire time. This is the
+//   ONLY way to obtain a token that is monotonic *across acquisitions and across
+//   processes* — a per-process counter is not globally ordered, so a stale
+//   holder on host A could mint a token that collides with the live holder on
+//   host B. The counter key is persistent (never expires) so the value survives
+//   lease gaps: a later acquirer ALWAYS receives a strictly greater token than
+//   any prior holder. Monotonicity needs only strictly-increasing (gaps from
+//   failed acquires are harmless), which INCR guarantees.
+//
+// • Value encoding — the lease key stores `"<ownerId>:<fencingToken>"`, NOT the
+//   bare ownerId. This lets every guarded operation (renew / release /
+//   validateFence) CAS on the *full* `(owner, token)` identity in a single
+//   atomic GET-equality check, which is exactly what detects a stale holder
+//   whose token no longer matches the key's current value.
+//
+// • Acquire atomicity — INCR-then-SET-NX runs inside one Lua script so the
+//   token capture and the lock take are atomic and no successor can interleave.
+//
+// • validateFence(token) — the side-effecting guard. It reads the lease key's
+//   CURRENT value LIVE from Redis (not a cached local copy — validating "at the
+//   side-effecting moment" means against the current truth) and throws
+//   `FenceLostError` unless the live value is exactly `"<ourOwnerId>:<token>"`.
+//   A worker calls it immediately before any non-idempotent write; if the lease
+//   was lost/expired/taken-over since the work was claimed, the write is
+//   rejected before it can land.
+import { uuidv7 } from "../uuid.js";
+import { WORKER_METRIC_NAMES } from "./observability-hooks.js";
+/** Atomic acquire: capture the next monotonic fence + take the lock under NX.
+ *  KEYS[1] = lease key, KEYS[2] = fence counter key.
+ *  ARGV[1] = ownerId, ARGV[2] = ttl seconds.
+ *  Returns the captured fence token (a number) on success, or nil if the lock
+ *  is already held by someone else (no token is consumed in that case). */
+const ACQUIRE_LUA = `
+if redis.call("EXISTS", KEYS[1]) == 1 then
+  return false
+end
+local fence = redis.call("INCR", KEYS[2])
+local val = ARGV[1] .. ":" .. tostring(fence)
+redis.call("SET", KEYS[1], val, "EX", tonumber(ARGV[2]))
+return fence
+`;
+/** CAS-renew: EXPIRE only if the key's current value is exactly our
+ *  `owner:token`. ARGV[1] = `owner:token`, ARGV[2] = ttl seconds. */
+const RENEW_LUA = `
+if redis.call("GET", KEYS[1]) == ARGV[1] then
+  return redis.call("EXPIRE", KEYS[1], ARGV[2])
+end
+return 0
+`;
+/** CAS-release: DEL only if the key's current value is exactly our
+ *  `owner:token`. ARGV[1] = `owner:token`. */
+const RELEASE_LUA = `
+if redis.call("GET", KEYS[1]) == ARGV[1] then
+  return redis.call("DEL", KEYS[1])
+end
+return 0
+`;
+/** Canonical lease key shape, pinned by D402. */
+export function leaseKey(service, scope) {
+    return `nodii:lease:${service}:${scope}`;
+}
+/** Sibling monotonic fence-counter key for a `(service, scope)`. */
+export function fenceKey(service, scope) {
+    return `${leaseKey(service, scope)}:fence`;
+}
+/** Encode the lease value as `<ownerId>:<fencingToken>`. */
+export function encodeLeaseValue(ownerId, token) {
+    return `${ownerId}:${token}`;
+}
+/** Parse a `<ownerId>:<fencingToken>` lease value. Returns null if malformed.
+ *  Owner ids are uuids (which contain `-` but no `:`), so the token is the
+ *  segment after the LAST `:`. */
+export function parseLeaseValue(value) {
+    if (value === null)
+        return null;
+    const idx = value.lastIndexOf(":");
+    if (idx <= 0 || idx === value.length - 1)
+        return null;
+    const ownerId = value.slice(0, idx);
+    const token = Number(value.slice(idx + 1));
+    if (!Number.isInteger(token))
+        return null;
+    return { ownerId, token };
+}
+/**
+ * Thrown by {@link SingleActiveLease.validateFence} when the lease no longer
+ * belongs to the caller under the token the work was claimed with — the lease
+ * expired, was released, or was taken over by a later acquirer (whose fence is
+ * strictly greater). A worker that catches this MUST NOT perform the guarded
+ * side effect; the write is stale and would corrupt single-active ordering.
+ */
+export class FenceLostError extends Error {
+    leaseKey;
+    /** The token the work was claimed under (now stale). */
+    expectedToken;
+    /** The lease's current `(owner, token)`, or null if the key is gone. */
+    current;
+    constructor(args) {
+        const cur = args.current
+            ? `${args.current.ownerId}:${args.current.token}`
+            : "<none>";
+        super(`fence lost for ${args.leaseKey}: work claimed under token ${args.expectedToken} ` +
+            `but lease now holds ${cur} — stale write rejected`);
+        this.name = "FenceLostError";
+        this.leaseKey = args.leaseKey;
+        this.expectedToken = args.expectedToken;
+        this.current = args.current;
+    }
+}
+/**
+ * Thrown by {@link SingleActiveLease.validateFence} when the fence-check READ
+ * itself fails — Redis is down / unreachable / timed out, so ownership cannot be
+ * DETERMINED. DISTINCT from {@link FenceLostError}: a FenceLostError means the
+ * lease verifiably belongs to someone else now (a benign handoff); a
+ * FenceCheckUnavailableError means we could not verify ownership at all.
+ *
+ * Cross-runtime contract (D402): BOTH FAIL CLOSED — the guarded side-effect MUST
+ * NOT run. But the event is treated as a TRANSIENT infrastructure failure: the
+ * worker does NOT ack it and does NOT dead-letter it; the event stays in the
+ * consumer PEL and is reprocessed on the next poll after Redis recovers
+ * (at-least-once; side-effect fires exactly once on recovery). Identical
+ * behavior in TS, Python, and Go.
+ */
+export class FenceCheckUnavailableError extends Error {
+    leaseKey;
+    expectedToken;
+    /** The underlying Redis read error. */
+    cause;
+    constructor(args) {
+        const causeMsg = args.cause instanceof Error ? args.cause.message : String(args.cause);
+        super(`fence check unavailable for ${args.leaseKey} (token ${args.expectedToken}): ` +
+            `lease redis read failed: ${causeMsg} — write withheld, event retried`);
+        this.name = "FenceCheckUnavailableError";
+        this.leaseKey = args.leaseKey;
+        this.expectedToken = args.expectedToken;
+        this.cause = args.cause;
+    }
+}
+/**
+ * A single-active lease with a fencing token. One instance per `(service,
+ * scope)` may hold the lease at a time; the holder renews at ttl/2 and exposes
+ * {@link validateFence} as the side-effecting guard.
+ *
+ * Lifecycle:
+ *   const lease = new SingleActiveLease(opts);
+ *   if (!(await lease.acquire())) return;       // someone else holds it; idle
+ *   // ... do work; before each non-idempotent write:
+ *   await lease.validateFence(lease.fencingToken!);  // throws FenceLostError
+ *   await lease.release();                       // CAS-DEL on graceful stop
+ */
+export class SingleActiveLease {
+    service;
+    scope;
+    ownerId;
+    key;
+    fenceCounterKey;
+    redis;
+    ttlMs;
+    ttlSeconds;
+    onLeaseLost;
+    telemetry;
+    _acquired = false;
+    _lost = false;
+    _fencingToken = null;
+    renewTimer = null;
+    constructor(opts) {
+        this.redis = opts.redis;
+        this.service = opts.service;
+        this.scope = opts.scope;
+        this.ownerId = opts.ownerId ?? uuidv7();
+        this.ttlMs = opts.ttlMs;
+        this.ttlSeconds = Math.max(1, Math.floor(opts.ttlMs / 1000));
+        this.onLeaseLost = opts.onLeaseLost;
+        this.telemetry = opts.telemetry;
+        this.key = leaseKey(opts.service, opts.scope);
+        this.fenceCounterKey = fenceKey(opts.service, opts.scope);
+    }
+    /** Did we currently hold the lease as of the last acquire/renew? */
+    get leaseAcquired() {
+        return this._acquired && !this._lost;
+    }
+    /** Did the renewal loop detect we lost the lease? */
+    get lost() {
+        return this._lost;
+    }
+    /** The fence token captured at acquire, or null if we never acquired. */
+    get fencingToken() {
+        return this._fencingToken;
+    }
+    /**
+     * Attempt to acquire. Resolves `true` if we took the lease (and starts the
+     * ttl/2 renewal loop), `false` if another instance already holds it. The
+     * fence token is captured atomically inside the acquire Lua.
+     */
+    async acquire() {
+        const result = await this.redis.eval(ACQUIRE_LUA, 2, this.key, this.fenceCounterKey, this.ownerId, String(this.ttlSeconds));
+        // Lua `false` → not acquired; a number → our captured fence.
+        if (result === false || result === null) {
+            this._acquired = false;
+            return false;
+        }
+        const token = Number(result);
+        if (!Number.isInteger(token)) {
+            this._acquired = false;
+            return false;
+        }
+        this._fencingToken = token;
+        this._acquired = true;
+        this._lost = false;
+        this.startRenewLoop();
+        // CANONICAL D402 name + ISOLATED emit (see `emit`): a vocab/metric throw must
+        // never influence lease state.
+        this.emit("counter", WORKER_METRIC_NAMES.leaseAcquired, {
+            service: this.service,
+            scope: this.scope,
+        });
+        return true;
+    }
+    /**
+     * Record a lease metric through the injected telemetry seam, ISOLATED so a
+     * throw (e.g. the lib's STRICT `recordMetric` raising `MetricVocabularyError`)
+     * can NEVER propagate into the lease's renew/CAS control flow and false-mark
+     * the lease lost. Mirrors Python's `_emit` try/except. Telemetry is best-effort
+     * observability; it must never break the lease.
+     */
+    emit(kind, name, attributes) {
+        const tel = this.telemetry;
+        if (tel === undefined)
+            return;
+        try {
+            tel.recordMetric({ kind, name, value: 1, attributes });
+        }
+        catch {
+            // Swallow — telemetry must never break the lease (R1: observability is
+            // best-effort; a metric vocab/backend error is not a lease failure).
+        }
+    }
+    /** Start the ttl/2 renewal loop (CAS on `owner:token`). */
+    startRenewLoop() {
+        const renewMs = Math.max(1_000, Math.floor(this.ttlMs / 2));
+        const encoded = encodeLeaseValue(this.ownerId, this._fencingToken ?? 0);
+        this.renewTimer = setInterval(() => {
+            void this.renewOnce(encoded);
+        }, renewMs);
+        this.renewTimer.unref?.();
+    }
+    /** One CAS renew. Marks the lease lost (and stops the loop) on failure. */
+    async renewOnce(encoded) {
+        try {
+            const r = (await this.redis.eval(RENEW_LUA, 1, this.key, encoded, String(this.ttlSeconds)));
+            if (Number(r) === 1) {
+                // CANONICAL renewed_total, ISOLATED — a metric throw here must NOT reach
+                // the outer catch (which would FALSE-mark the lease lost on a HEALTHY
+                // renew, tearing down the worker). That is exactly BUG[3].
+                this.emit("counter", WORKER_METRIC_NAMES.leaseRenewed, {
+                    service: this.service,
+                    scope: this.scope,
+                    result: "held",
+                });
+            }
+            else {
+                this.markLost("lost");
+            }
+        }
+        catch {
+            // Only a GENUINE renew/CAS (redis) failure reaches here — the metric emit
+            // is isolated above, so this catch is never tripped by a telemetry throw.
+            this.markLost("error");
+        }
+    }
+    markLost(result) {
+        if (this._lost)
+            return;
+        this._lost = true;
+        this.stopRenewLoop();
+        // CANONICAL lost_total, ISOLATED.
+        this.emit("counter", WORKER_METRIC_NAMES.leaseLost, {
+            service: this.service,
+            scope: this.scope,
+            result,
+        });
+        this.onLeaseLost?.();
+    }
+    stopRenewLoop() {
+        if (this.renewTimer !== null) {
+            clearInterval(this.renewTimer);
+            this.renewTimer = null;
+        }
+    }
+    /**
+     * Renew once, on demand (e.g. a manual heartbeat tick). Returns `true` if we
+     * still hold the lease. A non-owner / stale call is a CAS no-op → `false`.
+     */
+    async renew() {
+        if (this._fencingToken === null)
+            return false;
+        const encoded = encodeLeaseValue(this.ownerId, this._fencingToken);
+        try {
+            const r = (await this.redis.eval(RENEW_LUA, 1, this.key, encoded, String(this.ttlSeconds)));
+            const held = Number(r) === 1;
+            if (!held)
+                this.markLost("lost");
+            return held;
+        }
+        catch {
+            this.markLost("error");
+            return false;
+        }
+    }
+    /**
+     * THE side-effecting guard. Reads the lease key's CURRENT value live from
+     * Redis and throws {@link FenceLostError} unless it is exactly
+     * `"<ourOwnerId>:<token>"`. Call immediately before any non-idempotent write
+     * to prove the lease is still ours under the token the work was claimed with.
+     *
+     * @param token the fence token the in-flight work was claimed under.
+     */
+    async validateFence(token) {
+        let raw;
+        try {
+            raw = await this.redis.get(this.key);
+        }
+        catch (cause) {
+            // A TRANSIENT Redis read failure (down / unreachable / timeout) means we
+            // cannot DETERMINE ownership. FAIL CLOSED (withhold the write) but classify
+            // it as transient-unavailable — NOT a verified fence-loss. The worker keeps
+            // the event in the PEL + retries on recovery (it does NOT dead-letter a
+            // non-poison event over a redis blip). Cross-runtime-identical to Go/Python.
+            throw new FenceCheckUnavailableError({
+                leaseKey: this.key,
+                expectedToken: token,
+                cause,
+            });
+        }
+        const current = parseLeaseValue(raw);
+        const ours = current !== null &&
+            current.ownerId === this.ownerId &&
+            current.token === token;
+        if (!ours) {
+            // The key is absent or holds a different (owner, token): a VERIFIED
+            // fence-loss / lease handoff.
+            throw new FenceLostError({
+                leaseKey: this.key,
+                expectedToken: token,
+                current,
+            });
+        }
+    }
+    /**
+     * Stop the renewal loop and CAS-release the lease (DEL only if we still hold
+     * `owner:token` — a stale owner's release never deletes a successor's lease).
+     * Best-effort: a release failure is swallowed since the key TTL-expires.
+     * SIGTERM-safe — call from a signal handler to hand off fast.
+     */
+    async release() {
+        this.stopRenewLoop();
+        this._acquired = false;
+        if (this._fencingToken === null)
+            return;
+        const encoded = encodeLeaseValue(this.ownerId, this._fencingToken);
+        try {
+            await this.redis.eval(RELEASE_LUA, 1, this.key, encoded);
+        }
+        catch {
+            /* swallow — key TTL-expires anyway */
+        }
+    }
+}
+//# sourceMappingURL=single-active-lease.js.map

package/dist/worker/single-active-lease.js.map

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

package/dist/worker/streams-worker.d.ts

@@ -0,0 +1,192 @@
+import type { CheckpointStore } from "./checkpoint-store.js";
+import type { DeadLetterSink } from "./dead-letter.js";
+import type { DedupeStore } from "./dedupe-store.js";
+import { ObservabilityHooks } from "./observability-hooks.js";
+import { type SingleActiveLeaseOpts } from "./single-active-lease.js";
+import type { SqlExecutor } from "./tx.js";
+import type { WorkerHandle, WorkerHwm, WorkerStopOptions, WorkerStopResult } from "./worker-handle.js";
+/**
+ * Minimal Redis-Streams client surface a StreamsWorker needs. Structurally
+ * compatible with `ioredis` (and replica-consumer's `RedisLike`). The consumer
+ * injects its own client; this lib has no hard Redis dependency in its source.
+ */
+export interface StreamsRedisLike {
+    xgroup(...args: (string | number)[]): Promise<unknown>;
+    xreadgroup(...args: (string | number)[]): Promise<unknown>;
+    /**
+     * XAUTOCLAIM — transfers ownership of PENDING entries idle ≥ minIdleMs from any
+     * (possibly DEAD) consumer to the asking consumer, returning `[cursor, entries,
+     * deleted]`. This is the CRASH-RECOVERY reaper: a crashed worker's un-ACK'd
+     * entries (in its per-consumer PEL) are reclaimed by the single-active
+     * successor (a new instance with a different consumer name) — otherwise they
+     * are permanently orphaned and the event is lost (the "no-reaper" durability
+     * defect D402 eliminates). Structurally compatible with ioredis `xautoclaim`.
+     */
+    xautoclaim(...args: (string | number)[]): Promise<unknown>;
+    xack(stream: string, group: string, ...ids: string[]): Promise<number>;
+    xlen(stream: string): Promise<number>;
+}
+/**
+ * A consumed stream event handed to the apply handler. The worker parses the
+ * `event` field of each XREADGROUP entry as JSON; `event_id` + `topic` drive
+ * dedupe. The worker assigns `streamId` (the `<ms>-<seq>` id) for the cursor.
+ */
+export interface StreamEvent {
+    /** The dedupe id — `(event_id, topic)` is the composite dedupe key (D198). */
+    event_id: string;
+    /** The outbox topic. */
+    topic: string;
+    /** Optional source emission ms for lag measurement. */
+    occurred_at_ms?: number;
+    /** The rest of the event payload (the projection input). */
+    [key: string]: unknown;
+}
+/**
+ * The apply context handed to the injected handler INSIDE the per-event apply
+ * tx. Everything here runs on ONE transaction so the projection upsert + dedupe
+ * record + cursor advance commit together-or-none.
+ */
+export interface StreamApplyContext {
+    /** The apply transaction handle — run the projection upsert on THIS. */
+    tx: SqlExecutor;
+    /** The event being applied. */
+    event: StreamEvent;
+    /** The Redis-Streams id of this entry (the cursor position). */
+    streamId: string;
+    /**
+     * THE side-effecting guard — `await ctx.validateFence()` BEFORE any
+     * non-idempotent projection write. Re-reads the live lease and throws
+     * {@link FenceLostError} if the lease was lost/taken-over since dequeue.
+     */
+    validateFence(): Promise<void>;
+}
+/**
+ * The injected apply handler — the caller's projection upsert. It runs INSIDE
+ * the worker's apply tx; the worker handles dedupe.record + checkpoint.advance
+ * around it. The handler MUST call `ctx.validateFence()` before its write.
+ */
+export type StreamApplyHandler = (ctx: StreamApplyContext) => Promise<void>;
+export interface StreamsWorkerOpts {
+    redis: StreamsRedisLike;
+    /** The source stream key (and the consumer-group base). */
+    stream: string;
+    /** The injected apply handler (the projection upsert). */
+    apply: StreamApplyHandler;
+    /** Opens a fresh apply transaction; the worker runs dedupe/checkpoint/apply on it. */
+    begin: <T>(fn: (tx: SqlExecutor) => Promise<T>) => Promise<T>;
+    dedupe: DedupeStore;
+    checkpoint: CheckpointStore;
+    /** Lease config (service + scope=stream + ttlMs). */
+    lease: Omit<SingleActiveLeaseOpts, "onLeaseLost">;
+    /** Checkpoint subscription key. Default `streams:<stream>`. */
+    subscription?: string;
+    /** Injected dead-letter sink (NO default). */
+    deadLetter: DeadLetterSink;
+    /** Max in-line retries before dead-lettering a poison event. Default 3. */
+    retryMaxAttempts?: number;
+    /** XREADGROUP COUNT per poll. Default 32. */
+    pollBatch?: number;
+    /** XREADGROUP BLOCK ms. Default 2_000 (tests pass small). */
+    blockMs?: number;
+    /**
+     * XAUTOCLAIM crash-recovery threshold (ms): a PENDING entry idle at least this
+     * long is assumed to belong to a DEAD consumer and is reclaimed by the
+     * single-active successor. Default = max(lease ttlMs, 30_000) so a still-alive
+     * predecessor's normal in-flight latency never triggers a steal (the fence
+     * guard is the ultimate safety net for the rare race).
+     */
+    reclaimMinIdleMs?: number;
+    hooks?: ObservabilityHooks;
+    workerLabel?: string;
+    /** Launch the background consume loop on `start()`. Default true; tests pass
+     *  false to drive `runOnce()` deterministically. */
+    autoStart?: boolean;
+}
+/** Consumer-group name — `${service}:${stream}` (canonical per replica-consumer). */
+export declare function streamsConsumerGroup(service: string, stream: string): string;
+/** Parse an ioredis XREADGROUP response into flat (id, event) pairs. */
+export declare function parseStreamEntries(raw: unknown): Array<{
+    id: string;
+    event: StreamEvent;
+}>;
+/**
+ * Parse an ioredis XAUTOCLAIM reply `[cursor, entries, deleted]` into flat
+ * (id, event) pairs. `entries` has the same `[[id, [f, v, ...]], ...]` shape as
+ * one stream's entries in an XREADGROUP reply, so we wrap it and reuse
+ * {@link parseStreamEntries}.
+ */
+export declare function parseAutoClaimEntries(raw: unknown): Array<{
+    id: string;
+    event: StreamEvent;
+}>;
+/**
+ * StreamsWorker — the generic Pattern-2 single-active stream consumer. Composes
+ * lease + dedupe + checkpoint + hooks + drain to consume EXACTLY-ONCE.
+ */
+export declare class StreamsWorker implements WorkerHandle {
+    private readonly redis;
+    private readonly stream;
+    private readonly apply;
+    private readonly begin;
+    private readonly dedupe;
+    private readonly checkpoint;
+    private readonly lease;
+    private readonly subscription;
+    private readonly deadLetter;
+    private readonly retryMaxAttempts;
+    private readonly pollBatch;
+    private readonly blockMs;
+    private readonly reclaimMinIdleMs;
+    private readonly hooks;
+    private readonly autoStart;
+    private readonly group;
+    private readonly consumer;
+    private readonly retries;
+    private _running;
+    private _stopped;
+    private _inFlight;
+    private _hwm;
+    private _lastAppliedAtMs;
+    private groupEnsured;
+    private loop;
+    constructor(opts: StreamsWorkerOpts);
+    get running(): boolean;
+    get leaseAcquired(): boolean;
+    get lag(): number | null;
+    get currentHwm(): WorkerHwm;
+    /** Idempotently create the consumer group (swallow BUSYGROUP). */
+    private ensureGroup;
+    start(): Promise<void>;
+    private hydrateCursor;
+    private runLoop;
+    /**
+     * Poll one batch + apply each entry. Returns count processed.
+     *
+     * Two reads per poll: FIRST our OWN pending-entries-list (PEL) at id `0` —
+     * entries delivered to this consumer but NOT yet XACK'd (a prior apply failed
+     * + NACK'd them); they MUST be retried, and a plain `>` read never re-returns
+     * a PEL entry. THEN `>` for brand-new entries. Without the PEL re-read a
+     * poison event would be applied exactly once and never retried.
+     */
+    private pollOnce;
+    /**
+     * Apply one entry: dedupe-skip → apply-tx (projection + dedupe.record +
+     * checkpoint.advance, fence-guarded) → XACK. On error, retry-then-dead-letter.
+     */
+    private applyOne;
+    /**
+     * XACK an already-committed entry, SWALLOWING a transient ack failure. The
+     * XACK is post-commit (or post-dedupe-skip) and NOT part of the apply tx — a
+     * failing XACK is a transient redis blip, never a poison event. On failure the
+     * entry simply stays un-acked in the PEL and is re-acked next poll once redis
+     * recovers (the durable dedupe row makes the redelivery a no-op). This is what
+     * Go does (`_, _ = Ack(...)`); a throw here must NEVER reach retry/DLQ.
+     */
+    private ackSwallow;
+    /** Increment the retry ledger; dead-letter (+XACK) once the budget is spent. */
+    private retryOrDeadLetter;
+    /** Run exactly one poll batch (test seam / cron tick). */
+    runOnce(): Promise<number>;
+    stop(opts?: WorkerStopOptions): Promise<WorkerStopResult>;
+}
+//# sourceMappingURL=streams-worker.d.ts.map

package/dist/worker/streams-worker.d.ts.map

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