@groundnuty/macf-channel-server 0.2.47 → 0.2.49

package/dist/delivery/inbox-drain-driver.js

@@ -0,0 +1,109 @@
+/**
+ * Grace window before an undrained entry is considered a genuine orphan
+ * (constraint 1). Deliberately >= the ticker's own tick interval — the
+ * accept()→onNotify()→markProcessed() sequence on the ORIGINAL receive path
+ * completes in well under a second in practice, so an interval comfortably
+ * larger than one tick cycle can never mistake a mid-flight entry for an
+ * orphan.
+ */
+export const DEFAULT_INBOX_DRAIN_GRACE_MS = 30_000;
+/**
+ * Attempt cap (constraint 3). Small + finite — unlike the outbox's
+ * wall-clock-only retry budget (Decision 4 explicitly rejects an attempt
+ * count there, because restart gaps make attempt-count meaningless across
+ * process lifetimes), THIS driver's retries are only ever in-process (a
+ * fresh process gets a fresh, empty attempts `Map` + — today — a fresh,
+ * empty in-memory inbox), so a small attempt cap is the right complementary
+ * bound to the TTL below: it stops hammering a persistently-broken
+ * `onNotify` path quickly, without waiting a full day to give up.
+ */
+export const DEFAULT_INBOX_MAX_ATTEMPTS = 5;
+/**
+ * Wall-clock TTL (constraint 3), mirroring the outbox's `DEFAULT_TTL_MS`
+ * (`outbox.ts`) — same 24h budget, same rationale (an 8h-class outage fits
+ * comfortably; anything longer legitimately downgrades to the give-up path).
+ */
+export const DEFAULT_INBOX_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * Drive one orphan-drain tick: for every undrained inbox entry, either skip
+ * it (too young — constraint 1; or already exhausted — constraint 3), give
+ * it up (TTL exceeded — constraint 3), or re-fire `onNotify` (success →
+ * `markProcessed`, constraint 2; failure → bump the attempt counter,
+ * constraint 3). Callable directly by tests with an explicit `now` + a
+ * fresh `attempts` Map, or wrapped in `inbox-ticker.ts`'s periodic timer.
+ */
+export async function driveInboxOnce(deps) {
+    const { inbox, onNotify, attempts, logger } = deps;
+    const now = deps.now ?? Date.now;
+    const graceMs = deps.graceMs ?? DEFAULT_INBOX_DRAIN_GRACE_MS;
+    const maxAttempts = deps.maxAttempts ?? DEFAULT_INBOX_MAX_ATTEMPTS;
+    const ttlMs = deps.ttlMs ?? DEFAULT_INBOX_TTL_MS;
+    const t = now();
+    const undrained = await inbox.undrained();
+    let attempted = 0;
+    let drained = 0;
+    let failed = 0;
+    let gaveUp = 0;
+    for (const entry of undrained) {
+        const priorAttempts = attempts.get(entry.id) ?? 0;
+        // Constraint 3 (already exhausted): don't re-evaluate age at all once
+        // capped — permanently given-up for THIS driver; only the future
+        // surface-as-text path (constraint 4) is left to deal with it.
+        if (priorAttempts >= maxAttempts) {
+            gaveUp++;
+            continue;
+        }
+        const age = t - entry.receivedAt;
+        // Constraint 3 (TTL): checked before the grace window — an entry old
+        // enough to exceed the TTL is never "too young to be an orphan"; TTL
+        // (default 24h) is always far larger than the grace window (default
+        // 30s), so the two checks never actually compete in practice.
+        if (age > ttlMs) {
+            attempts.set(entry.id, maxAttempts); // pin capped so future ticks short-circuit above
+            gaveUp++;
+            logger?.warn('inbox_drain_gave_up', {
+                id: entry.id,
+                reason: 'ttl_exceeded',
+                age_ms: age,
+                ttl_ms: ttlMs,
+            });
+            continue;
+        }
+        // Constraint 1 (grace-before-drain): too young to be a genuine orphan —
+        // may still be mid-flight in the ORIGINAL accept()→onNotify()→
+        // markProcessed() sequence. Leave it for a later tick.
+        if (age < graceMs) {
+            continue;
+        }
+        attempted++;
+        try {
+            // See InboxDriveDeps.onNotify's doc comment for why this cast is sound.
+            await onNotify(entry.payload);
+            // Constraint 2: markProcessed ONLY after a confirmed onNotify success.
+            await inbox.markProcessed(entry.id);
+            attempts.delete(entry.id);
+            drained++;
+        }
+        catch (err) {
+            failed++;
+            const nextAttempts = priorAttempts + 1;
+            attempts.set(entry.id, nextAttempts);
+            logger?.warn('inbox_drain_refire_failed', {
+                id: entry.id,
+                attempt: nextAttempts,
+                max_attempts: maxAttempts,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            if (nextAttempts >= maxAttempts) {
+                gaveUp++;
+                logger?.warn('inbox_drain_gave_up', {
+                    id: entry.id,
+                    reason: 'max_attempts_exceeded',
+                    attempts: nextAttempts,
+                });
+            }
+        }
+    }
+    return { attempted, drained, failed, gaveUp };
+}
+//# sourceMappingURL=inbox-drain-driver.js.map

package/dist/delivery/inbox-drain-driver.js.map

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

package/dist/delivery/inbox-ticker.d.ts

@@ -0,0 +1,45 @@
+/**
+ * DR-038 Decision 5 follow-on (groundnuty/macf#744) — the mechanism that
+ * DRIVES `inbox-drain-driver.ts`'s `driveInboxOnce()` periodically over the
+ * channel-server's lifetime, so the receiver's own in-process inbox orphans
+ * (an entry whose original `onNotify` threw between `inbox.accept()` and
+ * `inbox.markProcessed()`) get re-fired without waiting for a restart or the
+ * plugin's separate, short-lived startup-drain (which can't see this
+ * process's own in-memory orphans).
+ *
+ * Exact same lifecycle shape as `outbox-ticker.ts` (`start()` / `stop()` /
+ * `tickNow()`, unref()'d interval, tick body never throws past the timer) —
+ * intentionally, so the two DR-038 tickers read as one family in
+ * `server.ts` + `shutdown.ts`.
+ *
+ * `server.ts` calls `tickNow()` once at startup (mirroring the outbox
+ * ticker's own startup tick) BEFORE starting the recurring interval, so any
+ * orphan already undrained when this process comes up gets an immediate
+ * first re-fire attempt rather than waiting a full tick interval.
+ */
+import type { Logger, NotifyPayload } from '@groundnuty/macf-core';
+import type { Inbox } from './inbox.js';
+/** Default retry-drive cadence. Same cadence as the outbox ticker. */
+export declare const DEFAULT_INBOX_TICK_INTERVAL_MS = 30000;
+export interface InboxTicker {
+    /** Start the periodic drive tick (no-op if already started). */
+    readonly start: () => void;
+    /** Clear the interval (idempotent; safe before start). */
+    readonly stop: () => void;
+    /** Fire one drive tick immediately, outside the interval schedule. */
+    readonly tickNow: () => Promise<void>;
+}
+export declare function createInboxTicker(opts: {
+    readonly inbox: Inbox;
+    /** The SAME `onNotify` callback passed to `createHttpsServer`. */
+    readonly onNotify: (payload: NotifyPayload) => Promise<void>;
+    readonly logger: Logger;
+    /** Cadence in ms; default 30s. */
+    readonly intervalMs?: number;
+    readonly graceMs?: number;
+    readonly maxAttempts?: number;
+    readonly ttlMs?: number;
+    /** Injectable epoch-ms clock (testing). Default `Date.now`. */
+    readonly now?: () => number;
+}): InboxTicker;
+//# sourceMappingURL=inbox-ticker.d.ts.map

package/dist/delivery/inbox-ticker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox-ticker.d.ts","sourceRoot":"","sources":["../../src/delivery/inbox-ticker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAQxC,sEAAsE;AACtE,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kCAAkC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B,GAAG,WAAW,CA+Dd"}

package/dist/delivery/inbox-ticker.js

@@ -0,0 +1,68 @@
+import { driveInboxOnce, DEFAULT_INBOX_DRAIN_GRACE_MS, DEFAULT_INBOX_MAX_ATTEMPTS, DEFAULT_INBOX_TTL_MS, } from './inbox-drain-driver.js';
+/** Default retry-drive cadence. Same cadence as the outbox ticker. */
+export const DEFAULT_INBOX_TICK_INTERVAL_MS = 30_000;
+export function createInboxTicker(opts) {
+    const { inbox, onNotify, logger } = opts;
+    const intervalMs = opts.intervalMs ?? DEFAULT_INBOX_TICK_INTERVAL_MS;
+    const graceMs = opts.graceMs ?? DEFAULT_INBOX_DRAIN_GRACE_MS;
+    const maxAttempts = opts.maxAttempts ?? DEFAULT_INBOX_MAX_ATTEMPTS;
+    const ttlMs = opts.ttlMs ?? DEFAULT_INBOX_TTL_MS;
+    const now = opts.now ?? Date.now;
+    // Process-lifetime attempt counter (DR-038 Decision 5 follow-on constraint
+    // 3) — never persisted, never touches the InboxStore/InboxEntry schema,
+    // reset to empty on every fresh process. This IS the "driver-locally"
+    // bookkeeping the design calls for: the ticker owns the one long-lived Map
+    // instance and hands it to `driveInboxOnce` unchanged on every tick so
+    // attempt counts actually accumulate across ticks.
+    const attempts = new Map();
+    let timer = null;
+    async function tickNow() {
+        try {
+            const summary = await driveInboxOnce({
+                inbox,
+                onNotify,
+                attempts,
+                logger,
+                now,
+                graceMs,
+                maxAttempts,
+                ttlMs,
+            });
+            if (summary.attempted > 0 || summary.gaveUp > 0) {
+                logger.info('inbox_drain_tick', {
+                    attempted: summary.attempted,
+                    drained: summary.drained,
+                    failed: summary.failed,
+                    gave_up: summary.gaveUp,
+                });
+            }
+        }
+        catch (err) {
+            // Best-effort: a driveInboxOnce failure (store I/O error, etc.) must
+            // never escape a timer callback and become an uncaughtException — same
+            // posture as outbox-ticker.ts's tick(). The next tick retries.
+            logger.warn('inbox_drain_tick_failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return {
+        start() {
+            if (timer !== null)
+                return;
+            timer = setInterval(() => {
+                void tickNow();
+            }, intervalMs);
+            // Never let the drain-drive interval keep the process alive.
+            timer.unref();
+        },
+        stop() {
+            if (timer !== null) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+        tickNow,
+    };
+}
+//# sourceMappingURL=inbox-ticker.js.map

package/dist/delivery/inbox-ticker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox-ticker.js","sourceRoot":"","sources":["../../src/delivery/inbox-ticker.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,cAAc,EACd,4BAA4B,EAC5B,0BAA0B,EAC1B,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AAEjC,sEAAsE;AACtE,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC;AAWrD,MAAM,UAAU,iBAAiB,CAAC,IAYjC;IACC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACzC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,8BAA8B,CAAC;IACrE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,4BAA4B,CAAC;IAC7D,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,0BAA0B,CAAC;IACnE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,oBAAoB,CAAC;IACjD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IACjC,2EAA2E;IAC3E,wEAAwE;IACxE,sEAAsE;IACtE,2EAA2E;IAC3E,uEAAuE;IACvE,mDAAmD;IACnD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC3C,IAAI,KAAK,GAA0C,IAAI,CAAC;IAExD,KAAK,UAAU,OAAO;QACpB,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC;gBACnC,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,MAAM;gBACN,GAAG;gBACH,OAAO;gBACP,WAAW;gBACX,KAAK;aACN,CAAC,CAAC;YACH,IAAI,OAAO,CAAC,SAAS,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChD,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;oBAC9B,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,OAAO,EAAE,OAAO,CAAC,OAAO;oBACxB,MAAM,EAAE,OAAO,CAAC,MAAM;oBACtB,OAAO,EAAE,OAAO,CAAC,MAAM;iBACxB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,qEAAqE;YACrE,uEAAuE;YACvE,+DAA+D;YAC/D,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE;gBACrC,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;aACxD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,OAAO;QACL,KAAK;YACH,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO;YAC3B,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;gBACvB,KAAK,OAAO,EAAE,CAAC;YACjB,CAAC,EAAE,UAAU,CAAC,CAAC;YACf,6DAA6D;YAC7D,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;QACD,IAAI;YACF,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,aAAa,CAAC,KAAK,CAAC,CAAC;gBACrB,KAAK,GAAG,IAAI,CAAC;YACf,CAAC;QACH,CAAC;QACD,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/delivery/inbox.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DR-038 Decisions 1, 3, 5 — the receiver-side effectively-once logic:
+ * persist-THEN-ack ordering (Decision 3), and the store-backed primitives
+ * the inbox drain (Decision 5) needs.
+ *
+ * Runtime-agnostic over an injected `InboxStore` (the pluggable driver
+ * interface, hoisted to `@groundnuty/macf-core`'s `delivery/store.ts` —
+ * macf#741). The drain TRIGGER itself — hooking `accept` into the HTTP
+ * `/notify` / `message/send` handler (on-receipt), and hooking `undrained`
+ * + `markProcessed` into the plugin's SessionStart `startup_check`
+ * (on-startup) — is a follow-on slice. This module provides the store-
+ * backed primitives both triggers call into, with the dedup-by-id property
+ * that makes the two triggers safe to run overlapping (Decision 5: "no
+ * periodic drain is needed if receipt + startup cover it").
+ */
+import type { InboxStore, InboxEntry } from '@groundnuty/macf-core';
+export interface InboxAcceptResult {
+    /**
+     * `true` when this `id` was genuinely new — now durably persisted for
+     * the first time. `false` when it was a redelivery: the existing
+     * persisted entry is left untouched (idempotent no-op per Decision 1's
+     * "idempotent receipt").
+     */
+    readonly wasNew: boolean;
+}
+export interface InboxDeps {
+    readonly store: InboxStore;
+    /** Injectable epoch-ms clock (testing). Default `Date.now`. */
+    readonly now?: () => number;
+}
+export interface Inbox {
+    /**
+     * Persist-THEN-ack (DR-038 Decision 3). The caller — the HTTP handler at
+     * the `/notify` or `message/send` boundary — MUST `await` this and
+     * return its HTTP 200 only AFTER it resolves. Returning 200 before this
+     * resolves would make the ACK mean "received" instead of "durably
+     * yours," reproducing the exact silent-fallback shape (success at the
+     * boundary, semantic durability absent — see `silent-fallback-hazards.md`)
+     * Decision 3 exists to avoid.
+     *
+     * A re-delivered `id` dedups here (`wasNew: false`) rather than
+     * re-persisting or re-processing — the caller still returns 200 per
+     * Decision 3 ("a lost-in-transit 200 is safe: the sender re-sends the
+     * same id → the receiver dedups... → re-returns 200. Idempotent by
+     * construction.").
+     */
+    readonly accept: (id: string, payload: unknown) => Promise<InboxAcceptResult>;
+    /**
+     * Persisted-but-not-processed entries — DR-038 Decision 5's drain input,
+     * read by both the on-receipt and on-startup triggers.
+     */
+    readonly undrained: () => Promise<InboxEntry[]>;
+    /** Mark an entry processed once the drain has handled it — won't be re-drained. */
+    readonly markProcessed: (id: string) => Promise<void>;
+}
+export declare function createInbox(deps: InboxDeps): Inbox;
+//# sourceMappingURL=inbox.d.ts.map

package/dist/delivery/inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.d.ts","sourceRoot":"","sources":["../../src/delivery/inbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEpE,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,KAAK;IACpB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE9E;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAEhD,mFAAmF;IACnF,QAAQ,CAAC,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK,CAkBlD"}

package/dist/delivery/inbox.js

@@ -0,0 +1,19 @@
+export function createInbox(deps) {
+    const { store } = deps;
+    const now = deps.now ?? Date.now;
+    return {
+        async accept(id, payload) {
+            const entry = {
+                id,
+                payload,
+                receivedAt: now(),
+                processed: false,
+            };
+            const wasNew = await store.persist(entry);
+            return { wasNew };
+        },
+        undrained: () => store.listUndrained(),
+        markProcessed: (id) => store.markProcessed(id),
+    };
+}
+//# sourceMappingURL=inbox.js.map

package/dist/delivery/inbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.js","sourceRoot":"","sources":["../../src/delivery/inbox.ts"],"names":[],"mappings":"AA6DA,MAAM,UAAU,WAAW,CAAC,IAAe;IACzC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IACvB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IAEjC,OAAO;QACL,KAAK,CAAC,MAAM,CAAC,EAAU,EAAE,OAAgB;YACvC,MAAM,KAAK,GAAe;gBACxB,EAAE;gBACF,OAAO;gBACP,UAAU,EAAE,GAAG,EAAE;gBACjB,SAAS,EAAE,KAAK;aACjB,CAAC;YACF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC1C,OAAO,EAAE,MAAM,EAAE,CAAC;QACpB,CAAC;QACD,SAAS,EAAE,GAA0B,EAAE,CAAC,KAAK,CAAC,aAAa,EAAE;QAC7D,aAAa,EAAE,CAAC,EAAU,EAAiB,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;KACtE,CAAC;AACJ,CAAC"}

package/dist/delivery/message-id.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Mint a fresh message-id for a NEW outbox entry. Call this exactly ONCE per
+ * logical message, at enqueue time — never again for the same message on
+ * retry (the persisted id is what gets reused). `randomUUID()` is Node's
+ * CSPRNG-backed UUIDv4 generator (no weak-PRNG concern; matches the
+ * `no-weak-prng` invariant already enforced elsewhere in this package, e.g.
+ * `notify-peer.ts` / `https.ts`).
+ */
+export declare function mintMessageId(): string;
+//# sourceMappingURL=message-id.d.ts.map

package/dist/delivery/message-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-id.d.ts","sourceRoot":"","sources":["../../src/delivery/message-id.ts"],"names":[],"mappings":"AAsBA;;;;;;;GAOG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC"}

package/dist/delivery/message-id.js

@@ -0,0 +1,33 @@
+/**
+ * DR-038 Decision 2 — the message-id contract for the effectively-once
+ * delivery layer.
+ *
+ * A UUIDv4, minted ONCE at outbox-enqueue, persisted with the entry BEFORE
+ * the first send, and reused VERBATIM on every retry — including across a
+ * sender restart (the id is stable because it's persisted, never
+ * regenerated). This is the whole receiver-side dedup key (Decision 1):
+ * `InboxStore.persist()` dedups by this id, which is what makes
+ * `message/send` safe to retry without the operation itself being
+ * idempotent.
+ *
+ * NOT a content-hash of the payload: two legitimately-identical messages
+ * (a peer sending "ping" twice, deliberately) would wrongly dedup-collide to
+ * one under a content-hash scheme. NOT a ULID: its only edge over UUIDv4 is
+ * a lexicographic time-ordering hint, but DR-038 explicitly scopes
+ * guaranteed ordering OUT of this delivery layer (see the DR's "Boundaries"
+ * section), and both `OutboxEntry` and `InboxEntry` already carry their own
+ * timestamp field for drain-ordering — so the id itself needn't encode time.
+ */
+import { randomUUID } from 'node:crypto';
+/**
+ * Mint a fresh message-id for a NEW outbox entry. Call this exactly ONCE per
+ * logical message, at enqueue time — never again for the same message on
+ * retry (the persisted id is what gets reused). `randomUUID()` is Node's
+ * CSPRNG-backed UUIDv4 generator (no weak-PRNG concern; matches the
+ * `no-weak-prng` invariant already enforced elsewhere in this package, e.g.
+ * `notify-peer.ts` / `https.ts`).
+ */
+export function mintMessageId() {
+    return randomUUID();
+}
+//# sourceMappingURL=message-id.js.map

package/dist/delivery/message-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-id.js","sourceRoot":"","sources":["../../src/delivery/message-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,UAAU,EAAE,CAAC;AACtB,CAAC"}

package/dist/delivery/outbox-ticker.d.ts

@@ -0,0 +1,50 @@
+/**
+ * DR-038 Decision 4 — the mechanism that DRIVES the persisted outbox's retry
+ * loop over the channel-server's lifetime.
+ *
+ * `outbox.ts`'s `driveOnce()` is a pure, callable-on-demand function; nothing
+ * in Slice A ticks it periodically. Two triggers combine to give the full
+ * restart-survival + eventual-retry contract:
+ *
+ *   1. `notify_peer`'s own enqueue path calls `driveOnce()` once immediately
+ *      after enqueueing (see `notify-peer.ts`) — the reachable-peer common
+ *      case is delivered inline, same UX as pre-DR-038 fire-and-forget.
+ *   2. THIS periodic, unref()'d ticker — mirrors `alive-ticker.ts` /
+ *      `registry-heartbeat.ts`'s exact lifecycle shape (`start()` / `stop()`,
+ *      never pins the event loop, tick body never throws past the timer) —
+ *      is what drives backed-off RETRIES for an unreachable peer, and
+ *      eventually TTL-expiry dead-lettering, WITHOUT requiring another
+ *      `notify_peer` call to happen to trigger the next attempt. Without
+ *      this, a message to a peer that's down for hours would sit in the
+ *      outbox forever unless some other notify_peer call happened to touch
+ *      the same store and incidentally drive it — that's not a retry
+ *      schedule, that's luck.
+ *
+ * `server.ts` also calls `tickNow()` once at startup (DR-038 Decision 4:
+ * "resumed on sender startup") BEFORE starting the recurring interval, so any
+ * entry already overdue when the process comes up (a message enqueued by a
+ * prior process instance, surviving via a durable store driver once DR-008
+ * lands) gets its first post-restart attempt immediately rather than waiting
+ * a full tick interval.
+ */
+import type { Logger } from '@groundnuty/macf-core';
+import type { Outbox } from './outbox.js';
+/** Default retry-drive cadence. Deliberately coarser than the alive-ticker's
+ * 60s — this is a backstop for the backoff schedule (1s..5min), not a
+ * liveness signal; a shorter interval would mostly find nothing due. */
+export declare const DEFAULT_OUTBOX_TICK_INTERVAL_MS = 30000;
+export interface OutboxTicker {
+    /** Start the periodic drive tick (no-op if already started). */
+    readonly start: () => void;
+    /** Clear the interval (idempotent; safe before start). */
+    readonly stop: () => void;
+    /** Fire one drive tick immediately, outside the interval schedule. */
+    readonly tickNow: () => Promise<void>;
+}
+export declare function createOutboxTicker(opts: {
+    readonly outbox: Outbox;
+    readonly logger: Logger;
+    /** Cadence in ms; default 30s. */
+    readonly intervalMs?: number;
+}): OutboxTicker;
+//# sourceMappingURL=outbox-ticker.d.ts.map

package/dist/delivery/outbox-ticker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-ticker.d.ts","sourceRoot":"","sources":["../../src/delivery/outbox-ticker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;wEAEwE;AACxE,eAAO,MAAM,+BAA+B,QAAS,CAAC;AAEtD,MAAM,WAAW,YAAY;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kCAAkC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,GAAG,YAAY,CA2Cf"}

package/dist/delivery/outbox-ticker.js

@@ -0,0 +1,49 @@
+/** Default retry-drive cadence. Deliberately coarser than the alive-ticker's
+ * 60s — this is a backstop for the backoff schedule (1s..5min), not a
+ * liveness signal; a shorter interval would mostly find nothing due. */
+export const DEFAULT_OUTBOX_TICK_INTERVAL_MS = 30_000;
+export function createOutboxTicker(opts) {
+    const { outbox, logger } = opts;
+    const intervalMs = opts.intervalMs ?? DEFAULT_OUTBOX_TICK_INTERVAL_MS;
+    let timer = null;
+    async function tickNow() {
+        try {
+            const summary = await outbox.driveOnce();
+            if (summary.attempted > 0 || summary.deadLettered > 0) {
+                logger.info('outbox_drive_tick', {
+                    attempted: summary.attempted,
+                    acked: summary.acked,
+                    failed: summary.failed,
+                    dead_lettered: summary.deadLettered,
+                });
+            }
+        }
+        catch (err) {
+            // Best-effort: a driveOnce failure (store I/O error, etc.) must never
+            // escape a timer callback and become an uncaughtException — same
+            // posture as alive-ticker.ts's tick(). The next tick retries.
+            logger.warn('outbox_drive_tick_failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return {
+        start() {
+            if (timer !== null)
+                return;
+            timer = setInterval(() => {
+                void tickNow();
+            }, intervalMs);
+            // Never let the retry-drive interval keep the process alive.
+            timer.unref();
+        },
+        stop() {
+            if (timer !== null) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+        tickNow,
+    };
+}
+//# sourceMappingURL=outbox-ticker.js.map

package/dist/delivery/outbox-ticker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-ticker.js","sourceRoot":"","sources":["../../src/delivery/outbox-ticker.ts"],"names":[],"mappings":"AAgCA;;wEAEwE;AACxE,MAAM,CAAC,MAAM,+BAA+B,GAAG,MAAM,CAAC;AAWtD,MAAM,UAAU,kBAAkB,CAAC,IAKlC;IACC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAChC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,+BAA+B,CAAC;IACtE,IAAI,KAAK,GAA0C,IAAI,CAAC;IAExD,KAAK,UAAU,OAAO;QACpB,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,SAAS,EAAE,CAAC;YACzC,IAAI,OAAO,CAAC,SAAS,GAAG,CAAC,IAAI,OAAO,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;gBACtD,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE;oBAC/B,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;oBACpB,MAAM,EAAE,OAAO,CAAC,MAAM;oBACtB,aAAa,EAAE,OAAO,CAAC,YAAY;iBACpC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,sEAAsE;YACtE,iEAAiE;YACjE,8DAA8D;YAC9D,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE;gBACtC,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;aACxD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,OAAO;QACL,KAAK;YACH,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO;YAC3B,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;gBACvB,KAAK,OAAO,EAAE,CAAC;YACjB,CAAC,EAAE,UAAU,CAAC,CAAC;YACf,6DAA6D;YAC7D,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;QACD,IAAI;YACF,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,aAAa,CAAC,KAAK,CAAC,CAAC;gBACrB,KAAK,GAAG,IAAI,CAAC;YACf,CAAC;QACH,CAAC;QACD,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/delivery/outbox.d.ts

@@ -0,0 +1,105 @@
+/**
+ * DR-038 Decisions 1, 2, 4 — the sender-side effectively-once logic:
+ * persist-then-send, stable message-id reuse across retries, exponential-
+ * backoff retry bounded by a wall-clock TTL, and dead-letter escalation on
+ * TTL expiry.
+ *
+ * Runtime-agnostic over an injected `OutboxStore` (the pluggable driver
+ * interface, hoisted to `@groundnuty/macf-core`'s `delivery/store.ts` —
+ * macf#741), an injected `send` transport seam, and an injected clock — so
+ * the whole retry loop is deterministically testable without real time or
+ * real network I/O, and so a driver swap (in-memory here, VM disk-spool /
+ * K8s PVC-broker per DR-008) never touches this file.
+ *
+ * Retries are driven off the PERSISTED outbox, not an in-memory queue:
+ * `driveOnce` re-reads `store.listPending()` on every call. This is the
+ * crux of restart-survival (Decision 4) — a fresh `createOutbox()` instance
+ * over the SAME store (simulating a sender restart) sees every entry a
+ * prior process instance hadn't finished with, and its very first
+ * `driveOnce` picks up anything already past its `nextAttemptAt` — which is
+ * also what naturally implements the DR-038 "Open Questions" lean ("one
+ * immediate attempt on startup... then re-enter backoff") without any
+ * startup-specific code path: an overdue entry is simply due right away.
+ */
+import type { Logger, OutboxStore, OutboxEntry } from '@groundnuty/macf-core';
+/**
+ * Result of one send attempt. `ack: true` means durable-ACK per DR-038
+ * Decision 3 (an HTTP 200 the *receiver* only returns after its own
+ * persist-then-ACK). Anything else — `ack: false`, or the `send` promise
+ * rejecting — is treated uniformly as a delivery failure (timeout, 5xx,
+ * connection-refused: the dead-peer case) and the entry stays in the
+ * outbox for retry.
+ */
+export interface OutboxSendResult {
+    readonly ack: boolean;
+}
+/**
+ * The injected transport seam. A real implementation dispatches the actual
+ * `message/send` (or legacy notify_peer POST) call; this module never
+ * touches the network directly — that keeps the effectively-once logic
+ * testable with a fake and reusable across transports.
+ */
+export type OutboxSendFn = (target: string, id: string, payload: unknown) => Promise<OutboxSendResult>;
+/** Default exponential-backoff base (DR-038 Decision 4: "~1s → … → 5min"). */
+export declare const DEFAULT_BACKOFF_BASE_MS = 1000;
+/** Default exponential-backoff cap (DR-038 Decision 4: "~1s → … → 5min"). */
+export declare const DEFAULT_BACKOFF_CAP_MS: number;
+/**
+ * Default wall-clock TTL bounding the retry budget. DR-038 Decision 4
+ * proposes 24h ("the 8h outage fits comfortably; a multi-day VM outage
+ * would dead-letter, correctly escalating to GitHub" — Open Questions).
+ */
+export declare const DEFAULT_TTL_MS: number;
+/**
+ * `baseMs * 2^attemptCount`, capped at `capMs`. `attemptCount` is the number
+ * of PRIOR failed attempts (0 on the first failure → backoff = `baseMs`).
+ * A wall-clock TTL bounds the retry budget (see `DEFAULT_TTL_MS`), NOT an
+ * attempt-count ceiling — an attempt count is meaningless across restart
+ * gaps of varying length (DR-038 Decision 4).
+ */
+export declare function computeBackoffMs(attemptCount: number, baseMs?: number, capMs?: number): number;
+export interface OutboxDeps {
+    readonly store: OutboxStore;
+    readonly send: OutboxSendFn;
+    /** Injectable epoch-ms clock (testing). Default `Date.now`. */
+    readonly now?: () => number;
+    /**
+     * Invoked once per TTL-expired entry, AFTER `store.deadLetter(id)` has
+     * already run. This is the decision-layer escalation hook DR-038
+     * Decision 4 requires ("a `gh issue` to the operator/reporter... a
+     * decision-layer action... NOT a store-driver method") — this slice does
+     * NOT implement the GitHub call itself; a later wiring slice supplies a
+     * real callback. A throw from this callback is caught + logged, never
+     * allowed to abort the rest of the drive tick.
+     */
+    readonly onDeadLetter?: (entry: OutboxEntry) => void | Promise<void>;
+    readonly logger?: Logger;
+    readonly backoffBaseMs?: number;
+    readonly backoffCapMs?: number;
+    readonly ttlMs?: number;
+}
+/** Per-tick counters, mainly for test assertions + operator diagnostics. */
+export interface OutboxDriveSummary {
+    readonly attempted: number;
+    readonly acked: number;
+    readonly failed: number;
+    readonly deadLettered: number;
+}
+export interface Outbox {
+    /**
+     * Persist a NEW message BEFORE any send attempt (Decision 1: persist-
+     * then-send). Mints a fresh message-id (Decision 2) and returns it.
+     */
+    readonly enqueue: (target: string, payload: unknown) => Promise<string>;
+    /**
+     * Drive one retry tick: for every pending entry whose `nextAttemptAt <=
+     * now`, either dead-letter it (TTL expired — checked BEFORE attempting
+     * another send) or attempt a send (ack → `markAcked`; failure →
+     * `reschedule` with the next backoff). Callable directly by tests with an
+     * explicit `now`, or wrapped in an operator-driven loop with injected
+     * sleep between ticks.
+     */
+    readonly driveOnce: (now?: number) => Promise<OutboxDriveSummary>;
+}
+export declare function createOutbox(deps: OutboxDeps): Outbox;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/delivery/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../src/delivery/outbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAG9E;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,KACb,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAE/B,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAE7C,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,QAAgB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAsB,CAAC;AAElD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,MAAM,GAAE,MAAgC,EACxC,KAAK,GAAE,MAA+B,GACrC,MAAM,CAGR;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B;;;;;;;;OAQG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACxE;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACnE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAmFrD"}