@honua/react 0.1.2-beta.0 → 0.1.4-beta.0

package/realtime/resumable-transport.js

@@ -0,0 +1,406 @@
+/**
+ * Bounded, resumable SSE and WebSocket transports for `@honua/sdk-js/realtime`
+ * (issue #557), built on the #556 snapshot/delta/cursor/resume/plan-identity
+ * contract.
+ *
+ * `resumable.ts` deliberately never reconnects a transport — that ownership
+ * is explicitly deferred to this module (see
+ * `docs/decisions/realtime-snapshot-delta-cursor-resume-plan-identity-contract.md`,
+ * "the gate never reconnects a transport itself"). This module closes that
+ * gap by wrapping any raw {@link RealtimeFeatureTransport} (the SSE adapter
+ * in `sse.ts`, the WebSocket adapter in `websocket.ts`, or a custom one) with:
+ *
+ * - the bounded delivery gate from `resumable.ts` (`maxPendingEvents`,
+ *   duplicate/gap detection, cross-scope checkpoint rejection);
+ * - reconnect ownership with exponential-backoff-and-jitter retry, bounded by
+ *   `reconnect.maxAttempts` — exhausting attempts fails closed rather than
+ *   retrying forever;
+ * - a heartbeat/liveness timeout that treats prolonged silence as a
+ *   transport-detected gap;
+ * - resume-vs-resnapshot selection driven entirely by the gate's own
+ *   `phase`: a reconnect resumes from the last accepted checkpoint's cursor
+ *   only while the gate considers it valid, and requests a fresh snapshot
+ *   the moment the gate (or this module, via `requireResnapshot`) decides
+ *   otherwise — REQ-003's "resume only with a valid scoped cursor";
+ * - idempotent disposal that stops timers, the active connection, and the
+ *   delivery gate exactly once, however disposal was triggered
+ *   (caller `close()`, external `AbortSignal`, or an unrecoverable failure);
+ * - redacted telemetry (`onTelemetry`) built on `contract.ts`'s
+ *   `deriveRealtimeContractAuthority` / `redactRealtimeCheckpoint`, so a raw
+ *   cursor, watermark, or delta-token never reaches a log or metrics sink.
+ *
+ * The result still satisfies `RealtimeFeatureTransport`, so it composes with
+ * `createRealtimeFeatureStore` exactly like any other transport.
+ *
+ * @module
+ */
+import { deriveRealtimeContractAuthority, redactRealtimeCheckpoint } from "./contract.js";
+import { HonuaRealtimeResumeError, createResumableRealtimeSubscription, } from "./resumable.js";
+import { createRealtimeServerSentEventsTransport } from "./sse.js";
+import { createRealtimeWebSocketTransport } from "./websocket.js";
+const DEFAULT_MAX_ATTEMPTS = 8;
+const DEFAULT_BASE_DELAY_MS = 250;
+const DEFAULT_MAX_DELAY_MS = 30_000;
+const DEFAULT_RESET_AFTER_MS = 15_000;
+const EXTERNAL_RESNAPSHOT_REASONS = new Set([
+    "cursor-expired",
+    "resume-unsupported",
+    "transport-gap",
+]);
+function normalizeReconnectPolicy(policy) {
+    return {
+        maxAttempts: nonNegativeIntOr(policy?.maxAttempts, DEFAULT_MAX_ATTEMPTS),
+        baseDelayMs: nonNegativeIntOr(policy?.baseDelayMs, DEFAULT_BASE_DELAY_MS),
+        maxDelayMs: nonNegativeIntOr(policy?.maxDelayMs, DEFAULT_MAX_DELAY_MS),
+        resetAfterMs: nonNegativeIntOr(policy?.resetAfterMs, DEFAULT_RESET_AFTER_MS),
+    };
+}
+function nonNegativeIntOr(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return fallback;
+    return Math.trunc(value);
+}
+/**
+ * Exponential backoff with jitter in the [0.5x, 1x] band for the given
+ * zero-based reconnect attempt — the same shape as
+ * `core/request-pipeline.ts`'s `resolveRetryDelayMs`, reimplemented locally
+ * so `@honua/sdk-js/realtime` does not pull in the HTTP request pipeline's
+ * error/type graph for one small helper. Exported so the schedule can be
+ * asserted deterministically without driving a fake transport end-to-end.
+ */
+export function computeReconnectDelayMs(policy, attempt) {
+    const normalized = normalizeReconnectPolicy(policy);
+    const exponential = normalized.baseDelayMs * 2 ** Math.max(0, attempt);
+    const capped = Math.min(normalized.maxDelayMs, exponential);
+    return capped * (0.5 + Math.random() * 0.5);
+}
+/**
+ * Wrap a raw {@link RealtimeFeatureTransport} with bounded, resumable
+ * delivery: the #556 delivery gate, reconnect/backoff, heartbeat timeout,
+ * and redacted telemetry. See the module doc for the full behavior.
+ */
+export function createResumableRealtimeTransport(transport, options) {
+    const policy = normalizeReconnectPolicy(options.reconnect);
+    return {
+        capabilities: transport.capabilities,
+        subscribe(request, observer) {
+            if (request.signal?.aborted) {
+                observer.complete();
+                return { close: () => { } };
+            }
+            // Every field that could seed a resume position is dropped: this
+            // wrapper always derives `resumeFrom` from the gate's own validated
+            // checkpoint (see `connect()`), never from caller input, so a stale or
+            // unscoped position can never reach the wire.
+            const { cursor: _cursor, watermark: _watermark, timestamp: _timestamp, deltaToken: _deltaToken, resumeFrom: _resumeFrom, signal: _signal, ...baseIdentity } = request;
+            const lifecycle = new AbortController();
+            // `lifecycle.signal` is handed to `gate` and to every `transport.subscribe()`
+            // call so a well-behaved transport (sse.ts, websocket.ts) tears itself down
+            // too, but disposal here never depends on that: `disposeGracefully`/
+            // `failClosed` below also close the active handle directly, so an external
+            // abort is honored even against a transport double that ignores `signal`.
+            const externalAbort = () => disposeGracefully("Subscription signal was aborted.");
+            if (request.signal)
+                request.signal.addEventListener("abort", externalAbort, { once: true });
+            let gate;
+            let activeHandle;
+            let heartbeatTimer;
+            let reconnectTimer;
+            let reconnectAttempt = 0;
+            let connectedAt;
+            let closed = false;
+            let expectingTeardown = false;
+            const currentNow = () => options.now?.() ?? Date.now();
+            function emitTelemetry() {
+                if (!options.onTelemetry || !gate)
+                    return;
+                const state = gate.state;
+                try {
+                    options.onTelemetry({
+                        authority: deriveRealtimeContractAuthority(state, {
+                            staleAfterMs: options.staleAfterMs,
+                            now: currentNow(),
+                        }),
+                        reconnectAttempt,
+                        acceptedEventCount: state.acceptedEventCount,
+                        duplicateEventCount: state.duplicateEventCount,
+                        gapCount: state.gapCount,
+                        overflowCount: state.overflowCount,
+                        ...(state.checkpoint ? { checkpoint: redactRealtimeCheckpoint(state.checkpoint) } : {}),
+                    });
+                }
+                catch {
+                    // Telemetry is diagnostic and must never affect delivery; a
+                    // throwing onTelemetry callback is the caller's bug, not a
+                    // reason to fail the subscription.
+                }
+            }
+            function hasBeenStableSince() {
+                return connectedAt !== undefined && currentNow() - connectedAt >= policy.resetAfterMs;
+            }
+            function clearHeartbeatTimer() {
+                if (heartbeatTimer !== undefined) {
+                    clearTimeout(heartbeatTimer);
+                    heartbeatTimer = undefined;
+                }
+            }
+            function clearReconnectTimer() {
+                if (reconnectTimer !== undefined) {
+                    clearTimeout(reconnectTimer);
+                    reconnectTimer = undefined;
+                }
+            }
+            function armHeartbeat() {
+                if (options.heartbeatTimeoutMs === undefined)
+                    return;
+                clearHeartbeatTimer();
+                heartbeatTimer = setTimeout(onHeartbeatTimeout, options.heartbeatTimeoutMs);
+            }
+            function onHeartbeatTimeout() {
+                heartbeatTimer = undefined;
+                if (closed || !gate)
+                    return;
+                gate.requireResnapshot("transport-gap", `No realtime event observed within ${String(options.heartbeatTimeoutMs)}ms.`);
+                scheduleReconnect("heartbeat-timeout");
+            }
+            function teardownActiveHandle() {
+                clearHeartbeatTimer();
+                if (!activeHandle)
+                    return;
+                const handle = activeHandle;
+                activeHandle = undefined;
+                expectingTeardown = true;
+                try {
+                    handle.close();
+                }
+                finally {
+                    expectingTeardown = false;
+                }
+            }
+            function isExternalResnapshotReason(code) {
+                return EXTERNAL_RESNAPSHOT_REASONS.has(code);
+            }
+            function handleTransportError(error) {
+                if (closed)
+                    return;
+                const resumeError = error instanceof HonuaRealtimeResumeError ? error : undefined;
+                if (!resumeError?.retryable) {
+                    failClosed(error);
+                    return;
+                }
+                if (isExternalResnapshotReason(resumeError.code)) {
+                    gate?.requireResnapshot(resumeError.code, resumeError.message);
+                }
+                scheduleReconnect(resumeError.message);
+            }
+            function scheduleReconnect(detail) {
+                if (closed || lifecycle.signal.aborted || !gate)
+                    return;
+                // A burst of in-flight deliveries (e.g. several queued events that
+                // each resolve `resnapshot-required`) can each call this before the
+                // pending reconnect delay fires. Only the first is honored — a
+                // reconnect is already scheduled, so later calls in the same burst
+                // must be deduplicated into it rather than each arming their own
+                // `setTimeout` (which would leak timers, double-count
+                // `reconnectAttempt`, and open several concurrent connections when
+                // they all fire).
+                if (reconnectTimer !== undefined)
+                    return;
+                teardownActiveHandle();
+                if (reconnectAttempt >= policy.maxAttempts) {
+                    failClosed(new HonuaRealtimeResumeError("delivery-failed", `Realtime transport reconnect attempts exhausted after ${String(reconnectAttempt)} tries (${detail}).`));
+                    return;
+                }
+                const delay = computeReconnectDelayMs(options.reconnect, reconnectAttempt);
+                reconnectAttempt += 1;
+                emitTelemetry();
+                reconnectTimer = setTimeout(() => {
+                    reconnectTimer = undefined;
+                    void connect();
+                }, delay);
+            }
+            async function connect() {
+                if (closed || lifecycle.signal.aborted || !gate)
+                    return;
+                connectedAt = undefined;
+                // Resume only while the gate still considers the last checkpoint
+                // valid (REQ-003). Once the gate — or `requireResnapshot` above —
+                // has moved to `resnapshot-required`, the checkpoint is left in
+                // place for callers that read it, but this wrapper never sends it
+                // back over the wire until a fresh snapshot is accepted.
+                const requiresResnapshot = gate.state.phase === "resnapshot-required";
+                const resumeFrom = requiresResnapshot ? undefined : gate.state.checkpoint?.resume;
+                // The gate's sole recovery path out of `resnapshot-required` is a
+                // `snapshot` event (`resumable.ts`'s `enqueue`: every other event is
+                // rejected while that phase holds). A subscription originally opened
+                // in pure `delta` mode never asks the transport for an initial
+                // snapshot, so reconnecting still in `delta` mode after a
+                // cursor-expired / transport-gap resnapshot would drop `resumeFrom`
+                // but never receive the snapshot needed to leave `resnapshot-required`
+                // — every subsequent delta is silently rejected and the caller loses
+                // the gap's data (and everything after it) for good. Upgrade to
+                // `snapshot-then-delta` so the reconnect requests a fresh snapshot
+                // before deltas resume.
+                const modeOverride = requiresResnapshot && baseIdentity.mode === "delta" ? { mode: "snapshot-then-delta" } : {};
+                const effectiveRequest = {
+                    ...baseIdentity,
+                    ...modeOverride,
+                    ...(resumeFrom ? { resumeFrom } : {}),
+                    signal: lifecycle.signal,
+                };
+                try {
+                    activeHandle = transport.subscribe(effectiveRequest, innerObserver);
+                }
+                catch (cause) {
+                    handleTransportError(cause);
+                    return;
+                }
+                if (closed) {
+                    // The transport completed or errored synchronously inside
+                    // subscribe(), before returning its handle: disposal already ran
+                    // without it. Close it now so nothing leaks.
+                    activeHandle?.close();
+                    activeHandle = undefined;
+                    return;
+                }
+                emitTelemetry();
+            }
+            /** Stop timers, the active connection, and the gate exactly once, then report a clean end. Idempotent. */
+            function disposeGracefully(reason) {
+                if (closed)
+                    return;
+                closed = true;
+                clearHeartbeatTimer();
+                clearReconnectTimer();
+                teardownActiveHandle();
+                gate?.close(reason);
+                if (request.signal)
+                    request.signal.removeEventListener("abort", externalAbort);
+                if (!lifecycle.signal.aborted)
+                    lifecycle.abort(reason);
+                emitTelemetry();
+                observer.complete();
+            }
+            /** Stop timers, the active connection, and the gate exactly once, then report a terminal failure. Idempotent. */
+            function failClosed(error) {
+                if (closed)
+                    return;
+                closed = true;
+                clearHeartbeatTimer();
+                clearReconnectTimer();
+                teardownActiveHandle();
+                gate?.close(errorMessage(error));
+                if (request.signal)
+                    request.signal.removeEventListener("abort", externalAbort);
+                if (!lifecycle.signal.aborted)
+                    lifecycle.abort("realtime resumable transport failed closed");
+                emitTelemetry();
+                observer.error(error);
+            }
+            const innerObserver = {
+                next(event) {
+                    switch (event.type) {
+                        case "snapshot":
+                        case "upsert":
+                        case "delete":
+                        case "delta": {
+                            armHeartbeat();
+                            if (!gate)
+                                return;
+                            void gate.enqueue(event).then((result) => {
+                                if (closed)
+                                    return;
+                                if (result.status === "applied" || result.status === "duplicate") {
+                                    reconnectAttempt = 0;
+                                }
+                                else if (result.status === "resnapshot-required") {
+                                    scheduleReconnect(result.reason ?? "resnapshot-required");
+                                }
+                                else if (result.status === "error") {
+                                    failClosed(new HonuaRealtimeResumeError(result.reason ?? "delivery-failed", gate?.state.detail ?? "Realtime delivery failed."));
+                                }
+                                emitTelemetry();
+                            });
+                            break;
+                        }
+                        case "heartbeat": {
+                            armHeartbeat();
+                            if (hasBeenStableSince())
+                                reconnectAttempt = 0;
+                            observer.next(event);
+                            emitTelemetry();
+                            break;
+                        }
+                        case "status": {
+                            if (event.status === "live")
+                                connectedAt = currentNow();
+                            armHeartbeat();
+                            observer.next(event);
+                            break;
+                        }
+                        case "error": {
+                            observer.next(event);
+                            if (event.terminal)
+                                failClosed(event.error);
+                            else
+                                handleTransportError(event.error);
+                            break;
+                        }
+                    }
+                },
+                error(error) {
+                    handleTransportError(error);
+                },
+                complete() {
+                    if (expectingTeardown)
+                        return;
+                    disposeGracefully("Realtime transport completed.");
+                },
+            };
+            void (async () => {
+                try {
+                    gate = await createResumableRealtimeSubscription({
+                        context: options.context,
+                        apply: (applied) => observer.next(applied),
+                        checkpointStore: options.checkpointStore,
+                        initialCheckpoint: options.initialCheckpoint,
+                        maxPendingEvents: options.maxPendingEvents,
+                        maxRecentEventIds: options.maxRecentEventIds,
+                        now: options.now,
+                        signal: lifecycle.signal,
+                    });
+                }
+                catch (cause) {
+                    if (!closed)
+                        failClosed(cause);
+                    return;
+                }
+                if (closed || lifecycle.signal.aborted)
+                    return;
+                await connect();
+            })();
+            return {
+                close() {
+                    disposeGracefully("Subscription closed by caller.");
+                },
+            };
+        },
+    };
+}
+/**
+ * Convenience factory combining {@link createRealtimeServerSentEventsTransport}
+ * with {@link createResumableRealtimeTransport}.
+ */
+export function createResumableServerSentEventsTransport(sseOptions, resumableOptions) {
+    return createResumableRealtimeTransport(createRealtimeServerSentEventsTransport(sseOptions), resumableOptions);
+}
+/**
+ * Convenience factory combining {@link createRealtimeWebSocketTransport}
+ * with {@link createResumableRealtimeTransport}.
+ */
+export function createResumableWebSocketTransport(webSocketOptions, resumableOptions) {
+    return createResumableRealtimeTransport(createRealtimeWebSocketTransport(webSocketOptions), resumableOptions);
+}
+function errorMessage(value) {
+    return value instanceof Error ? value.message : String(value);
+}

package/realtime/resumable.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Transport-neutral, resumable delivery gate for realtime feature events.
+ *
+ * This module deliberately does not reconnect a transport. It protects the
+ * boundary between a transport and a consumer: compatible checkpoints resume,
+ * ordered events advance durably, duplicates are bounded, and gaps or queue
+ * overflow require an explicit replacement snapshot.
+ *
+ * @module
+ */
+import type { SourceId } from "../contract/types.js";
+import { HonuaSdkError } from "../core/error-envelope.js";
+import type { RealtimeDeleteEvent, RealtimeDeltaEvent, RealtimeResumeCheckpoint, RealtimeSnapshotEvent, RealtimeUpsertEvent } from "./types.js";
+export declare const REALTIME_DURABLE_CHECKPOINT_VERSION: 1;
+export type RealtimeSequencedEvent<TFeature = unknown> = RealtimeSnapshotEvent<TFeature> | RealtimeUpsertEvent<TFeature> | RealtimeDeleteEvent | RealtimeDeltaEvent<TFeature>;
+export interface RealtimeResumeContextV1 {
+    readonly kind: "honua.realtime-resume-context";
+    readonly version: 1;
+    readonly sourceId: SourceId;
+    /** Stable, credential-free identity of the accepted query or plan. */
+    readonly queryFingerprint: string;
+    readonly sourceVersion: string;
+    readonly schemaVersion: string;
+    /** Stable opaque ACL/scope identity. Never pass a bearer token. */
+    readonly authorizationScopeFingerprint: string;
+}
+export interface RealtimeDurableCheckpointV1 {
+    readonly kind: "honua.realtime-checkpoint";
+    readonly version: typeof REALTIME_DURABLE_CHECKPOINT_VERSION;
+    readonly context: RealtimeResumeContextV1;
+    readonly resume: Readonly<RealtimeResumeCheckpoint> & {
+        readonly sequence: number;
+    };
+    readonly recentEventIds: readonly string[];
+    readonly savedAt: string;
+}
+export type RealtimeCheckpointCompatibilityCode = "compatible" | "invalid-checkpoint" | "source-changed" | "query-changed" | "source-version-changed" | "schema-version-changed" | "authorization-scope-changed";
+export interface RealtimeCheckpointCompatibility {
+    readonly compatible: boolean;
+    readonly code: RealtimeCheckpointCompatibilityCode;
+    readonly reason: string;
+}
+export type ResumableRealtimePhase = "awaiting-snapshot" | "resuming" | "live" | "resnapshot-required" | "error" | "closed";
+export type ResumableRealtimeReasonCode = RealtimeCheckpointCompatibilityCode | "snapshot-required" | "replacement-snapshot-required" | "invalid-event" | "sequence-missing" | "checkpoint-conflict" | "sequence-gap" | "event-id-reused" | "buffer-overflow" | "consumer-failed" | "delivery-failed" | "checkpoint-load-failed" | "checkpoint-save-failed" | "cursor-expired" | "resume-unsupported" | "transport-gap" | "cancelled" | "closed";
+export type RealtimeExternalResnapshotReason = "cursor-expired" | "resume-unsupported" | "transport-gap";
+export interface ResumableRealtimeState {
+    readonly phase: ResumableRealtimePhase;
+    readonly reason?: ResumableRealtimeReasonCode;
+    readonly detail?: string;
+    readonly checkpoint?: RealtimeDurableCheckpointV1;
+    readonly checkpointPersisted: boolean;
+    readonly pendingEvents: number;
+    readonly acceptedEventCount: number;
+    readonly duplicateEventCount: number;
+    readonly gapCount: number;
+    readonly overflowCount: number;
+}
+export type ResumableRealtimeDeliveryStatus = "applied" | "duplicate" | "resnapshot-required" | "error" | "cancelled";
+export interface ResumableRealtimeDelivery {
+    readonly status: ResumableRealtimeDeliveryStatus;
+    readonly reason?: ResumableRealtimeReasonCode;
+    readonly checkpoint?: RealtimeDurableCheckpointV1;
+}
+export interface RealtimeCheckpointStore {
+    load(context: RealtimeResumeContextV1, signal: AbortSignal): Promise<RealtimeDurableCheckpointV1 | undefined>;
+    save(checkpoint: RealtimeDurableCheckpointV1, signal: AbortSignal): Promise<void>;
+}
+export interface CreateResumableRealtimeSubscriptionOptions<TFeature = unknown> {
+    readonly context: RealtimeResumeContextV1;
+    readonly apply: (event: RealtimeSequencedEvent<TFeature>, signal: AbortSignal) => void | Promise<void>;
+    readonly checkpointStore?: RealtimeCheckpointStore;
+    /** Takes precedence over `checkpointStore.load` when supplied. */
+    readonly initialCheckpoint?: RealtimeDurableCheckpointV1;
+    /** Includes the currently applying event. @default 64 */
+    readonly maxPendingEvents?: number;
+    /** Bounded event-id history persisted with each checkpoint. @default 256 */
+    readonly maxRecentEventIds?: number;
+    readonly now?: () => number;
+    readonly signal?: AbortSignal;
+}
+export interface ResumableRealtimeSubscription<TFeature = unknown> {
+    readonly state: ResumableRealtimeState;
+    enqueue(event: RealtimeSequencedEvent<TFeature>): Promise<ResumableRealtimeDelivery>;
+    /** Project an adapter/server resume failure into an explicit snapshot transition. */
+    requireResnapshot(reason: RealtimeExternalResnapshotReason, detail?: string): void;
+    close(reason?: string): void;
+}
+/**
+ * Public realtime failure with the original detailed reason on `.code` and a
+ * stable common-envelope recovery class on `.sdkCode`. Classification metadata
+ * does not reconnect a transport or request a replacement snapshot.
+ */
+export declare class HonuaRealtimeResumeError extends HonuaSdkError {
+    readonly code: ResumableRealtimeReasonCode;
+    constructor(code: ResumableRealtimeReasonCode, message: string, options?: ErrorOptions);
+}
+/** Validate a checkpoint against the exact source/query/schema/ACL context. */
+export declare function evaluateRealtimeCheckpoint(context: RealtimeResumeContextV1, checkpoint: RealtimeDurableCheckpointV1): RealtimeCheckpointCompatibility;
+/**
+ * Create a serial, bounded delivery gate. Loading a durable checkpoint is the
+ * only asynchronous construction step; no transport is opened here.
+ */
+export declare function createResumableRealtimeSubscription<TFeature = unknown>(options: CreateResumableRealtimeSubscriptionOptions<TFeature>): Promise<ResumableRealtimeSubscription<TFeature>>;
+//# sourceMappingURL=resumable.d.ts.map

package/realtime/resumable.d.ts.map

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