@nodii/telemetry 0.12.0 → 0.14.0

package/dist/worker/dead-letter.js

@@ -0,0 +1,165 @@
+// D402 — DeadLetter: an INJECTED dead-letter sink with a fail-closed PII
+// redaction hook.
+//
+// D402 (LOCKED):
+//   "DeadLetter — an injected sink (NEVER a default-on source-side `outbox_dlq`
+//    — see D-NEW / D401)."
+//
+// D401 forbids a default-on source-side DLQ table. So this primitive ships:
+//   1. The `DeadLetterSink` INTERFACE — the caller injects the impl.
+//   2. A fail-closed PII redaction wrapper AUTOMATICALLY applied by every worker
+//      constructor (via `ensurePiiRedaction`) to every dead item BEFORE it
+//      reaches the sink — fail-closed BY DEFAULT (D15: the SAFE state is the
+//      default; a consumer cannot leak raw PII by forgetting to wrap). If
+//      redaction throws, the payload is dropped to `[REDACTED]`, never raw. A
+//      consumer who wraps manually with `withPiiRedaction` is not double-wrapped.
+//   3. A couple of REFERENCE impls the caller OPTS INTO:
+//        - `LoudNoopDeadLetterSink` — accepts the item but logs LOUDLY (never a
+//          silent drop). Only constructed when EXPLICITLY injected; never
+//          auto-wired anywhere.
+//        - `TableDeadLetterSink` — persists into a CONSUMER-OWNED table the
+//          caller opts into by passing its own `SqlExecutor` + table name. NOT a
+//          source-side `outbox_dlq`; it is the subscriber's own quarantine.
+//
+// There is NO default sink. A worker constructed without a DeadLetter has no
+// dead-letter behavior; the caller must inject one to enable it. This is the
+// D401/D402 "never a default-on" rule expressed in the type system.
+import { attemptRedactString, redactFields } from "../redaction.js";
+/** Strict SQL identifier whitelist (mirrors replica-consumer's quoteIdent). */
+const IDENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function quoteIdent(name) {
+    if (!IDENT_PATTERN.test(name)) {
+        throw new Error(`invalid SQL identifier: ${name}`);
+    }
+    return `"${name}"`;
+}
+/**
+ * Wrap a sink with the FAIL-CLOSED PII redaction hook. Both the item's
+ * `payload` AND its `errorMessage` are scrubbed before they reach the wrapped
+ * sink:
+ *   - `payload` runs through the canonical D15 `redactFields` redactor; if it
+ *     THROWS (e.g. a circular/non-serializable value) the whole payload is
+ *     collapsed to `{ redaction: "[REDACTED]" }` rather than passed through raw.
+ *   - `errorMessage` runs through the canonical D15 string redactor
+ *     (`attemptRedactString`) — real apply errors embed PII routinely (a
+ *     postgres `Key (email)=(user@example.com) already exists`, an HTTP error
+ *     carrying a URL+querystring); if the scrub fails it collapses to
+ *     `[REDACTED]`. Fail-closed, never fail-open, on BOTH fields.
+ *
+ * Every worker that injects a DeadLetterSink gets this wrapper applied so a
+ * dead item can never carry plaintext PII into a quarantine table or a log.
+ */
+/** Brand marking a sink as already PII-redacting (so it is not double-wrapped). */
+const PII_REDACTING = Symbol.for("nodii.worker.piiRedactingSink");
+export function withPiiRedaction(sink, opts = {}) {
+    const wrapped = {
+        async deadLetter(item) {
+            let safePayload;
+            try {
+                safePayload = redactFields(item.payload ?? {}, {
+                    extraPaths: opts.extraPaths,
+                });
+            }
+            catch {
+                // Fail CLOSED: redaction failed → drop the payload entirely rather than
+                // risk leaking raw PII into the sink.
+                safePayload = { redaction: "[REDACTED]" };
+            }
+            // Scrub the error string too — a raw apply error routinely quotes PII.
+            // attemptRedactString is itself fail-closed (returns ok:false on throw);
+            // on a non-ok result we drop the whole string to [REDACTED].
+            const scrubbed = attemptRedactString(item.errorMessage ?? "", {
+                extraPaths: opts.extraPaths,
+            });
+            const safeErrorMessage = scrubbed.ok ? scrubbed.redacted : "[REDACTED]";
+            await sink.deadLetter({
+                ...item,
+                payload: safePayload,
+                errorMessage: safeErrorMessage,
+            });
+        },
+    };
+    wrapped[PII_REDACTING] = true;
+    return wrapped;
+}
+/**
+ * The FAIL-CLOSED-BY-DEFAULT wrapper every worker applies to its injected
+ * DeadLetterSink: redaction runs on every dead item WITHOUT the consumer having
+ * to remember to wrap (D15: the SAFE state must be the default). An
+ * already-wrapped sink is returned as-is (no double-wrap). Used internally by the
+ * worker constructors.
+ */
+export function ensurePiiRedaction(sink) {
+    if (sink[PII_REDACTING])
+        return sink;
+    return withPiiRedaction(sink);
+}
+/**
+ * Reference sink #1: accepts the dead item but logs it LOUDLY (error-level,
+ * with the failure cause + identity, never the raw payload — that's already
+ * redacted by `withPiiRedaction`). It does NOT persist. Useful as an explicit
+ * "I have NO durable DLQ yet but I refuse to silently drop" choice. NEVER
+ * auto-wired — the caller must construct + inject it.
+ */
+export class LoudNoopDeadLetterSink {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async deadLetter(item) {
+        this.logger.error("worker.dead_letter (no durable sink wired)", {
+            source_stream: item.sourceStream,
+            topic: item.topic,
+            event_id: item.eventId,
+            error_message: item.errorMessage,
+            retry_count: item.retryCount,
+            // payload is redacted by withPiiRedaction before reaching here.
+            payload: item.payload,
+        });
+    }
+}
+/**
+ * Reference sink #2: persists the dead item into a CONSUMER-OWNED quarantine
+ * table the caller opts into (passing its OWN transaction/pool executor + table
+ * name). This is the SUBSCRIBER's own DLQ — NOT a source-side `outbox_dlq`
+ * (which D401 forbids). The caller controls the executor, so the write joins
+ * whatever transaction the caller chooses (or runs standalone on a pool conn).
+ */
+export class TableDeadLetterSink {
+    table;
+    insertSql;
+    exec;
+    constructor(opts) {
+        this.exec = opts.executor;
+        this.table = opts.table ?? "worker_dead_letter";
+        const t = quoteIdent(this.table);
+        this.insertSql = `INSERT INTO ${t}
+  (source_stream, topic, event_id, payload, error_message, retry_count, dead_lettered_at)
+VALUES ($1, $2, $3, $4::jsonb, $5, $6, now())`;
+    }
+    /** Idempotent DDL for the consumer-owned quarantine table. */
+    static tableDDL(table = "worker_dead_letter") {
+        const t = quoteIdent(table);
+        return `CREATE TABLE IF NOT EXISTS ${t} (
+  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  source_stream TEXT NOT NULL,
+  topic TEXT NOT NULL,
+  event_id TEXT NOT NULL,
+  payload JSONB NOT NULL,
+  error_message TEXT NOT NULL,
+  retry_count INTEGER NOT NULL DEFAULT 0,
+  dead_lettered_at TIMESTAMPTZ NOT NULL DEFAULT now()
+)`;
+    }
+    async deadLetter(item) {
+        await this.exec.query(this.insertSql, [
+            item.sourceStream,
+            item.topic,
+            item.eventId,
+            JSON.stringify(item.payload ?? {}),
+            item.errorMessage,
+            item.retryCount,
+        ]);
+    }
+}
+//# sourceMappingURL=dead-letter.js.map

package/dist/worker/dead-letter.js.map

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

package/dist/worker/dedupe-store.d.ts

@@ -0,0 +1,46 @@
+import type { SqlExecutor } from "./tx.js";
+/** The canonical un-prefixed dedupe table (per-service DB). */
+export declare const DEFAULT_CONSUMED_EVENTS_TABLE = "consumed_events";
+/** Default retention horizon for the sweep — 30d per 09-replication § 6. */
+export declare const DEFAULT_RETENTION_DAYS = 30;
+/** Idempotent DDL for the composite-PK dedupe table (D198). */
+export declare function consumedEventsTableDDL(table?: string): string;
+/**
+ * Dedupe over `consumed_events (event_id, topic)` (D198 composite PK). One
+ * instance serves a whole service DB (the table is per-service). All writes
+ * join the caller's apply transaction via the injected `tx`.
+ */
+export declare class DedupeStore {
+    readonly table: string;
+    private readonly selectSql;
+    private readonly insertSql;
+    private readonly sweepSql;
+    constructor(opts?: {
+        table?: string;
+    });
+    /**
+     * Has `(event_id, topic)` already been consumed? Call at step [1] of consume
+     * to skip an already-applied event before any work. Pass the apply `tx` (so
+     * the probe sees the tx's own uncommitted inserts) or a pooled connection for
+     * a cheap pre-tx probe.
+     */
+    seen(eventId: string, topic: string, tx: SqlExecutor): Promise<boolean>;
+    /**
+     * Record `(event_id, topic)` as consumed INSIDE the caller's apply tx — the
+     * SAME `tx` the projection upsert + `checkpoint.advance(...)` run on, so the
+     * dedupe row commits together-or-none with them.
+     *
+     * @returns `true` if this call inserted the row (first time consumed), `false`
+     *          if it was already present (ON CONFLICT DO NOTHING) — lets the
+     *          caller detect a concurrent double-consume.
+     */
+    record(eventId: string, topic: string, tx: SqlExecutor): Promise<boolean>;
+    /**
+     * Retention sweep — DELETE dedupe rows older than `retentionDays` (default
+     * 30d per 09-replication § 6). Run on a SweeperWorker tick. Returns the number
+     * of rows removed (surface as `nodii.worker.swept_total`). `tx` may be a
+     * pooled connection — the sweep is independent of any apply transaction.
+     */
+    sweep(tx: SqlExecutor, retentionDays?: number): Promise<number>;
+}
+//# sourceMappingURL=dedupe-store.d.ts.map

package/dist/worker/dedupe-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe-store.d.ts","sourceRoot":"","sources":["../../src/worker/dedupe-store.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,SAAS,CAAC;AAYnD,+DAA+D;AAC/D,eAAO,MAAM,6BAA6B,oBAAoB,CAAC;AAE/D,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,KAAK,SAAgC,GACpC,MAAM,CAQR;AAMD;;;;GAIG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,IAAI,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO;IAczC;;;;;OAKG;IACG,IAAI,CACR,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,WAAW,GACd,OAAO,CAAC,OAAO,CAAC;IAKnB;;;;;;;;OAQG;IACG,MAAM,CACV,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,WAAW,GACd,OAAO,CAAC,OAAO,CAAC;IAKnB;;;;;OAKG;IACG,KAAK,CACT,EAAE,EAAE,WAAW,EACf,aAAa,GAAE,MAA+B,GAC7C,OAAO,CAAC,MAAM,CAAC;CASnB"}

package/dist/worker/dedupe-store.js

@@ -0,0 +1,113 @@
+// D402 — DedupeStore: the at-most-once dedupe primitive over the
+// `consumed_events (event_id, topic)` composite-PK table.
+//
+// D402 (LOCKED):
+//   "DedupeStore — `consumed_events (event_id, topic)` composite-PK dedupe +
+//    retention sweep (default 30d per 09-replication-doctrine § 6)."
+//
+// D198 (LOCKED 2026-06-03) pins the COMPOSITE pk: the same event_id can
+// legitimately recur across topics, so an event_id-only dedupe would wrongly
+// short-circuit the second topic. Keying on `(event_id, topic)` is the
+// cross-topic-correctness fix (see ts/replica-consumer/src/sql-builders.ts
+// DEDUPE_SELECT_SQL / CONSUMED_EVENTS_INSERT_SQL — generalized here, NOT
+// duplicated; same table, same column shape).
+//
+// The `consumed_events` table is intentionally UN-prefixed: each adopting
+// service owns its own database, so the table is already per-service (operator-
+// confirmed; see memory feedback_consumed_events_table).
+//
+// ── Atomic-in-apply-tx (the load-bearing property) ───────────────────────────
+//   `record(...)` runs on the CALLER's `tx` handle, the SAME one the projection
+//   upsert + `checkpoint.advance(...)` run on. The dedupe row is therefore
+//   committed together-or-none with the projection + the cursor: if apply fails
+//   after `record(...)`, the rollback removes the dedupe row too, so the event
+//   is NOT falsely marked consumed (a retry re-processes it). And because the
+//   cursor advance is in the same tx, a committed dedupe row always has a
+//   committed cursor that covers it.
+//
+//   `seen(...)` is the read-side probe at step [1] of the consume sequence:
+//   call it (on the tx, or a pooled conn pre-tx) to skip an already-applied
+//   (event_id, topic) before doing any work.
+/** Strict SQL identifier whitelist (mirrors replica-consumer's quoteIdent). */
+const IDENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function quoteIdent(name) {
+    if (!IDENT_PATTERN.test(name)) {
+        throw new Error(`invalid SQL identifier: ${name}`);
+    }
+    return `"${name}"`;
+}
+/** The canonical un-prefixed dedupe table (per-service DB). */
+export const DEFAULT_CONSUMED_EVENTS_TABLE = "consumed_events";
+/** Default retention horizon for the sweep — 30d per 09-replication § 6. */
+export const DEFAULT_RETENTION_DAYS = 30;
+/** Idempotent DDL for the composite-PK dedupe table (D198). */
+export function consumedEventsTableDDL(table = DEFAULT_CONSUMED_EVENTS_TABLE) {
+    const t = quoteIdent(table);
+    return `CREATE TABLE IF NOT EXISTS ${t} (
+  event_id TEXT NOT NULL,
+  topic TEXT NOT NULL,
+  consumed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (event_id, topic)
+)`;
+}
+/**
+ * Dedupe over `consumed_events (event_id, topic)` (D198 composite PK). One
+ * instance serves a whole service DB (the table is per-service). All writes
+ * join the caller's apply transaction via the injected `tx`.
+ */
+export class DedupeStore {
+    table;
+    selectSql;
+    insertSql;
+    sweepSql;
+    constructor(opts = {}) {
+        this.table = opts.table ?? DEFAULT_CONSUMED_EVENTS_TABLE;
+        const t = quoteIdent(this.table);
+        this.selectSql = `SELECT 1 AS one FROM ${t} WHERE event_id = $1 AND topic = $2 LIMIT 1`;
+        // ON CONFLICT DO NOTHING: a concurrent / replayed insert is a benign no-op
+        // (the row already proves consumption); rowCount distinguishes first-insert
+        // (1) from already-seen (0).
+        this.insertSql = `INSERT INTO ${t} (event_id, topic, consumed_at) VALUES ($1, $2, now())
+ON CONFLICT (event_id, topic) DO NOTHING`;
+        // Retention sweep — parameterized day horizon, cast to an interval. Mirrors
+        // replica-consumer's SWEEP_CONSUMED_EVENTS_SQL.
+        this.sweepSql = `DELETE FROM ${t} WHERE consumed_at < now() - ($1::int || ' days')::interval`;
+    }
+    /**
+     * Has `(event_id, topic)` already been consumed? Call at step [1] of consume
+     * to skip an already-applied event before any work. Pass the apply `tx` (so
+     * the probe sees the tx's own uncommitted inserts) or a pooled connection for
+     * a cheap pre-tx probe.
+     */
+    async seen(eventId, topic, tx) {
+        const res = await tx.query(this.selectSql, [eventId, topic]);
+        return res.rows.length > 0;
+    }
+    /**
+     * Record `(event_id, topic)` as consumed INSIDE the caller's apply tx — the
+     * SAME `tx` the projection upsert + `checkpoint.advance(...)` run on, so the
+     * dedupe row commits together-or-none with them.
+     *
+     * @returns `true` if this call inserted the row (first time consumed), `false`
+     *          if it was already present (ON CONFLICT DO NOTHING) — lets the
+     *          caller detect a concurrent double-consume.
+     */
+    async record(eventId, topic, tx) {
+        const res = await tx.query(this.insertSql, [eventId, topic]);
+        return res.rowCount > 0;
+    }
+    /**
+     * Retention sweep — DELETE dedupe rows older than `retentionDays` (default
+     * 30d per 09-replication § 6). Run on a SweeperWorker tick. Returns the number
+     * of rows removed (surface as `nodii.worker.swept_total`). `tx` may be a
+     * pooled connection — the sweep is independent of any apply transaction.
+     */
+    async sweep(tx, retentionDays = DEFAULT_RETENTION_DAYS) {
+        if (!Number.isInteger(retentionDays) || retentionDays < 0) {
+            throw new Error(`retentionDays must be a non-negative integer, got ${retentionDays}`);
+        }
+        const res = await tx.query(this.sweepSql, [retentionDays]);
+        return res.rowCount;
+    }
+}
+//# sourceMappingURL=dedupe-store.js.map

package/dist/worker/dedupe-store.js.map

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

package/dist/worker/index.d.ts

@@ -0,0 +1,23 @@
+export { encodeLeaseValue, FenceCheckUnavailableError, FenceLostError, fenceKey, leaseKey, parseLeaseValue, SingleActiveLease, } from "./single-active-lease.js";
+export type { LeaseRedisLike, LeaseTelemetry, SingleActiveLeaseOpts, } from "./single-active-lease.js";
+export { postgresJsExecutor } from "./tx.js";
+export type { SqlExecutor, SqlResult, SqlRow } from "./tx.js";
+export { CheckpointStore, checkpointTableDDL, DEFAULT_CHECKPOINT_TABLE, } from "./checkpoint-store.js";
+export type { Checkpoint, CheckpointAdvance } from "./checkpoint-store.js";
+export { consumedEventsTableDDL, DedupeStore, DEFAULT_CONSUMED_EVENTS_TABLE, DEFAULT_RETENTION_DAYS, } from "./dedupe-store.js";
+export { ensurePiiRedaction, LoudNoopDeadLetterSink, TableDeadLetterSink, withPiiRedaction, } from "./dead-letter.js";
+export type { DeadLetterItem, DeadLetterLogger, DeadLetterSink, } from "./dead-letter.js";
+export { hwmGaugeValue, ObservabilityHooks, WORKER_METRIC_NAMES, WORKER_SUBSTRATE_VOCABULARY, } from "./observability-hooks.js";
+export type { ObservabilityHooksOpts, RecordMetricFn, WorkerMetricAttributes, } from "./observability-hooks.js";
+export { SignalDrain } from "./signal-drain.js";
+export type { DrainResult, SignalDrainOpts, StopHandler, } from "./signal-drain.js";
+export type { WorkerHandle, WorkerHwm, WorkerStopOptions, WorkerStopResult, } from "./worker-handle.js";
+export { SweeperWorker } from "./sweeper-worker.js";
+export type { SweeperJobContext, SweeperJobDefinition, SweeperJobResult, SweeperWorkerOpts, } from "./sweeper-worker.js";
+export { parseAutoClaimEntries, parseStreamEntries, StreamsWorker, streamsConsumerGroup, } from "./streams-worker.js";
+export type { StreamApplyContext, StreamApplyHandler, StreamEvent, StreamsRedisLike, StreamsWorkerOpts, } from "./streams-worker.js";
+export { OutboxDispatcher } from "./outbox-dispatcher.js";
+export type { OutboxDispatcherOpts, OutboxPublisher, OutboxRow, } from "./outbox-dispatcher.js";
+export { ReplicationWorker, replicationConsumerGroup, } from "./replication-worker.js";
+export type { ReplicationApplyContext, ReplicationApplyHandler, ReplicationAuditHook, ReplicationEvent, ReplicationWorkerOpts, SnapshotBootstrap, } from "./replication-worker.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/worker/index.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,cAAc,EACd,cAAc,EACd,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG3E,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,6BAA6B,EAC7B,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,cAAc,GACf,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,sBAAsB,GACvB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EACV,WAAW,EACX,eAAe,EACf,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAM5B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,SAAS,GACV,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,yBAAyB,CAAC"}

package/dist/worker/index.js

@@ -0,0 +1,46 @@
+// @nodii/telemetry/worker — the canonical background-worker substrate (D402).
+//
+// Every background worker on every Nodii service — stream consumer, sweeper,
+// single-active leased loop, outbox drainer — is built from these canonical
+// primitives. No service hand-rolls a lease, a checkpoint cursor, a dedupe
+// store, or a worker lifecycle.
+//
+// D402 (LOCKED) primitives shipped here:
+//   - SingleActiveLease   — Redis SET-NX-EX + Lua CAS-renew@ttl/2 + fencing token
+//   - CheckpointStore     — durable HWM cursor, advanced atomically in the apply tx
+//   - DedupeStore         — consumed_events (event_id, topic) composite-PK + sweep
+//   - DeadLetter          — injected sink + fail-closed PII redaction (D401)
+//   - ObservabilityHooks  — canonical worker metrics via the real recordMetric
+//   - SignalDrain         — SIGTERM/SIGINT bounded graceful drain
+//   - WorkerHandle        — the uniform handle the 4 worker types implement
+//
+// Resolve as a downstream consumer would:
+//   import {
+//     SingleActiveLease, CheckpointStore, DedupeStore,
+//     ObservabilityHooks, SignalDrain, type WorkerHandle,
+//   } from "@nodii/telemetry/worker";
+// ── SingleActiveLease (already shipped) ──────────────────────────────────────
+export { encodeLeaseValue, FenceCheckUnavailableError, FenceLostError, fenceKey, leaseKey, parseLeaseValue, SingleActiveLease, } from "./single-active-lease.js";
+// ── Shared SQL-executor seam (the atomic-in-apply-tx handle) ─────────────────
+export { postgresJsExecutor } from "./tx.js";
+// ── CheckpointStore (HWM cursor) ─────────────────────────────────────────────
+export { CheckpointStore, checkpointTableDDL, DEFAULT_CHECKPOINT_TABLE, } from "./checkpoint-store.js";
+// ── DedupeStore ──────────────────────────────────────────────────────────────
+export { consumedEventsTableDDL, DedupeStore, DEFAULT_CONSUMED_EVENTS_TABLE, DEFAULT_RETENTION_DAYS, } from "./dedupe-store.js";
+// ── DeadLetter (injected sink + fail-closed PII redaction) ───────────────────
+export { ensurePiiRedaction, LoudNoopDeadLetterSink, TableDeadLetterSink, withPiiRedaction, } from "./dead-letter.js";
+// ── ObservabilityHooks ───────────────────────────────────────────────────────
+export { hwmGaugeValue, ObservabilityHooks, WORKER_METRIC_NAMES, WORKER_SUBSTRATE_VOCABULARY, } from "./observability-hooks.js";
+// ── SignalDrain ──────────────────────────────────────────────────────────────
+export { SignalDrain } from "./signal-drain.js";
+// ── Worker types (compose the primitives) ────────────────────────────────────
+// The 4 D402 worker types, each implementing WorkerHandle.
+// SweeperWorker — single-active, checkpoint-resumable interval job.
+export { SweeperWorker } from "./sweeper-worker.js";
+// StreamsWorker — generic (non-replication) Pattern-2 stream consumer.
+export { parseAutoClaimEntries, parseStreamEntries, StreamsWorker, streamsConsumerGroup, } from "./streams-worker.js";
+// OutboxDispatcher — Pattern-3 producer drain.
+export { OutboxDispatcher } from "./outbox-dispatcher.js";
+// ReplicationWorker — Pattern-3 subscriber consume (snapshot + LWW + audit).
+export { ReplicationWorker, replicationConsumerGroup, } from "./replication-worker.js";
+//# sourceMappingURL=index.js.map

package/dist/worker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/worker/index.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,2EAA2E;AAC3E,gCAAgC;AAChC,EAAE;AACF,yCAAyC;AACzC,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,6EAA6E;AAC7E,+EAA+E;AAC/E,kEAAkE;AAClE,4EAA4E;AAC5E,EAAE;AACF,0CAA0C;AAC1C,aAAa;AACb,uDAAuD;AACvD,0DAA0D;AAC1D,sCAAsC;AAEtC,gFAAgF;AAChF,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAOlC,gFAAgF;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAG7C,gFAAgF;AAChF,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAG/B,gFAAgF;AAChF,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,6BAA6B,EAC7B,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,gFAAgF;AAChF,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAO1B,gFAAgF;AAChF,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,0BAA0B,CAAC;AAOlC,gFAAgF;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAehD,gFAAgF;AAChF,2DAA2D;AAE3D,oEAAoE;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAQpD,uEAAuE;AACvE,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAS7B,+CAA+C;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAO1D,6EAA6E;AAC7E,OAAO,EACL,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC"}

package/dist/worker/observability-hooks.d.ts

@@ -0,0 +1,99 @@
+import { type RecordMetricArgs } from "../metrics.js";
+import type { MetricVocabularyRegistry } from "../types.js";
+/** Canonical worker-substrate metric names, pinned by D402 + the task. */
+export declare const WORKER_METRIC_NAMES: {
+    readonly leaseAcquired: "nodii.worker.lease.acquired_total";
+    readonly leaseRenewed: "nodii.worker.lease.renewed_total";
+    readonly leaseLost: "nodii.worker.lease.lost_total";
+    readonly lag: "nodii.worker.lag";
+    readonly currentHwm: "nodii.worker.current_hwm";
+    readonly depth: "nodii.worker.depth";
+    readonly drainDurationMs: "nodii.worker.drain.duration_ms";
+    readonly swept: "nodii.worker.swept_total";
+};
+/**
+ * The locked worker-substrate metric vocabulary — merge into
+ * `initTelemetry({ vocabularyRegistry: { ...svc, ...WORKER_SUBSTRATE_VOCABULARY } })`
+ * so the canonical names register under family `async_worker` instead of
+ * tripping `MetricVocabularyError`. Mirrors how `REPLICA_CONSUMER_VOCABULARY`
+ * is consumed.
+ */
+export declare const WORKER_SUBSTRATE_VOCABULARY: MetricVocabularyRegistry;
+/**
+ * Base attributes every worker-substrate metric carries so a service can slice
+ * the canonical series by worker. `service` + `scope` mirror the lease's
+ * `(service, scope)` key shape; `worker` is the worker-type label
+ * (`replication` | `sweeper` | `streams` | `outbox`).
+ */
+export interface WorkerMetricAttributes {
+    service: string;
+    scope: string;
+    worker?: string;
+    [key: string]: string | number | undefined;
+}
+/**
+ * The metric-recording seam. Defaults to telemetry's real `recordMetric`. A
+ * test may inject a capturing fn, but production ALWAYS gets the real path —
+ * there is no no-op default. (To assert emitted points in a test, prefer
+ * `_setMetricsBackend(...)` underneath the real `recordMetric`, exactly as
+ * `metrics.test.ts` does; the `record` seam here exists only for the rare case
+ * a caller wants to swap the whole function.)
+ */
+export type RecordMetricFn = (args: RecordMetricArgs) => void;
+export interface ObservabilityHooksOpts {
+    /** Stable base attributes (service, scope, worker) for every emitted point. */
+    attributes: WorkerMetricAttributes;
+    /**
+     * The metric-recording fn. Defaults to the REAL telemetry `recordMetric`.
+     * Never a no-op. Injectable for direct-capture tests only.
+     */
+    record?: RecordMetricFn;
+}
+/**
+ * ObservabilityHooks emits the canonical worker-substrate metrics through the
+ * real telemetry metric API. One instance per worker; the worker types call
+ * the typed methods at the corresponding lifecycle points (lease acquire/renew/
+ * lose, per-tick lag/hwm/depth refresh, drain on stop, sweep count).
+ *
+ * Usage:
+ *   const hooks = new ObservabilityHooks({
+ *     attributes: { service: "billing", scope: "outbox", worker: "outbox" },
+ *   });
+ *   hooks.leaseAcquired();
+ *   hooks.recordLag(12.5);
+ *   hooks.recordDrainDuration(842);
+ */
+export declare class ObservabilityHooks {
+    private readonly attrs;
+    private readonly record;
+    constructor(opts: ObservabilityHooksOpts);
+    private emit;
+    /** The worker acquired its single-active lease. */
+    leaseAcquired(extra?: Record<string, string | number>): void;
+    /** The worker renewed its lease (CAS held) at ttl/2. */
+    leaseRenewed(extra?: Record<string, string | number>): void;
+    /** The worker lost its lease (renew CAS failed / taken over / errored). */
+    leaseLost(extra?: Record<string, string | number>): void;
+    /** Snapshot the current consumer lag in seconds. */
+    recordLag(seconds: number, extra?: Record<string, string | number>): void;
+    /**
+     * Snapshot the current durable HWM as a numeric position. A Redis-Streams id
+     * (`<ms>-<seq>`) is reduced to its leading ms component so the gauge is a
+     * monotonic-ish stall indicator (the same reduction outbox-dispatcher uses
+     * for `outbox.hwm`); callers with a numeric cursor pass it directly.
+     */
+    recordHwm(position: number, extra?: Record<string, string | number>): void;
+    /** Snapshot the current backlog / stream depth (pending entries). */
+    recordDepth(depth: number, extra?: Record<string, string | number>): void;
+    /** Record the wall-clock ms a graceful drain (stop) took. */
+    recordDrainDuration(ms: number, extra?: Record<string, string | number>): void;
+    /** Count rows removed by a sweeper retention sweep. */
+    recordSwept(count: number, extra?: Record<string, string | number>): void;
+}
+/**
+ * Reduce a Redis-Streams id (`<ms>-<seq>`) to a numeric gauge position (its
+ * leading ms component). Mirrors outbox-dispatcher's `hwmGaugeValue`. A
+ * non-streams numeric string returns its Number; an unparseable value returns 0.
+ */
+export declare function hwmGaugeValue(streamId: string | null): number;
+//# sourceMappingURL=observability-hooks.d.ts.map

package/dist/worker/observability-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability-hooks.d.ts","sourceRoot":"","sources":["../../src/worker/observability-hooks.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAc,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAExE,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB;;;;;;;;;CAStB,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,wBAyDzC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAE9D,MAAM,WAAW,sBAAsB;IACrC,+EAA+E;IAC/E,UAAU,EAAE,sBAAsB,CAAC;IACnC;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAcD;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;gBAE5B,IAAI,EAAE,sBAAsB;IAMxC,OAAO,CAAC,IAAI;IAcZ,mDAAmD;IACnD,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;IAI5D,wDAAwD;IACxD,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;IAI3D,2EAA2E;IAC3E,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;IAIxD,oDAAoD;IACpD,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;IAIzE;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;IAI1E,qEAAqE;IACrE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;IAIzE,6DAA6D;IAC7D,mBAAmB,CACjB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GACtC,IAAI;IAIP,uDAAuD;IACvD,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI;CAG1E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAM7D"}