@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.0

package/dist/esm/core/requests/network-backoff.frontend.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-backoff.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/requests/network-backoff.frontend.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,8DAA8D;AAC9D,MAAM,8BAA8B,GAAG,IAAI,CAAC;AAC5C,kEAAkE;AAClE,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAClC,kEAAkE;AAClE,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAAe,EAAE,WAAmB,EAAE,KAAa;IACrF,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACzC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IACvE,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAgB,8BAA8B;IAC7E,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAgB,sBAAsB,EACtC,QAAgB,sBAAsB;IAEtC,OAAO,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;AACxE,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,KAAK,CAAC,EAAU;IAC9B,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AACzD,CAAC","sourcesContent":["/**\n * Shared jittered-backoff + staggered-release helpers for the frontend network\n * layer.\n *\n * These centralise the anti-thundering-herd (\"auto-DDOS\") math so every recovery\n * path de-synchronises the same way: the HTTP retry backoff, the offline-queue\n * drain, the API-readiness gate, and the WebSocket readiness poll all import from\n * here. The problem they solve: when a backend outage ends, EVERY stuck client\n * would otherwise fire its backlog — plus its WS reconnect — in the same instant,\n * re-overloading the server the moment it comes back.\n *\n * What jitter fixes is SYNCHRONISATION, not per-client volume. Full jitter has a\n * mean of ~window/2 vs. a deterministic window, so an individual client actually\n * polls/retries somewhat MORE often on average — but the retries of N clients are\n * de-correlated, so the server sees a smooth spread instead of a synchronised\n * spike every backoff step. The spike is what melts a recovering backend, so this\n * is the right trade (the probed endpoints — /health/ready — are cheap). If\n * per-client probe rate ever becomes the concern, switch to \"equal jitter\"\n * (half-fixed + half-random) to lift the mean back toward ~3·window/4.\n *\n * Design rationale (why not a token bucket): the HTTP client already caps\n * in-flight requests via `maxConcurrentRequests`, so bounding the RATE is already\n * handled. All that's missing is de-correlating WHEN each request/client fires,\n * which random jitter achieves with zero additional state. See\n * `.claude/plans/network-resilience-organization.md` (decision D3).\n */\n\n/** Default ceiling on the per-client recovery offset (ms). */\nconst DEFAULT_RECOVERY_OFFSET_MAX_MS = 2000;\n/** Default lower bound for the inter-release stagger gap (ms). */\nconst DEFAULT_STAGGER_MIN_MS = 25;\n/** Default upper bound for the inter-release stagger gap (ms). */\nconst DEFAULT_STAGGER_MAX_MS = 250;\n\n/**\n * AWS \"full jitter\" exponential backoff: a uniformly random delay in\n * `[0, min(capMs, baseDelayMs · 2^attempt)]`.\n *\n * Full jitter (as opposed to raw exponential, or \"equal jitter\") gives the best\n * cross-client de-synchronisation — two clients that failed on the same round\n * pick independent delays, so their retries spread out instead of colliding again\n * on every subsequent round. The randomness is the whole point; do not replace it\n * with a deterministic curve.\n *\n * @param attempt      Zero-based attempt index (0 = first retry).\n * @param baseDelayMs  Base unit of backoff before doubling.\n * @param capMs        Hard ceiling on the pre-jitter window.\n * @returns            A jittered delay in milliseconds.\n */\nexport function fullJitterBackoffMs(attempt: number, baseDelayMs: number, capMs: number): number {\n  const safeAttempt = Math.max(0, attempt);\n  const window = Math.min(capMs, baseDelayMs * Math.pow(2, safeAttempt));\n  return Math.floor(Math.random() * Math.max(0, window));\n}\n\n/**\n * A fresh per-recovery offset in `[0, maxMs]`, rolled on each call.\n *\n * Applied ONCE per recovery event (the first offline→online drain, or the moment\n * the readiness gate flips healthy after an outage). Because each client rolls an\n * independent value, N clients that were all blocked on the same outage release\n * at N different instants instead of stampeding together. Rolled fresh per\n * recovery (not cached for the tab's lifetime) so a client that draws a large\n * offset on one outage isn't perpetually last on every future one.\n *\n * @param maxMs  Upper bound on the offset (defaults to 2000ms).\n */\nexport function recoveryOffsetMs(maxMs: number = DEFAULT_RECOVERY_OFFSET_MAX_MS): number {\n  return Math.floor(Math.random() * Math.max(0, maxMs));\n}\n\n/**\n * A small randomised gap between successive releases when draining a backlog\n * (offline queue, readiness-gate waiters). Spreads a burst over time WITHIN a\n * single client. Combined with {@link recoveryOffsetMs} (which de-syncs clients\n * from each other), this de-syncs a single client's own queued requests.\n *\n * @param minMs  Lower bound of the gap (defaults to 25ms).\n * @param maxMs  Upper bound of the gap (defaults to 250ms).\n */\nexport function staggerGapMs(\n  minMs: number = DEFAULT_STAGGER_MIN_MS,\n  maxMs: number = DEFAULT_STAGGER_MAX_MS,\n): number {\n  return minMs + Math.floor(Math.random() * Math.max(0, maxMs - minMs));\n}\n\n/** Promise-based sleep used by the staggered-release helpers. */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n"]}

package/dist/esm/core/requests/offline-replay-policy.frontend.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Offline replay policy — decides what the HTTP client does with a request that
+ * is issued while the browser reports no connectivity.
+ *
+ * The offline queue is a genuine convenience for READS: a GET that fires during a
+ * mobile tunnel blip can safely be held and replayed a moment later — the caller
+ * gets fresh data and nothing was mutated twice. MUTATIONS are the opposite: the
+ * queue has no de-duplication and entries never expire, so a POST/PUT/PATCH/DELETE
+ * enqueued at 9am could silently replay hours later against stale state, or double-
+ * submit if the user retried in the meantime. For a mutation the honest behaviour
+ * is to fail fast with a clear "you're offline" signal and let the user (or the
+ * caller) decide to retry.
+ *
+ * v1 (locked 2026-07-07): reads REPLAY (with a TTL enforced by the client),
+ * mutations REJECT. No idempotency-key replay path yet — see
+ * `.claude/plans/network-resilience-organization.md` (decision D4).
+ */
+export declare enum OfflineReplayPolicy {
+    /** Hold the request in the offline queue and replay it when connectivity returns (subject to the queue TTL). */
+    REPLAY = "REPLAY",
+    /** Reject the request immediately with a {@link NetworkOfflineError}; do not queue. */
+    REJECT_WHEN_OFFLINE = "REJECT_WHEN_OFFLINE"
+}
+/**
+ * Default policy for a request when the caller did not specify one explicitly:
+ * safe/idempotent reads replay, everything else rejects.
+ *
+ * @param method  HTTP verb (case-insensitive); undefined is treated as GET,
+ *                matching axios's own default method.
+ */
+export declare function defaultOfflineReplayPolicyForMethod(method: string | undefined): OfflineReplayPolicy;
+/** Distinguishes the two offline-failure shapes so callers/telemetry can tell them apart. */
+export declare enum NetworkOfflineReason {
+    /** A mutation was rejected because the client was offline (never sent). */
+    MUTATION_REJECTED = "MUTATION_REJECTED",
+    /** A queued read outlived the queue TTL before connectivity returned. */
+    QUEUE_ENTRY_EXPIRED = "QUEUE_ENTRY_EXPIRED"
+}
+/**
+ * Error raised when a request cannot proceed due to lack of connectivity. It is
+ * deliberately NOT a transport error and NOT a cancellation: the HTTP client's
+ * response-error interceptor recognises it via {@link isNetworkOfflineRejection}
+ * and short-circuits — it is never retried, never re-classified as a generic
+ * NETWORK fault, and never routed through the global error toast. UX for the
+ * offline state is owned by the connectivity layer (a single banner), not by
+ * per-request toasts.
+ */
+export declare class NetworkOfflineError extends Error {
+    /** Marker property used by {@link isNetworkOfflineRejection} (survives structured-clone / prototype loss). */
+    readonly __wildoNetworkOffline = true;
+    readonly reason: NetworkOfflineReason;
+    readonly url?: string;
+    /**
+     * The originating axios request config, attached at the throw site so the HTTP
+     * client's response-error interceptor can emit the balancing LOADING_*_END
+     * event (LOADING_*_START was already emitted before the request was rejected /
+     * queued). Typed `unknown` to keep this policy module free of an axios import.
+     */
+    config?: unknown;
+    constructor(reason: NetworkOfflineReason, url?: string);
+}
+/**
+ * Predicate mirroring `isAbortOrCancelError`: recognises a {@link NetworkOfflineError}
+ * by its marker property so the check survives even if the prototype is lost (e.g.
+ * across an event-bus round-trip). Used at the single response-interceptor boundary
+ * that suppresses offline rejections from retry/classification.
+ */
+export declare function isNetworkOfflineRejection(error: unknown): error is NetworkOfflineError;
+//# sourceMappingURL=offline-replay-policy.frontend.d.ts.map

package/dist/esm/core/requests/offline-replay-policy.frontend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-replay-policy.frontend.d.ts","sourceRoot":"","sources":["../../../../../src/core/requests/offline-replay-policy.frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,oBAAY,mBAAmB;IAC7B,gHAAgH;IAChH,MAAM,WAAW;IACjB,uFAAuF;IACvF,mBAAmB,wBAAwB;CAC5C;AASD;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,CAKnG;AAED,6FAA6F;AAC7F,oBAAY,oBAAoB;IAC9B,2EAA2E;IAC3E,iBAAiB,sBAAsB;IACvC,yEAAyE;IACzE,mBAAmB,wBAAwB;CAC5C;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,8GAA8G;IAC9G,SAAgB,qBAAqB,QAAQ;IAC7C,SAAgB,MAAM,EAAE,oBAAoB,CAAC;IAC7C,SAAgB,GAAG,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACI,MAAM,CAAC,EAAE,OAAO,CAAC;gBAEZ,MAAM,EAAE,oBAAoB,EAAE,GAAG,CAAC,EAAE,MAAM;CAYvD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAMtF"}

package/dist/esm/core/requests/offline-replay-policy.frontend.js

@@ -0,0 +1,95 @@
+/**
+ * Offline replay policy — decides what the HTTP client does with a request that
+ * is issued while the browser reports no connectivity.
+ *
+ * The offline queue is a genuine convenience for READS: a GET that fires during a
+ * mobile tunnel blip can safely be held and replayed a moment later — the caller
+ * gets fresh data and nothing was mutated twice. MUTATIONS are the opposite: the
+ * queue has no de-duplication and entries never expire, so a POST/PUT/PATCH/DELETE
+ * enqueued at 9am could silently replay hours later against stale state, or double-
+ * submit if the user retried in the meantime. For a mutation the honest behaviour
+ * is to fail fast with a clear "you're offline" signal and let the user (or the
+ * caller) decide to retry.
+ *
+ * v1 (locked 2026-07-07): reads REPLAY (with a TTL enforced by the client),
+ * mutations REJECT. No idempotency-key replay path yet — see
+ * `.claude/plans/network-resilience-organization.md` (decision D4).
+ */
+export var OfflineReplayPolicy;
+(function (OfflineReplayPolicy) {
+    /** Hold the request in the offline queue and replay it when connectivity returns (subject to the queue TTL). */
+    OfflineReplayPolicy["REPLAY"] = "REPLAY";
+    /** Reject the request immediately with a {@link NetworkOfflineError}; do not queue. */
+    OfflineReplayPolicy["REJECT_WHEN_OFFLINE"] = "REJECT_WHEN_OFFLINE";
+})(OfflineReplayPolicy || (OfflineReplayPolicy = {}));
+/**
+ * HTTP methods that are safe to replay after an offline blip. Anything not in
+ * this set is treated as a mutation and rejected when offline (unless the caller
+ * overrides via `RequestOptions.offlineReplayPolicy`).
+ */
+const REPLAY_SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+/**
+ * Default policy for a request when the caller did not specify one explicitly:
+ * safe/idempotent reads replay, everything else rejects.
+ *
+ * @param method  HTTP verb (case-insensitive); undefined is treated as GET,
+ *                matching axios's own default method.
+ */
+export function defaultOfflineReplayPolicyForMethod(method) {
+    const normalized = (method ?? 'GET').toUpperCase();
+    return REPLAY_SAFE_METHODS.has(normalized)
+        ? OfflineReplayPolicy.REPLAY
+        : OfflineReplayPolicy.REJECT_WHEN_OFFLINE;
+}
+/** Distinguishes the two offline-failure shapes so callers/telemetry can tell them apart. */
+export var NetworkOfflineReason;
+(function (NetworkOfflineReason) {
+    /** A mutation was rejected because the client was offline (never sent). */
+    NetworkOfflineReason["MUTATION_REJECTED"] = "MUTATION_REJECTED";
+    /** A queued read outlived the queue TTL before connectivity returned. */
+    NetworkOfflineReason["QUEUE_ENTRY_EXPIRED"] = "QUEUE_ENTRY_EXPIRED";
+})(NetworkOfflineReason || (NetworkOfflineReason = {}));
+/**
+ * Error raised when a request cannot proceed due to lack of connectivity. It is
+ * deliberately NOT a transport error and NOT a cancellation: the HTTP client's
+ * response-error interceptor recognises it via {@link isNetworkOfflineRejection}
+ * and short-circuits — it is never retried, never re-classified as a generic
+ * NETWORK fault, and never routed through the global error toast. UX for the
+ * offline state is owned by the connectivity layer (a single banner), not by
+ * per-request toasts.
+ */
+export class NetworkOfflineError extends Error {
+    /** Marker property used by {@link isNetworkOfflineRejection} (survives structured-clone / prototype loss). */
+    __wildoNetworkOffline = true;
+    reason;
+    url;
+    /**
+     * The originating axios request config, attached at the throw site so the HTTP
+     * client's response-error interceptor can emit the balancing LOADING_*_END
+     * event (LOADING_*_START was already emitted before the request was rejected /
+     * queued). Typed `unknown` to keep this policy module free of an axios import.
+     */
+    config;
+    constructor(reason, url) {
+        super(reason === NetworkOfflineReason.MUTATION_REJECTED
+            ? 'Request could not be sent because the device is offline'
+            : 'Queued request expired before connectivity was restored');
+        this.name = 'NetworkOfflineError';
+        this.reason = reason;
+        this.url = url;
+        // Restore the prototype chain for `instanceof` after transpilation to ES5-ish targets.
+        Object.setPrototypeOf(this, NetworkOfflineError.prototype);
+    }
+}
+/**
+ * Predicate mirroring `isAbortOrCancelError`: recognises a {@link NetworkOfflineError}
+ * by its marker property so the check survives even if the prototype is lost (e.g.
+ * across an event-bus round-trip). Used at the single response-interceptor boundary
+ * that suppresses offline rejections from retry/classification.
+ */
+export function isNetworkOfflineRejection(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        error.__wildoNetworkOffline === true);
+}
+//# sourceMappingURL=offline-replay-policy.frontend.js.map

package/dist/esm/core/requests/offline-replay-policy.frontend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-replay-policy.frontend.js","sourceRoot":"","sources":["../../../../../src/core/requests/offline-replay-policy.frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAN,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,gHAAgH;IAChH,wCAAiB,CAAA;IACjB,uFAAuF;IACvF,kEAA2C,CAAA;AAC7C,CAAC,EALW,mBAAmB,KAAnB,mBAAmB,QAK9B;AAED;;;;GAIG;AACH,MAAM,mBAAmB,GAAwB,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAErF;;;;;;GAMG;AACH,MAAM,UAAU,mCAAmC,CAAC,MAA0B;IAC5E,MAAM,UAAU,GAAG,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IACnD,OAAO,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC;QACxC,CAAC,CAAC,mBAAmB,CAAC,MAAM;QAC5B,CAAC,CAAC,mBAAmB,CAAC,mBAAmB,CAAC;AAC9C,CAAC;AAED,6FAA6F;AAC7F,MAAM,CAAN,IAAY,oBAKX;AALD,WAAY,oBAAoB;IAC9B,2EAA2E;IAC3E,+DAAuC,CAAA;IACvC,yEAAyE;IACzE,mEAA2C,CAAA;AAC7C,CAAC,EALW,oBAAoB,KAApB,oBAAoB,QAK/B;AAED;;;;;;;;GAQG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC5C,8GAA8G;IAC9F,qBAAqB,GAAG,IAAI,CAAC;IAC7B,MAAM,CAAuB;IAC7B,GAAG,CAAU;IAC7B;;;;;OAKG;IACI,MAAM,CAAW;IAExB,YAAY,MAA4B,EAAE,GAAY;QACpD,KAAK,CACH,MAAM,KAAK,oBAAoB,CAAC,iBAAiB;YAC/C,CAAC,CAAC,yDAAyD;YAC3D,CAAC,CAAC,yDAAyD,CAC9D,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,uFAAuF;QACvF,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC7D,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAc;IACtD,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACb,KAA6C,CAAC,qBAAqB,KAAK,IAAI,CAC9E,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Offline replay policy — decides what the HTTP client does with a request that\n * is issued while the browser reports no connectivity.\n *\n * The offline queue is a genuine convenience for READS: a GET that fires during a\n * mobile tunnel blip can safely be held and replayed a moment later — the caller\n * gets fresh data and nothing was mutated twice. MUTATIONS are the opposite: the\n * queue has no de-duplication and entries never expire, so a POST/PUT/PATCH/DELETE\n * enqueued at 9am could silently replay hours later against stale state, or double-\n * submit if the user retried in the meantime. For a mutation the honest behaviour\n * is to fail fast with a clear \"you're offline\" signal and let the user (or the\n * caller) decide to retry.\n *\n * v1 (locked 2026-07-07): reads REPLAY (with a TTL enforced by the client),\n * mutations REJECT. No idempotency-key replay path yet — see\n * `.claude/plans/network-resilience-organization.md` (decision D4).\n */\nexport enum OfflineReplayPolicy {\n  /** Hold the request in the offline queue and replay it when connectivity returns (subject to the queue TTL). */\n  REPLAY = 'REPLAY',\n  /** Reject the request immediately with a {@link NetworkOfflineError}; do not queue. */\n  REJECT_WHEN_OFFLINE = 'REJECT_WHEN_OFFLINE',\n}\n\n/**\n * HTTP methods that are safe to replay after an offline blip. Anything not in\n * this set is treated as a mutation and rejected when offline (unless the caller\n * overrides via `RequestOptions.offlineReplayPolicy`).\n */\nconst REPLAY_SAFE_METHODS: ReadonlySet<string> = new Set(['GET', 'HEAD', 'OPTIONS']);\n\n/**\n * Default policy for a request when the caller did not specify one explicitly:\n * safe/idempotent reads replay, everything else rejects.\n *\n * @param method  HTTP verb (case-insensitive); undefined is treated as GET,\n *                matching axios's own default method.\n */\nexport function defaultOfflineReplayPolicyForMethod(method: string | undefined): OfflineReplayPolicy {\n  const normalized = (method ?? 'GET').toUpperCase();\n  return REPLAY_SAFE_METHODS.has(normalized)\n    ? OfflineReplayPolicy.REPLAY\n    : OfflineReplayPolicy.REJECT_WHEN_OFFLINE;\n}\n\n/** Distinguishes the two offline-failure shapes so callers/telemetry can tell them apart. */\nexport enum NetworkOfflineReason {\n  /** A mutation was rejected because the client was offline (never sent). */\n  MUTATION_REJECTED = 'MUTATION_REJECTED',\n  /** A queued read outlived the queue TTL before connectivity returned. */\n  QUEUE_ENTRY_EXPIRED = 'QUEUE_ENTRY_EXPIRED',\n}\n\n/**\n * Error raised when a request cannot proceed due to lack of connectivity. It is\n * deliberately NOT a transport error and NOT a cancellation: the HTTP client's\n * response-error interceptor recognises it via {@link isNetworkOfflineRejection}\n * and short-circuits — it is never retried, never re-classified as a generic\n * NETWORK fault, and never routed through the global error toast. UX for the\n * offline state is owned by the connectivity layer (a single banner), not by\n * per-request toasts.\n */\nexport class NetworkOfflineError extends Error {\n  /** Marker property used by {@link isNetworkOfflineRejection} (survives structured-clone / prototype loss). */\n  public readonly __wildoNetworkOffline = true;\n  public readonly reason: NetworkOfflineReason;\n  public readonly url?: string;\n  /**\n   * The originating axios request config, attached at the throw site so the HTTP\n   * client's response-error interceptor can emit the balancing LOADING_*_END\n   * event (LOADING_*_START was already emitted before the request was rejected /\n   * queued). Typed `unknown` to keep this policy module free of an axios import.\n   */\n  public config?: unknown;\n\n  constructor(reason: NetworkOfflineReason, url?: string) {\n    super(\n      reason === NetworkOfflineReason.MUTATION_REJECTED\n        ? 'Request could not be sent because the device is offline'\n        : 'Queued request expired before connectivity was restored',\n    );\n    this.name = 'NetworkOfflineError';\n    this.reason = reason;\n    this.url = url;\n    // Restore the prototype chain for `instanceof` after transpilation to ES5-ish targets.\n    Object.setPrototypeOf(this, NetworkOfflineError.prototype);\n  }\n}\n\n/**\n * Predicate mirroring `isAbortOrCancelError`: recognises a {@link NetworkOfflineError}\n * by its marker property so the check survives even if the prototype is lost (e.g.\n * across an event-bus round-trip). Used at the single response-interceptor boundary\n * that suppresses offline rejections from retry/classification.\n */\nexport function isNetworkOfflineRejection(error: unknown): error is NetworkOfflineError {\n  return (\n    typeof error === 'object' &&\n    error !== null &&\n    (error as { __wildoNetworkOffline?: unknown }).__wildoNetworkOffline === true\n  );\n}\n"]}

package/dist/esm/core/requests/request-cancellation.frontend.utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Request-cancellation detection — single source of truth.
+ *
+ * An intentionally aborted request (a superseded refetch, a component unmount,
+ * React StrictMode's mount→unmount→mount, an RMM mutation supersede, a
+ * backpressure hard-timeout) is NOT a transport failure and must never be
+ * classified, toasted, retried, or surfaced as an error.
+ *
+ * The complication is that the cancel signature depends on the transport:
+ * - **axios** (the `WildoBackendHttpClient` transport) rejects a cancelled
+ *   request with a `CanceledError`: `__CANCEL__ === true`, `code ===
+ *   'ERR_CANCELED'`, `name === 'CanceledError'`. It is NOT a DOM `AbortError`.
+ * - the **fetch** API / raw `AbortController` rejects with a `DOMException`
+ *   whose `name === 'AbortError'`.
+ *
+ * Consumers historically each reimplemented a partial check (some only matched
+ * `AbortError`, missing every axios cancel; some only matched `ERR_CANCELED`).
+ * This predicate recognises every shape so the framework treats a cancel
+ * identically everywhere — at the HTTP-client interceptor boundary, in the RMM
+ * transport adapter's error mapping, and in per-consumer catch guards.
+ */
+export declare function isAbortOrCancelError(error: unknown): boolean;
+//# sourceMappingURL=request-cancellation.frontend.utils.d.ts.map

package/dist/esm/core/requests/request-cancellation.frontend.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-cancellation.frontend.utils.d.ts","sourceRoot":"","sources":["../../../../../src/core/requests/request-cancellation.frontend.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAY5D"}

package/dist/esm/core/requests/request-cancellation.frontend.utils.js

@@ -0,0 +1,35 @@
+/**
+ * Request-cancellation detection — single source of truth.
+ *
+ * An intentionally aborted request (a superseded refetch, a component unmount,
+ * React StrictMode's mount→unmount→mount, an RMM mutation supersede, a
+ * backpressure hard-timeout) is NOT a transport failure and must never be
+ * classified, toasted, retried, or surfaced as an error.
+ *
+ * The complication is that the cancel signature depends on the transport:
+ * - **axios** (the `WildoBackendHttpClient` transport) rejects a cancelled
+ *   request with a `CanceledError`: `__CANCEL__ === true`, `code ===
+ *   'ERR_CANCELED'`, `name === 'CanceledError'`. It is NOT a DOM `AbortError`.
+ * - the **fetch** API / raw `AbortController` rejects with a `DOMException`
+ *   whose `name === 'AbortError'`.
+ *
+ * Consumers historically each reimplemented a partial check (some only matched
+ * `AbortError`, missing every axios cancel; some only matched `ERR_CANCELED`).
+ * This predicate recognises every shape so the framework treats a cancel
+ * identically everywhere — at the HTTP-client interceptor boundary, in the RMM
+ * transport adapter's error mapping, and in per-consumer catch guards.
+ */
+export function isAbortOrCancelError(error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+        return true;
+    }
+    if (error && typeof error === 'object') {
+        const candidate = error;
+        return candidate.__CANCEL__ === true
+            || candidate.code === 'ERR_CANCELED'
+            || candidate.name === 'CanceledError'
+            || candidate.name === 'AbortError';
+    }
+    return false;
+}
+//# sourceMappingURL=request-cancellation.frontend.utils.js.map

package/dist/esm/core/requests/request-cancellation.frontend.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-cancellation.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/requests/request-cancellation.frontend.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,IAAI,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QACjE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvC,MAAM,SAAS,GAAG,KAAiE,CAAC;QACpF,OAAO,SAAS,CAAC,UAAU,KAAK,IAAI;eAC/B,SAAS,CAAC,IAAI,KAAK,cAAc;eACjC,SAAS,CAAC,IAAI,KAAK,eAAe;eAClC,SAAS,CAAC,IAAI,KAAK,YAAY,CAAC;IACvC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/**\n * Request-cancellation detection — single source of truth.\n *\n * An intentionally aborted request (a superseded refetch, a component unmount,\n * React StrictMode's mount→unmount→mount, an RMM mutation supersede, a\n * backpressure hard-timeout) is NOT a transport failure and must never be\n * classified, toasted, retried, or surfaced as an error.\n *\n * The complication is that the cancel signature depends on the transport:\n * - **axios** (the `WildoBackendHttpClient` transport) rejects a cancelled\n *   request with a `CanceledError`: `__CANCEL__ === true`, `code ===\n *   'ERR_CANCELED'`, `name === 'CanceledError'`. It is NOT a DOM `AbortError`.\n * - the **fetch** API / raw `AbortController` rejects with a `DOMException`\n *   whose `name === 'AbortError'`.\n *\n * Consumers historically each reimplemented a partial check (some only matched\n * `AbortError`, missing every axios cancel; some only matched `ERR_CANCELED`).\n * This predicate recognises every shape so the framework treats a cancel\n * identically everywhere — at the HTTP-client interceptor boundary, in the RMM\n * transport adapter's error mapping, and in per-consumer catch guards.\n */\nexport function isAbortOrCancelError(error: unknown): boolean {\n  if (error instanceof DOMException && error.name === 'AbortError') {\n    return true;\n  }\n  if (error && typeof error === 'object') {\n    const candidate = error as { code?: unknown; name?: unknown; __CANCEL__?: unknown };\n    return candidate.__CANCEL__ === true\n      || candidate.code === 'ERR_CANCELED'\n      || candidate.name === 'CanceledError'\n      || candidate.name === 'AbortError';\n  }\n  return false;\n}\n"]}

package/dist/esm/core/requests/websockets/ConnectionStatusNotifier.d.ts

@@ -0,0 +1,2 @@
+export declare const ConnectionStatusNotifier: () => null;
+//# sourceMappingURL=ConnectionStatusNotifier.d.ts.map

package/dist/esm/core/requests/websockets/ConnectionStatusNotifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionStatusNotifier.d.ts","sourceRoot":"","sources":["../../../../../../src/core/requests/websockets/ConnectionStatusNotifier.tsx"],"names":[],"mappings":"AAiEA,eAAO,MAAM,wBAAwB,QAAO,IAuH3C,CAAC"}

package/dist/esm/core/requests/websockets/ConnectionStatusNotifier.js

@@ -0,0 +1,169 @@
+import { useEffect, useRef } from 'react';
+import { FrontendComponentType } from '@wildo-ai/presets-components-models';
+import { useWebSocket } from './useWebSocket.js';
+import { WebSocketStatus } from './WebSocketContext.js';
+import { useNotification } from '../../../core/events/useNotification.js';
+import { useI18n } from '../../../core/i18n/useI18n.js';
+/**
+ * Debounced, single-source connectivity notifier.
+ *
+ * Headless bridge (renders nothing) that turns the WebSocket connection state
+ * machine into AT MOST ONE user-facing notification per outage:
+ *
+ * - **Transient blip (< grace):** nothing. The status bar already reflects
+ *   DISCONNECTED/RECONNECTING; a mobile tunnel or a quick backend restart that
+ *   recovers within the grace window shows no toast at all.
+ * - **Sustained outage (>= grace):** ONE persistent, self-dismissing toast —
+ *   "reconnecting…" while `RECONNECTING`, escalating in place to "connection
+ *   lost" if reconnection gives up (`ERROR`). It is pinned by a stable id, so it
+ *   updates rather than stacks, and auto-dismisses the instant we reconnect.
+ *
+ * This replaces the old per-attempt `errorManagement.handleError` toasts in
+ * WebSocketContext (one Sonner toast per reconnection attempt). The transport
+ * context now only drives status + one-per-outage observability logging; ALL
+ * connection UX lives here, so there is a single place that owns the policy.
+ *
+ * Mounted once near the app-level `<Toaster/>` (see ApplicationMainContext).
+ */
+/** Stable id so repeated updates replace the same toast instead of stacking. */
+const CONNECTIVITY_TOAST_ID = 'wildo:connectivity-status';
+/**
+ * Grace before surfacing anything — a blip shorter than this stays silent
+ * (matches the locked 3s connectivity grace period).
+ */
+const CONNECTION_NOTICE_GRACE_MS = 3000;
+/**
+ * Hardcoded English fallbacks for when the label BUNDLE is loaded (`isReady`)
+ * but lacks these specific keys — e.g. an app whose generated label bundle
+ * predates the keys. `tComponent` then returns the raw key PATH
+ * (`components.<component>.<key>`) verbatim, and without this guard that raw
+ * path shipped straight into the toast. Mirrors the miss-check
+ * `NotificationContext.resolveMessage` applies to its own component-label
+ * lookups (`startsWith('components.')`). The stale bundle itself is repaired by
+ * regenerating labels; this is the engine-side class fix so a label gap can
+ * never render as `components.application-level-status-bar.connectionLostNotice`.
+ */
+const CONNECTION_NOTICE_FALLBACK_MESSAGES = {
+    connectionReconnectingNotice: 'Connection lost — reconnecting…',
+    connectionLostNotice: 'Connection lost. Please check your network and reload the page.',
+};
+/**
+ * Only an ACTIVELY-RETRYING (`RECONNECTING`) or a GAVE-UP (`ERROR`) socket is a
+ * surfaceable outage. Plain `DISCONNECTED`/`CONNECTING` is NOT: the socket only
+ * emits reconnection events after `connect()` (which the app calls after auth),
+ * so a logged-out user — or the pre-auth window, or an intentional
+ * disconnect/logout — sits at `DISCONNECTED` and must never raise a
+ * "reconnecting" notice. This is the guard that keeps the notice from firing for
+ * every unauthenticated visitor.
+ */
+const isOutageStatus = (status) => status === WebSocketStatus.RECONNECTING || status === WebSocketStatus.ERROR;
+export const ConnectionStatusNotifier = () => {
+    const { status } = useWebSocket();
+    const { showPersistentToast, dismissPersistentToast } = useNotification();
+    // Pass the component so its label bundle is requested — without this,
+    // `tComponent` returns the raw key path if the outage happens before any other
+    // consumer (the status bar) has loaded these keys. `isReady` gates surfacing.
+    const { tComponent, isReady } = useI18n({ component: FrontendComponentType.APPLICATION_LEVEL_STATUS_BAR });
+    // Ref the imperative callbacks (t-function, toast show/dismiss) so the effects
+    // do NOT depend on their identities. This is deliberate: the notice is a
+    // fire-and-forget side effect keyed on connection STATUS, not on those
+    // functions, and it makes the component robust regardless of whether
+    // NotificationContext / I18n keep them referentially stable — a future change
+    // that made them non-stable would otherwise re-fire the mount/teardown effects
+    // on every render and dismiss a live notice. Refs sidestep that entirely.
+    const tComponentRef = useRef(tComponent);
+    tComponentRef.current = tComponent;
+    const showPersistentToastRef = useRef(showPersistentToast);
+    showPersistentToastRef.current = showPersistentToast;
+    const dismissPersistentToastRef = useRef(dismissPersistentToast);
+    dismissPersistentToastRef.current = dismissPersistentToast;
+    // Latest status, read inside the debounce timer so a state change during the
+    // grace window surfaces the CURRENT state, not the one captured at schedule.
+    const statusRef = useRef(status);
+    statusRef.current = status;
+    const graceTimerRef = useRef(null);
+    const noticeShownRef = useRef(false);
+    // On (re)mount, reconcile any orphaned pinned toast from a PRIOR mount. Sonner's
+    // toast store is a module-level singleton that outlives this component, so after
+    // a bootstrap remount the old notice can survive while `noticeShownRef` resets
+    // to false — leaving a toast this instance would never dismiss.
+    //
+    // BUT only reconcile when mounting into a NON-outage state. If we remount while
+    // an outage is active, dismissing here would blink the live notice out for a
+    // full grace window before the main effect re-arms and re-shows it. Instead we
+    // KEEP any existing pinned toast: the main effect (below) arms its timer and
+    // refreshes the same stable id in place after grace, so the notice never
+    // disappears. Empty deps + ref access = genuinely mount-only.
+    useEffect(() => {
+        if (!isOutageStatus(statusRef.current)) {
+            dismissPersistentToastRef.current(CONNECTIVITY_TOAST_ID);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- mount-only by design; callbacks read via ref
+    }, []);
+    useEffect(() => {
+        const clearGraceTimer = () => {
+            if (graceTimerRef.current) {
+                clearTimeout(graceTimerRef.current);
+                graceTimerRef.current = null;
+            }
+        };
+        const surfaceNotice = () => {
+            const current = statusRef.current;
+            const isTerminal = current === WebSocketStatus.ERROR;
+            const labelKey = isTerminal ? 'connectionLostNotice' : 'connectionReconnectingNotice';
+            const translated = tComponentRef.current(FrontendComponentType.APPLICATION_LEVEL_STATUS_BAR, labelKey);
+            // An unresolved key comes back as its raw `components.…` key path — never
+            // show that to a user; fall back to hardcoded English (see the constant).
+            const message = translated.startsWith('components.') ? CONNECTION_NOTICE_FALLBACK_MESSAGES[labelKey] : translated;
+            showPersistentToastRef.current(CONNECTIVITY_TOAST_ID, isTerminal ? 'error' : 'loading', message);
+            noticeShownRef.current = true;
+        };
+        // Not a surfaceable outage (CONNECTED, CONNECTING, or DISCONNECTED): clear any
+        // pending timer and dismiss a shown notice. This covers reconnect SUCCESS
+        // (→ CONNECTED) AND intentional disconnect/logout (→ DISCONNECTED) — both must
+        // take down the notice.
+        if (!isOutageStatus(status)) {
+            clearGraceTimer();
+            if (noticeShownRef.current) {
+                dismissPersistentToastRef.current(CONNECTIVITY_TOAST_ID);
+                noticeShownRef.current = false;
+            }
+            return;
+        }
+        // Outage, but the localized message isn't available yet — wait for the bundle.
+        // This effect re-runs when `isReady` flips (it's in the deps).
+        if (!isReady) {
+            return;
+        }
+        if (noticeShownRef.current) {
+            // Already surfaced — update the message in place (e.g. reconnecting → lost).
+            surfaceNotice();
+            return;
+        }
+        // First outage state — start the grace timer once. Subsequent status changes
+        // within the window don't reset it (the timer reads the latest status when it
+        // fires), so a flapping reconnect still surfaces after one grace span.
+        if (!graceTimerRef.current) {
+            graceTimerRef.current = setTimeout(() => {
+                graceTimerRef.current = null;
+                surfaceNotice();
+            }, CONNECTION_NOTICE_GRACE_MS);
+        }
+    }, [status, isReady]);
+    // Teardown: never leave a pinned toast or a pending timer behind on unmount.
+    useEffect(() => {
+        return () => {
+            if (graceTimerRef.current) {
+                clearTimeout(graceTimerRef.current);
+                graceTimerRef.current = null;
+            }
+            if (noticeShownRef.current) {
+                dismissPersistentToastRef.current(CONNECTIVITY_TOAST_ID);
+                noticeShownRef.current = false;
+            }
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- unmount-only by design; dismiss read via ref
+    }, []);
+    return null;
+};
+//# sourceMappingURL=ConnectionStatusNotifier.js.map

package/dist/esm/core/requests/websockets/ConnectionStatusNotifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionStatusNotifier.js","sourceRoot":"","sources":["../../../../../../src/core/requests/websockets/ConnectionStatusNotifier.tsx"],"names":[],"mappings":"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","sourcesContent":["import { useEffect, useRef } from 'react';\nimport { FrontendComponentType } from '@wildo-ai/presets-components-models';\nimport { useWebSocket } from './useWebSocket';\nimport { WebSocketStatus } from './WebSocketContext';\nimport { useNotification } from '~wildo-frontend-lib/core/events/useNotification';\nimport { useI18n } from '~wildo-frontend-lib/core/i18n/useI18n';\n\n/**\n * Debounced, single-source connectivity notifier.\n *\n * Headless bridge (renders nothing) that turns the WebSocket connection state\n * machine into AT MOST ONE user-facing notification per outage:\n *\n * - **Transient blip (< grace):** nothing. The status bar already reflects\n *   DISCONNECTED/RECONNECTING; a mobile tunnel or a quick backend restart that\n *   recovers within the grace window shows no toast at all.\n * - **Sustained outage (>= grace):** ONE persistent, self-dismissing toast —\n *   \"reconnecting…\" while `RECONNECTING`, escalating in place to \"connection\n *   lost\" if reconnection gives up (`ERROR`). It is pinned by a stable id, so it\n *   updates rather than stacks, and auto-dismisses the instant we reconnect.\n *\n * This replaces the old per-attempt `errorManagement.handleError` toasts in\n * WebSocketContext (one Sonner toast per reconnection attempt). The transport\n * context now only drives status + one-per-outage observability logging; ALL\n * connection UX lives here, so there is a single place that owns the policy.\n *\n * Mounted once near the app-level `<Toaster/>` (see ApplicationMainContext).\n */\n\n/** Stable id so repeated updates replace the same toast instead of stacking. */\nconst CONNECTIVITY_TOAST_ID = 'wildo:connectivity-status';\n/**\n * Grace before surfacing anything — a blip shorter than this stays silent\n * (matches the locked 3s connectivity grace period).\n */\nconst CONNECTION_NOTICE_GRACE_MS = 3000;\n\n/**\n * Hardcoded English fallbacks for when the label BUNDLE is loaded (`isReady`)\n * but lacks these specific keys — e.g. an app whose generated label bundle\n * predates the keys. `tComponent` then returns the raw key PATH\n * (`components.<component>.<key>`) verbatim, and without this guard that raw\n * path shipped straight into the toast. Mirrors the miss-check\n * `NotificationContext.resolveMessage` applies to its own component-label\n * lookups (`startsWith('components.')`). The stale bundle itself is repaired by\n * regenerating labels; this is the engine-side class fix so a label gap can\n * never render as `components.application-level-status-bar.connectionLostNotice`.\n */\nconst CONNECTION_NOTICE_FALLBACK_MESSAGES = {\n  connectionReconnectingNotice: 'Connection lost — reconnecting…',\n  connectionLostNotice: 'Connection lost. Please check your network and reload the page.',\n} as const;\n\n/**\n * Only an ACTIVELY-RETRYING (`RECONNECTING`) or a GAVE-UP (`ERROR`) socket is a\n * surfaceable outage. Plain `DISCONNECTED`/`CONNECTING` is NOT: the socket only\n * emits reconnection events after `connect()` (which the app calls after auth),\n * so a logged-out user — or the pre-auth window, or an intentional\n * disconnect/logout — sits at `DISCONNECTED` and must never raise a\n * \"reconnecting\" notice. This is the guard that keeps the notice from firing for\n * every unauthenticated visitor.\n */\nconst isOutageStatus = (status: WebSocketStatus): boolean =>\n  status === WebSocketStatus.RECONNECTING || status === WebSocketStatus.ERROR;\n\nexport const ConnectionStatusNotifier = (): null => {\n  const { status } = useWebSocket();\n  const { showPersistentToast, dismissPersistentToast } = useNotification();\n  // Pass the component so its label bundle is requested — without this,\n  // `tComponent` returns the raw key path if the outage happens before any other\n  // consumer (the status bar) has loaded these keys. `isReady` gates surfacing.\n  const { tComponent, isReady } = useI18n({ component: FrontendComponentType.APPLICATION_LEVEL_STATUS_BAR });\n\n  // Ref the imperative callbacks (t-function, toast show/dismiss) so the effects\n  // do NOT depend on their identities. This is deliberate: the notice is a\n  // fire-and-forget side effect keyed on connection STATUS, not on those\n  // functions, and it makes the component robust regardless of whether\n  // NotificationContext / I18n keep them referentially stable — a future change\n  // that made them non-stable would otherwise re-fire the mount/teardown effects\n  // on every render and dismiss a live notice. Refs sidestep that entirely.\n  const tComponentRef = useRef(tComponent);\n  tComponentRef.current = tComponent;\n  const showPersistentToastRef = useRef(showPersistentToast);\n  showPersistentToastRef.current = showPersistentToast;\n  const dismissPersistentToastRef = useRef(dismissPersistentToast);\n  dismissPersistentToastRef.current = dismissPersistentToast;\n\n  // Latest status, read inside the debounce timer so a state change during the\n  // grace window surfaces the CURRENT state, not the one captured at schedule.\n  const statusRef = useRef(status);\n  statusRef.current = status;\n\n  const graceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const noticeShownRef = useRef(false);\n\n  // On (re)mount, reconcile any orphaned pinned toast from a PRIOR mount. Sonner's\n  // toast store is a module-level singleton that outlives this component, so after\n  // a bootstrap remount the old notice can survive while `noticeShownRef` resets\n  // to false — leaving a toast this instance would never dismiss.\n  //\n  // BUT only reconcile when mounting into a NON-outage state. If we remount while\n  // an outage is active, dismissing here would blink the live notice out for a\n  // full grace window before the main effect re-arms and re-shows it. Instead we\n  // KEEP any existing pinned toast: the main effect (below) arms its timer and\n  // refreshes the same stable id in place after grace, so the notice never\n  // disappears. Empty deps + ref access = genuinely mount-only.\n  useEffect(() => {\n    if (!isOutageStatus(statusRef.current)) {\n      dismissPersistentToastRef.current(CONNECTIVITY_TOAST_ID);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- mount-only by design; callbacks read via ref\n  }, []);\n\n  useEffect(() => {\n    const clearGraceTimer = (): void => {\n      if (graceTimerRef.current) {\n        clearTimeout(graceTimerRef.current);\n        graceTimerRef.current = null;\n      }\n    };\n\n    const surfaceNotice = (): void => {\n      const current = statusRef.current;\n      const isTerminal = current === WebSocketStatus.ERROR;\n      const labelKey = isTerminal ? 'connectionLostNotice' : 'connectionReconnectingNotice';\n      const translated = tComponentRef.current(FrontendComponentType.APPLICATION_LEVEL_STATUS_BAR, labelKey);\n      // An unresolved key comes back as its raw `components.…` key path — never\n      // show that to a user; fall back to hardcoded English (see the constant).\n      const message = translated.startsWith('components.') ? CONNECTION_NOTICE_FALLBACK_MESSAGES[labelKey] : translated;\n      showPersistentToastRef.current(CONNECTIVITY_TOAST_ID, isTerminal ? 'error' : 'loading', message);\n      noticeShownRef.current = true;\n    };\n\n    // Not a surfaceable outage (CONNECTED, CONNECTING, or DISCONNECTED): clear any\n    // pending timer and dismiss a shown notice. This covers reconnect SUCCESS\n    // (→ CONNECTED) AND intentional disconnect/logout (→ DISCONNECTED) — both must\n    // take down the notice.\n    if (!isOutageStatus(status)) {\n      clearGraceTimer();\n      if (noticeShownRef.current) {\n        dismissPersistentToastRef.current(CONNECTIVITY_TOAST_ID);\n        noticeShownRef.current = false;\n      }\n      return;\n    }\n\n    // Outage, but the localized message isn't available yet — wait for the bundle.\n    // This effect re-runs when `isReady` flips (it's in the deps).\n    if (!isReady) {\n      return;\n    }\n\n    if (noticeShownRef.current) {\n      // Already surfaced — update the message in place (e.g. reconnecting → lost).\n      surfaceNotice();\n      return;\n    }\n    // First outage state — start the grace timer once. Subsequent status changes\n    // within the window don't reset it (the timer reads the latest status when it\n    // fires), so a flapping reconnect still surfaces after one grace span.\n    if (!graceTimerRef.current) {\n      graceTimerRef.current = setTimeout(() => {\n        graceTimerRef.current = null;\n        surfaceNotice();\n      }, CONNECTION_NOTICE_GRACE_MS);\n    }\n  }, [status, isReady]);\n\n  // Teardown: never leave a pinned toast or a pending timer behind on unmount.\n  useEffect(() => {\n    return () => {\n      if (graceTimerRef.current) {\n        clearTimeout(graceTimerRef.current);\n        graceTimerRef.current = null;\n      }\n      if (noticeShownRef.current) {\n        dismissPersistentToastRef.current(CONNECTIVITY_TOAST_ID);\n        noticeShownRef.current = false;\n      }\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- unmount-only by design; dismiss read via ref\n  }, []);\n\n  return null;\n};\n"]}

package/dist/esm/core/requests/websockets/WebSocketContext.d.ts

@@ -12,6 +12,10 @@ export declare enum WebSocketStatus {
     ERROR = "error",
     RECONNECTING = "reconnecting"
 }
+type ContextResourceIdentifiersInput = Record<string, string | {
+    fieldIdentifier?: string;
+    resourceId?: string;
+}>;
 export interface WebSocketConfig {
     url: string;
     token?: string;
@@ -20,6 +24,26 @@ export interface WebSocketConfig {
     autoReconnect?: boolean;
     reconnectInterval?: number;
     maxReconnectAttempts?: number;
+    /**
+     * Invoked when the server rejects the handshake for an AUTHENTICATION reason
+     * (`connect_error` carrying `data.code === AUTHENTICATION_FAILED`) — i.e. the
+     * access token this socket presented is expired/invalid.
+     *
+     * The WebSocket layer deliberately does NOT know how to mint a token: the auth
+     * layer (`AuthSessionContext.tokenRenewalHandler`) owns the resilient refresh
+     * (cross-tab Web-Lock dedup, transient-vs-authoritative classification, dev
+     * leniency) and, on success, calls `refreshAuth()` to seed the fresh token and
+     * revive this socket. This callback is the WS layer's request for that renewal.
+     *
+     * Without it, a backgrounded/unfocused tab whose access token expires keeps
+     * replaying the expired token on every reconnect (no HTTP traffic flows to
+     * trigger a reactive refresh), so real-time background jobs stall until the
+     * user refocuses the window. See `AuthSessionContext.connectWebSocket`.
+     *
+     * May be async; the WS layer holds an in-flight guard until the returned
+     * promise settles so an in-flight renewal is never requested twice.
+     */
+    onAuthenticationError?: () => void | Promise<unknown>;
 }
 export interface SubscribedRoom {
     roomName: string;
@@ -48,7 +72,7 @@ export interface WebSocketContextType {
         resourceId?: string;
         scopeKey?: string;
         scopeId?: string;
-        contextResourceIdentifiers: Record<string, string>;
+        contextResourceIdentifiers: ContextResourceIdentifiersInput;
     }) => Promise<{
         success: boolean;
         editingUsers?: string[];
@@ -59,7 +83,7 @@ export interface WebSocketContextType {
         resourceId?: string;
         scopeKey?: string;
         scopeId?: string;
-        contextResourceIdentifiers: Record<string, string>;
+        contextResourceIdentifiers: ContextResourceIdentifiersInput;
     }) => Promise<{
         success: boolean;
         editingUsers?: string[];
@@ -69,7 +93,7 @@ export interface WebSocketContextType {
         resourceId?: string;
         scopeKey?: string;
         scopeId?: string;
-        contextResourceIdentifiers: Record<string, string>;
+        contextResourceIdentifiers: ContextResourceIdentifiersInput;
     }) => Promise<void>;
     releaseResourceRoom: (params: {
         ownerKey: string;
@@ -77,12 +101,12 @@ export interface WebSocketContextType {
         resourceId?: string;
         scopeKey?: string;
         scopeId?: string;
-        contextResourceIdentifiers: Record<string, string>;
+        contextResourceIdentifiers: ContextResourceIdentifiersInput;
     }) => Promise<void>;
     startEditing: (params: {
         resourceType: string;
         resourceId: string;
-        contextResourceIdentifiers: Record<string, string>;
+        contextResourceIdentifiers: ContextResourceIdentifiersInput;
     }) => Promise<boolean>;
     stopEditing: (params: {
         resourceType: string;
@@ -93,7 +117,7 @@ export interface WebSocketContextType {
         resourceId: string;
         eventName: string;
         data?: unknown;
-        contextResourceIdentifiers: Record<string, string>;
+        contextResourceIdentifiers: ContextResourceIdentifiersInput;
         includeSelf?: boolean;
     }) => void;
     getBadge: (identifier: string, scope: string, scopeId: string) => Promise<number>;
@@ -113,4 +137,5 @@ export declare const WebSocketContext: React.Context<WebSocketContextType | unde
 export declare const WebSocketProvider: React.FC<{
     children: ReactNode;
 }>;
+export {};
 //# sourceMappingURL=WebSocketContext.d.ts.map

package/dist/esm/core/requests/websockets/WebSocketContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebSocketContext.d.ts","sourceRoot":"","sources":["../../../../../src/core/requests/websockets/WebSocketContext.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"WebSocketContext.d.ts","sourceRoot":"","sources":["../../../../../../src/core/requests/websockets/WebSocketContext.tsx"],"names":[],"mappings":"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"}