@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/data/stableUuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stableUuid.js","sourceRoot":"","sources":["stableUuid.ts"],"names":[],"mappings":"AAAA,MAAM,YAAY,GAAG,IAAI,WAAW,EAAE,CAAC;AAEvC,SAAS,gBAAgB,CAAC,IAAgB,EAAE,KAAiB;IAC3D,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;IACjE,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACnB,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAClC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC7B,OAAO,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,UAAU,CAAC,KAAiB;IACnC,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClD,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,CACxD,EAAE,EACF,EAAE,CACH,IAAI,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;AAChD,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAiB;IAC5C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC5C,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YAChB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QAC9B,CAAC;QAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YAChB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QAC9B,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,SAAqB,EACrB,IAAY;IAEZ,MAAM,MAAM,GAAG,IAAI,UAAU,CAC3B,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CACxB,OAAO,EACP,gBAAgB,CAAC,SAAS,EAAE,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CACvD,CACF,CAAC;IACF,OAAO,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;AACjD,CAAC","sourcesContent":["const TEXT_ENCODER = new TextEncoder();\n\nfunction concatenateBytes(left: Uint8Array, right: Uint8Array) {\n  const bytes = new Uint8Array(left.byteLength + right.byteLength);\n  bytes.set(left, 0);\n  bytes.set(right, left.byteLength);\n  return bytes;\n}\n\nfunction byteToHex(byte: number): string {\n  return byte.toString(16).padStart(2, \"0\");\n}\n\nfunction formatUuid(bytes: Uint8Array): string {\n  const hex = Array.from(bytes, byteToHex).join(\"\");\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(\n    12,\n    16,\n  )}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;\n}\n\nfunction toUuidV4ShapedBytes(bytes: Uint8Array): Uint8Array {\n  return bytes.slice(0, 16).map((byte, index) => {\n    if (index === 6) {\n      return (byte & 0x0f) | 0x40;\n    }\n\n    if (index === 8) {\n      return (byte & 0x3f) | 0x80;\n    }\n\n    return byte;\n  });\n}\n\n/**\n * Derives a stable, UUID-shaped id from a 16-byte namespace and a name string.\n *\n * The digest (RFC-4122 v5 style: SHA-1 over namespace ++ name) makes the id\n * idempotent — the same inputs always yield the same id, so a retry after a lost\n * response re-sends the id the first attempt used. The version and variant bits\n * are normalized to a v4 shape because the remote APIs validate ids against the\n * same v4 UUID contract they use for random `crypto.randomUUID()` ids.\n */\nexport async function deriveStableUuidV4Shaped(\n  namespace: Uint8Array,\n  name: string,\n): Promise<string> {\n  const digest = new Uint8Array(\n    await crypto.subtle.digest(\n      \"SHA-1\",\n      concatenateBytes(namespace, TEXT_ENCODER.encode(name)),\n    ),\n  );\n  return formatUuid(toUuidV4ShapedBytes(digest));\n}\n"]}

package/data/sync/coordinatorPump.d.ts

@@ -0,0 +1,10 @@
+import type { DomainSyncCoordinatorState, SyncLaneState } from "./coordinatorState.js";
+export interface SyncIdleOptions {
+    intervalMs?: number;
+    quietMs?: number;
+    timeoutMs?: number;
+}
+export declare function requestLaneSync(coordinatorState: DomainSyncCoordinatorState, lane: SyncLaneState): void;
+export declare function requestLaneSyncAfter(coordinatorState: DomainSyncCoordinatorState, lane: SyncLaneState, delayMs: number): void;
+export declare function requestAllPumpDrivenLanes(coordinatorState: DomainSyncCoordinatorState): void;
+export declare function waitForIdleLanes(coordinatorState: DomainSyncCoordinatorState, options?: SyncIdleOptions): Promise<boolean>;

package/data/sync/coordinatorPump.js

@@ -0,0 +1,305 @@
+import { describeSyncLaneError, hasPendingLaneWork, publishSyncCoordinatorSnapshot, } from "./coordinatorState.js";
+import { compareSyncLaneOrder, createSyncTimestamp } from "./syncTelemetry.js";
+const DEFAULT_SYNC_IDLE_INTERVAL_MS = 10;
+const DEFAULT_SYNC_IDLE_QUIET_MS = 0;
+const DEFAULT_SYNC_IDLE_TIMEOUT_MS = 500;
+// Slow down repeated failures and yield periodically during successful bursts
+// so lanes that keep requesting work cannot starve timers or other tasks.
+const FAILED_LANE_REARM_BACKOFF_MS = 1000;
+// Allow normal convergence bursts to finish without a timer delay.
+const SYNC_PUMP_MACROTASK_YIELD_INTERVAL = 16;
+// A timed-out run keeps its lane occupied until it settles, but releases the
+// serial pump so other lanes can proceed.
+const SYNC_LANE_WATCHDOG_MS = 120_000;
+// Keyed on the registered config so a discarded lane is collectable.
+const lastReportedFailureByConfig = new WeakMap();
+// Local-only dedup key. describeSyncLaneError joins messages without their
+// types, so the name keeps a swallowed DatabaseUnavailableError distinct from
+// a plain Error carrying the same text; the cause chain keeps a re-wrapped
+// failure distinct from its origin.
+function describeSyncLaneFailureSignature(error) {
+    const name = error instanceof Error ? error.name : typeof error;
+    return JSON.stringify([name, describeSyncLaneError(error)]);
+}
+// Observability only: a failing lane re-arms every FAILED_LANE_REARM_BACKOFF_MS
+// for the rest of the session, and mobile WebViews are never reloaded, so an
+// unrecoverable lane would report once a second. The signature is deliberately
+// never cleared on a completed run: alternating success and failure would
+// re-admit the same report every pass and evict the surrounding diagnostic
+// trail from the host's bounded log.
+function reportUnexpectedSyncLaneFailure(state, error) {
+    const report = state.config.reportUnexpectedError;
+    if (!report)
+        return;
+    const signature = describeSyncLaneFailureSignature(error);
+    if (lastReportedFailureByConfig.get(state.config) === signature)
+        return;
+    lastReportedFailureByConfig.set(state.config, signature);
+    try {
+        void Promise.resolve(report(error)).catch(() => undefined);
+    }
+    catch {
+        // Hosts may throw synchronously or return a rejected promise.
+    }
+}
+async function runSyncLane(state) {
+    try {
+        await state.config.run();
+        return { status: "completed" };
+    }
+    catch (error) {
+        if (state.config.shouldIgnoreError?.(error)) {
+            return { status: "completed" };
+        }
+        reportUnexpectedSyncLaneFailure(state, error);
+        if (state.config.onUnexpectedError) {
+            state.config.onUnexpectedError(error);
+            return { status: "failed", error };
+        }
+        throw error;
+    }
+}
+// Console-only on purpose. This runs only when the lane's OWN error handler
+// already threw, so it must never route through reportUnexpectedSyncLaneFailure
+// as well: re-entering a handler that just threw would reject runResultPromise
+// from inside its own onRejected callback, leaving `running` true and
+// `activeRunToken` set, which wedges the lane for the rest of the session.
+function reportUnexpectedSyncLaneError(state, error) {
+    console.error(`Failed to run sync lane ${state.key}:`, error);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// An abandoned run still owns its lane. Its eventual settlement will restart
+// the pump; trying to restart earlier would spin without runnable work.
+function isRequestedLaneAvailable(lane) {
+    return lane.pumpDriven && lane.requested && lane.activeRunToken === null;
+}
+function hasRequestedLaneWork(lanes) {
+    const now = Date.now();
+    for (const lane of lanes) {
+        if (isRequestedLaneAvailable(lane) &&
+            (lane.notBeforeAtMs === null || lane.notBeforeAtMs <= now)) {
+            return true;
+        }
+    }
+    return false;
+}
+function selectNextRequestedLane(lanes) {
+    let selectedLane = null;
+    const now = Date.now();
+    for (const lane of lanes) {
+        if (!isRequestedLaneAvailable(lane) ||
+            (lane.notBeforeAtMs !== null && lane.notBeforeAtMs > now)) {
+            continue;
+        }
+        if (!selectedLane || compareSyncLaneOrder(lane, selectedLane) < 0) {
+            selectedLane = lane;
+        }
+    }
+    return selectedLane;
+}
+function recordSyncLaneRunResult(lane, runResult) {
+    lane.lastActionAt = createSyncTimestamp();
+    if (runResult.status === "failed") {
+        lane.errorCount += 1;
+        lane.lastAction = "failed";
+        lane.lastError = describeSyncLaneError(runResult.error);
+        lane.lastFailedAt = lane.lastActionAt;
+    }
+    else {
+        lane.lastAction = "completed";
+        lane.lastCompletedAt = lane.lastActionAt;
+        lane.lastError = null;
+    }
+}
+// Replace the watchdog failure with the late result, then release queued work.
+function settleAbandonedSyncLaneRun(coordinatorState, lane, runToken, runResult) {
+    if (lane.activeRunToken !== runToken) {
+        return;
+    }
+    lane.activeRunToken = null;
+    lane.runAbandoned = false;
+    recordSyncLaneRunResult(lane, runResult);
+    publishSyncCoordinatorSnapshot(coordinatorState);
+    if (!coordinatorState.disposed &&
+        hasRequestedLaneWork(coordinatorState.lanes.values())) {
+        scheduleCoordinatorPump(coordinatorState);
+    }
+}
+function startSyncLaneRun(coordinatorState, lane) {
+    lane.requested = false;
+    lane.notBeforeAtMs = null;
+    lane.running = true;
+    lane.runCount += 1;
+    lane.lastAction = "started";
+    lane.lastActionAt = createSyncTimestamp();
+    lane.lastStartedAt = lane.lastActionAt;
+    lane.runAbandoned = false;
+    const runToken = {};
+    lane.activeRunToken = runToken;
+    publishSyncCoordinatorSnapshot(coordinatorState);
+    // Keep follow-up requests even on failure to preserve phase ordering; see
+    // docs/client-sync-ordering.md.
+    // The fallback also catches errors thrown by the lane's error handlers.
+    const runResultPromise = runSyncLane(lane).then((result) => result, (error) => {
+        reportUnexpectedSyncLaneError(lane, error);
+        return { status: "failed", error };
+    });
+    return { runToken, runResultPromise };
+}
+async function runRequestedSyncLanes(coordinatorState) {
+    let runsSinceMacrotaskYield = 0;
+    // Disposal can happen during a run. Finish it before selecting more work.
+    while (!coordinatorState.disposed) {
+        const lane = selectNextRequestedLane(coordinatorState.lanes.values());
+        if (!lane) {
+            return;
+        }
+        const { runToken, runResultPromise } = startSyncLaneRun(coordinatorState, lane);
+        // Clamp overrides to at least 1ms so every run has a chance to complete.
+        const watchdogMs = Math.max(1, lane.config.watchdogMs ?? SYNC_LANE_WATCHDOG_MS);
+        let watchdogTimer = null;
+        const raceOutcome = await Promise.race([
+            runResultPromise.then((result) => ({
+                kind: "settled",
+                result,
+            })),
+            new Promise((resolve) => {
+                watchdogTimer = setTimeout(() => resolve({ kind: "timed-out" }), watchdogMs);
+            }),
+        ]);
+        if (watchdogTimer !== null) {
+            clearTimeout(watchdogTimer);
+        }
+        lane.running = false;
+        let runResult;
+        if (raceOutcome.kind === "settled") {
+            lane.activeRunToken = null;
+            runResult = raceOutcome.result;
+        }
+        else {
+            lane.runAbandoned = true;
+            runResult = {
+                status: "failed",
+                error: new Error(`Sync lane watchdog: run exceeded ${watchdogMs}ms; continuing with other lanes`),
+            };
+            void runResultPromise.then((result) => settleAbandonedSyncLaneRun(coordinatorState, lane, runToken, result));
+        }
+        recordSyncLaneRunResult(lane, runResult);
+        publishSyncCoordinatorSnapshot(coordinatorState);
+        runsSinceMacrotaskYield += 1;
+        if (runResult.status === "failed" &&
+            lane.requested &&
+            raceOutcome.kind === "settled") {
+            // Timed-out runs cannot run again until they settle, so only ordinary
+            // failures need backoff. Other lanes can proceed immediately on timeout.
+            await delay(FAILED_LANE_REARM_BACKOFF_MS);
+            runsSinceMacrotaskYield = 0;
+        }
+        else if (runsSinceMacrotaskYield >= SYNC_PUMP_MACROTASK_YIELD_INTERVAL) {
+            // Awaiting resolved promises only yields microtasks. A timer also lets
+            // the event loop advance when lanes keep requesting each other.
+            await delay(0);
+            runsSinceMacrotaskYield = 0;
+        }
+    }
+}
+function scheduleCoordinatorPump(coordinatorState) {
+    if (coordinatorState.pump || coordinatorState.disposed) {
+        return;
+    }
+    coordinatorState.pump = Promise.resolve()
+        .then(() => runRequestedSyncLanes(coordinatorState))
+        .finally(() => {
+        coordinatorState.pump = null;
+        publishSyncCoordinatorSnapshot(coordinatorState);
+        if (!coordinatorState.disposed &&
+            hasRequestedLaneWork(coordinatorState.lanes.values())) {
+            scheduleCoordinatorPump(coordinatorState);
+        }
+    });
+}
+function markLaneRequested(lane, requestedAt) {
+    lane.requested = true;
+    lane.requestCount += 1;
+    lane.lastAction = "requested";
+    lane.lastActionAt = requestedAt;
+    lane.lastRequestedAt = requestedAt;
+}
+export function requestLaneSync(coordinatorState, lane) {
+    if (coordinatorState.disposed || !lane.pumpDriven) {
+        return;
+    }
+    lane.notBeforeAtMs = null;
+    markLaneRequested(lane, createSyncTimestamp());
+    publishSyncCoordinatorSnapshot(coordinatorState);
+    scheduleCoordinatorPump(coordinatorState);
+}
+export function requestLaneSyncAfter(coordinatorState, lane, delayMs) {
+    if (coordinatorState.disposed || !lane.pumpDriven) {
+        return;
+    }
+    if (lane.requested && lane.notBeforeAtMs === null) {
+        return;
+    }
+    const requestedAtMs = Date.now() + Math.max(0, delayMs);
+    lane.notBeforeAtMs =
+        lane.notBeforeAtMs === null
+            ? requestedAtMs
+            : Math.min(lane.notBeforeAtMs, requestedAtMs);
+    markLaneRequested(lane, createSyncTimestamp());
+    publishSyncCoordinatorSnapshot(coordinatorState);
+    const scheduledAtMs = lane.notBeforeAtMs;
+    setTimeout(() => {
+        if (coordinatorState.disposed || lane.notBeforeAtMs !== scheduledAtMs) {
+            return;
+        }
+        lane.notBeforeAtMs = null;
+        publishSyncCoordinatorSnapshot(coordinatorState);
+        scheduleCoordinatorPump(coordinatorState);
+    }, Math.max(0, scheduledAtMs - Date.now()));
+}
+export function requestAllPumpDrivenLanes(coordinatorState) {
+    if (coordinatorState.disposed || coordinatorState.lanes.size === 0) {
+        return;
+    }
+    // Publish all requests together. Observational upload lanes report actual
+    // uploads and must never be driven through their no-op runner.
+    const requestedAt = createSyncTimestamp();
+    let didRequestLane = false;
+    for (const lane of coordinatorState.lanes.values()) {
+        if (!lane.pumpDriven) {
+            continue;
+        }
+        lane.notBeforeAtMs = null;
+        markLaneRequested(lane, requestedAt);
+        didRequestLane = true;
+    }
+    if (!didRequestLane) {
+        return;
+    }
+    publishSyncCoordinatorSnapshot(coordinatorState);
+    scheduleCoordinatorPump(coordinatorState);
+}
+export async function waitForIdleLanes(coordinatorState, options = {}) {
+    const intervalMs = options.intervalMs ?? DEFAULT_SYNC_IDLE_INTERVAL_MS;
+    const quietMs = options.quietMs ?? DEFAULT_SYNC_IDLE_QUIET_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_SYNC_IDLE_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    let quietStartedAt = Date.now();
+    while (Date.now() <= deadline) {
+        if (!coordinatorState.pump &&
+            !hasPendingLaneWork(coordinatorState.lanes.values())) {
+            if (Date.now() - quietStartedAt >= quietMs) {
+                return true;
+            }
+        }
+        else {
+            quietStartedAt = Date.now();
+        }
+        await delay(intervalMs);
+    }
+    return false;
+}
+//# sourceMappingURL=coordinatorPump.js.map

package/data/sync/coordinatorPump.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinatorPump.js","sourceRoot":"","sources":["coordinatorPump.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  DomainSyncCoordinatorState,\n  SyncLaneState,\n} from \"./coordinatorState\";\nimport {\n  describeSyncLaneError,\n  hasPendingLaneWork,\n  publishSyncCoordinatorSnapshot,\n} from \"./coordinatorState\";\nimport type { SyncLaneConfig } from \"./syncLaneConfig\";\nimport { compareSyncLaneOrder, createSyncTimestamp } from \"./syncTelemetry\";\n\nexport interface SyncIdleOptions {\n  intervalMs?: number;\n  quietMs?: number;\n  timeoutMs?: number;\n}\n\nconst DEFAULT_SYNC_IDLE_INTERVAL_MS = 10;\nconst DEFAULT_SYNC_IDLE_QUIET_MS = 0;\nconst DEFAULT_SYNC_IDLE_TIMEOUT_MS = 500;\n// Slow down repeated failures and yield periodically during successful bursts\n// so lanes that keep requesting work cannot starve timers or other tasks.\nconst FAILED_LANE_REARM_BACKOFF_MS = 1000;\n// Allow normal convergence bursts to finish without a timer delay.\nconst SYNC_PUMP_MACROTASK_YIELD_INTERVAL = 16;\n// A timed-out run keeps its lane occupied until it settles, but releases the\n// serial pump so other lanes can proceed.\nconst SYNC_LANE_WATCHDOG_MS = 120_000;\n\ntype SyncLaneRunResult =\n  | { status: \"completed\" }\n  | { status: \"failed\"; error: unknown };\n\n// Keyed on the registered config so a discarded lane is collectable.\nconst lastReportedFailureByConfig = new WeakMap<SyncLaneConfig, string>();\n\n// Local-only dedup key. describeSyncLaneError joins messages without their\n// types, so the name keeps a swallowed DatabaseUnavailableError distinct from\n// a plain Error carrying the same text; the cause chain keeps a re-wrapped\n// failure distinct from its origin.\nfunction describeSyncLaneFailureSignature(error: unknown): string {\n  const name = error instanceof Error ? error.name : typeof error;\n  return JSON.stringify([name, describeSyncLaneError(error)]);\n}\n\n// Observability only: a failing lane re-arms every FAILED_LANE_REARM_BACKOFF_MS\n// for the rest of the session, and mobile WebViews are never reloaded, so an\n// unrecoverable lane would report once a second. The signature is deliberately\n// never cleared on a completed run: alternating success and failure would\n// re-admit the same report every pass and evict the surrounding diagnostic\n// trail from the host's bounded log.\nfunction reportUnexpectedSyncLaneFailure(\n  state: SyncLaneState,\n  error: unknown,\n): void {\n  const report = state.config.reportUnexpectedError;\n  if (!report) return;\n  const signature = describeSyncLaneFailureSignature(error);\n  if (lastReportedFailureByConfig.get(state.config) === signature) return;\n  lastReportedFailureByConfig.set(state.config, signature);\n  try {\n    void Promise.resolve(report(error)).catch(() => undefined);\n  } catch {\n    // Hosts may throw synchronously or return a rejected promise.\n  }\n}\n\nasync function runSyncLane(state: SyncLaneState): Promise<SyncLaneRunResult> {\n  try {\n    await state.config.run();\n    return { status: \"completed\" };\n  } catch (error: unknown) {\n    if (state.config.shouldIgnoreError?.(error)) {\n      return { status: \"completed\" };\n    }\n    reportUnexpectedSyncLaneFailure(state, error);\n\n    if (state.config.onUnexpectedError) {\n      state.config.onUnexpectedError(error);\n      return { status: \"failed\", error };\n    }\n\n    throw error;\n  }\n}\n\n// Console-only on purpose. This runs only when the lane's OWN error handler\n// already threw, so it must never route through reportUnexpectedSyncLaneFailure\n// as well: re-entering a handler that just threw would reject runResultPromise\n// from inside its own onRejected callback, leaving `running` true and\n// `activeRunToken` set, which wedges the lane for the rest of the session.\nfunction reportUnexpectedSyncLaneError(state: SyncLaneState, error: unknown) {\n  console.error(`Failed to run sync lane ${state.key}:`, error);\n}\n\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n// An abandoned run still owns its lane. Its eventual settlement will restart\n// the pump; trying to restart earlier would spin without runnable work.\nfunction isRequestedLaneAvailable(lane: SyncLaneState): boolean {\n  return lane.pumpDriven && lane.requested && lane.activeRunToken === null;\n}\n\nfunction hasRequestedLaneWork(lanes: Iterable<SyncLaneState>): boolean {\n  const now = Date.now();\n  for (const lane of lanes) {\n    if (\n      isRequestedLaneAvailable(lane) &&\n      (lane.notBeforeAtMs === null || lane.notBeforeAtMs <= now)\n    ) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction selectNextRequestedLane(\n  lanes: Iterable<SyncLaneState>,\n): SyncLaneState | null {\n  let selectedLane: SyncLaneState | null = null;\n  const now = Date.now();\n\n  for (const lane of lanes) {\n    if (\n      !isRequestedLaneAvailable(lane) ||\n      (lane.notBeforeAtMs !== null && lane.notBeforeAtMs > now)\n    ) {\n      continue;\n    }\n    if (!selectedLane || compareSyncLaneOrder(lane, selectedLane) < 0) {\n      selectedLane = lane;\n    }\n  }\n\n  return selectedLane;\n}\n\nfunction recordSyncLaneRunResult(\n  lane: SyncLaneState,\n  runResult: SyncLaneRunResult,\n): void {\n  lane.lastActionAt = createSyncTimestamp();\n  if (runResult.status === \"failed\") {\n    lane.errorCount += 1;\n    lane.lastAction = \"failed\";\n    lane.lastError = describeSyncLaneError(runResult.error);\n    lane.lastFailedAt = lane.lastActionAt;\n  } else {\n    lane.lastAction = \"completed\";\n    lane.lastCompletedAt = lane.lastActionAt;\n    lane.lastError = null;\n  }\n}\n\n// Replace the watchdog failure with the late result, then release queued work.\nfunction settleAbandonedSyncLaneRun(\n  coordinatorState: DomainSyncCoordinatorState,\n  lane: SyncLaneState,\n  runToken: object,\n  runResult: SyncLaneRunResult,\n): void {\n  if (lane.activeRunToken !== runToken) {\n    return;\n  }\n  lane.activeRunToken = null;\n  lane.runAbandoned = false;\n  recordSyncLaneRunResult(lane, runResult);\n  publishSyncCoordinatorSnapshot(coordinatorState);\n  if (\n    !coordinatorState.disposed &&\n    hasRequestedLaneWork(coordinatorState.lanes.values())\n  ) {\n    scheduleCoordinatorPump(coordinatorState);\n  }\n}\n\nfunction startSyncLaneRun(\n  coordinatorState: DomainSyncCoordinatorState,\n  lane: SyncLaneState,\n) {\n  lane.requested = false;\n  lane.notBeforeAtMs = null;\n  lane.running = true;\n  lane.runCount += 1;\n  lane.lastAction = \"started\";\n  lane.lastActionAt = createSyncTimestamp();\n  lane.lastStartedAt = lane.lastActionAt;\n  lane.runAbandoned = false;\n  const runToken = {};\n  lane.activeRunToken = runToken;\n  publishSyncCoordinatorSnapshot(coordinatorState);\n\n  // Keep follow-up requests even on failure to preserve phase ordering; see\n  // docs/client-sync-ordering.md.\n  // The fallback also catches errors thrown by the lane's error handlers.\n  const runResultPromise: Promise<SyncLaneRunResult> = runSyncLane(lane).then(\n    (result) => result,\n    (error: unknown) => {\n      reportUnexpectedSyncLaneError(lane, error);\n      return { status: \"failed\", error };\n    },\n  );\n\n  return { runToken, runResultPromise };\n}\n\nasync function runRequestedSyncLanes(\n  coordinatorState: DomainSyncCoordinatorState,\n): Promise<void> {\n  let runsSinceMacrotaskYield = 0;\n  // Disposal can happen during a run. Finish it before selecting more work.\n  while (!coordinatorState.disposed) {\n    const lane = selectNextRequestedLane(coordinatorState.lanes.values());\n    if (!lane) {\n      return;\n    }\n\n    const { runToken, runResultPromise } = startSyncLaneRun(\n      coordinatorState,\n      lane,\n    );\n    // Clamp overrides to at least 1ms so every run has a chance to complete.\n    const watchdogMs = Math.max(\n      1,\n      lane.config.watchdogMs ?? SYNC_LANE_WATCHDOG_MS,\n    );\n    let watchdogTimer: ReturnType<typeof setTimeout> | null = null;\n    const raceOutcome = await Promise.race([\n      runResultPromise.then((result) => ({\n        kind: \"settled\" as const,\n        result,\n      })),\n      new Promise<{ kind: \"timed-out\" }>((resolve) => {\n        watchdogTimer = setTimeout(\n          () => resolve({ kind: \"timed-out\" }),\n          watchdogMs,\n        );\n      }),\n    ]);\n    if (watchdogTimer !== null) {\n      clearTimeout(watchdogTimer);\n    }\n\n    lane.running = false;\n    let runResult: SyncLaneRunResult;\n    if (raceOutcome.kind === \"settled\") {\n      lane.activeRunToken = null;\n      runResult = raceOutcome.result;\n    } else {\n      lane.runAbandoned = true;\n      runResult = {\n        status: \"failed\",\n        error: new Error(\n          `Sync lane watchdog: run exceeded ${watchdogMs}ms; continuing with other lanes`,\n        ),\n      };\n      void runResultPromise.then((result) =>\n        settleAbandonedSyncLaneRun(coordinatorState, lane, runToken, result),\n      );\n    }\n    recordSyncLaneRunResult(lane, runResult);\n    publishSyncCoordinatorSnapshot(coordinatorState);\n\n    runsSinceMacrotaskYield += 1;\n\n    if (\n      runResult.status === \"failed\" &&\n      lane.requested &&\n      raceOutcome.kind === \"settled\"\n    ) {\n      // Timed-out runs cannot run again until they settle, so only ordinary\n      // failures need backoff. Other lanes can proceed immediately on timeout.\n      await delay(FAILED_LANE_REARM_BACKOFF_MS);\n      runsSinceMacrotaskYield = 0;\n    } else if (runsSinceMacrotaskYield >= SYNC_PUMP_MACROTASK_YIELD_INTERVAL) {\n      // Awaiting resolved promises only yields microtasks. A timer also lets\n      // the event loop advance when lanes keep requesting each other.\n      await delay(0);\n      runsSinceMacrotaskYield = 0;\n    }\n  }\n}\n\nfunction scheduleCoordinatorPump(coordinatorState: DomainSyncCoordinatorState) {\n  if (coordinatorState.pump || coordinatorState.disposed) {\n    return;\n  }\n\n  coordinatorState.pump = Promise.resolve()\n    .then(() => runRequestedSyncLanes(coordinatorState))\n    .finally(() => {\n      coordinatorState.pump = null;\n      publishSyncCoordinatorSnapshot(coordinatorState);\n\n      if (\n        !coordinatorState.disposed &&\n        hasRequestedLaneWork(coordinatorState.lanes.values())\n      ) {\n        scheduleCoordinatorPump(coordinatorState);\n      }\n    });\n}\n\nfunction markLaneRequested(lane: SyncLaneState, requestedAt: string): void {\n  lane.requested = true;\n  lane.requestCount += 1;\n  lane.lastAction = \"requested\";\n  lane.lastActionAt = requestedAt;\n  lane.lastRequestedAt = requestedAt;\n}\n\nexport function requestLaneSync(\n  coordinatorState: DomainSyncCoordinatorState,\n  lane: SyncLaneState,\n) {\n  if (coordinatorState.disposed || !lane.pumpDriven) {\n    return;\n  }\n  lane.notBeforeAtMs = null;\n  markLaneRequested(lane, createSyncTimestamp());\n  publishSyncCoordinatorSnapshot(coordinatorState);\n  scheduleCoordinatorPump(coordinatorState);\n}\n\nexport function requestLaneSyncAfter(\n  coordinatorState: DomainSyncCoordinatorState,\n  lane: SyncLaneState,\n  delayMs: number,\n): void {\n  if (coordinatorState.disposed || !lane.pumpDriven) {\n    return;\n  }\n  if (lane.requested && lane.notBeforeAtMs === null) {\n    return;\n  }\n  const requestedAtMs = Date.now() + Math.max(0, delayMs);\n  lane.notBeforeAtMs =\n    lane.notBeforeAtMs === null\n      ? requestedAtMs\n      : Math.min(lane.notBeforeAtMs, requestedAtMs);\n  markLaneRequested(lane, createSyncTimestamp());\n  publishSyncCoordinatorSnapshot(coordinatorState);\n  const scheduledAtMs = lane.notBeforeAtMs;\n  setTimeout(\n    () => {\n      if (coordinatorState.disposed || lane.notBeforeAtMs !== scheduledAtMs) {\n        return;\n      }\n      lane.notBeforeAtMs = null;\n      publishSyncCoordinatorSnapshot(coordinatorState);\n      scheduleCoordinatorPump(coordinatorState);\n    },\n    Math.max(0, scheduledAtMs - Date.now()),\n  );\n}\n\nexport function requestAllPumpDrivenLanes(\n  coordinatorState: DomainSyncCoordinatorState,\n): void {\n  if (coordinatorState.disposed || coordinatorState.lanes.size === 0) {\n    return;\n  }\n\n  // Publish all requests together. Observational upload lanes report actual\n  // uploads and must never be driven through their no-op runner.\n  const requestedAt = createSyncTimestamp();\n  let didRequestLane = false;\n  for (const lane of coordinatorState.lanes.values()) {\n    if (!lane.pumpDriven) {\n      continue;\n    }\n    lane.notBeforeAtMs = null;\n    markLaneRequested(lane, requestedAt);\n    didRequestLane = true;\n  }\n  if (!didRequestLane) {\n    return;\n  }\n\n  publishSyncCoordinatorSnapshot(coordinatorState);\n  scheduleCoordinatorPump(coordinatorState);\n}\n\nexport async function waitForIdleLanes(\n  coordinatorState: DomainSyncCoordinatorState,\n  options: SyncIdleOptions = {},\n): Promise<boolean> {\n  const intervalMs = options.intervalMs ?? DEFAULT_SYNC_IDLE_INTERVAL_MS;\n  const quietMs = options.quietMs ?? DEFAULT_SYNC_IDLE_QUIET_MS;\n  const timeoutMs = options.timeoutMs ?? DEFAULT_SYNC_IDLE_TIMEOUT_MS;\n  const deadline = Date.now() + timeoutMs;\n  let quietStartedAt = Date.now();\n\n  while (Date.now() <= deadline) {\n    if (\n      !coordinatorState.pump &&\n      !hasPendingLaneWork(coordinatorState.lanes.values())\n    ) {\n      if (Date.now() - quietStartedAt >= quietMs) {\n        return true;\n      }\n    } else {\n      quietStartedAt = Date.now();\n    }\n\n    await delay(intervalMs);\n  }\n\n  return false;\n}\n"]}

package/data/sync/coordinatorState.d.ts

@@ -0,0 +1,43 @@
+import type { SyncLaneConfig } from "./syncLaneConfig.js";
+import type { DomainSyncSnapshot, SyncLaneLastAction, SyncLaneProgress } from "./syncTelemetry.js";
+export interface SyncLaneState {
+    activeRunToken: object | null;
+    blobStorageKey: string | null;
+    config: SyncLaneConfig;
+    errorCount: number;
+    key: string;
+    lastAction: SyncLaneLastAction;
+    lastActionAt: string;
+    lastCompletedAt: string | null;
+    lastError: string | null;
+    lastFailedAt: string | null;
+    lastRequestedAt: string | null;
+    lastStartedAt: string | null;
+    notBeforeAtMs: number | null;
+    progress: SyncLaneProgress | null;
+    pumpDriven: boolean;
+    registrationIndex: number;
+    requestCount: number;
+    requested: boolean;
+    runAbandoned: boolean;
+    runCount: number;
+    running: boolean;
+}
+export interface DomainSyncCoordinatorState {
+    disposed: boolean;
+    lanes: Map<string, SyncLaneState>;
+    listeners: Set<() => void>;
+    nextRegistrationIndex: number;
+    pump: Promise<void> | null;
+    snapshot: DomainSyncSnapshot;
+}
+export declare const INITIAL_SYNC_LANE_RUN_STATE: {
+    readonly activeRunToken: null;
+    readonly runAbandoned: false;
+    readonly runCount: 0;
+    readonly running: false;
+};
+export declare function describeSyncLaneError(error: unknown): string;
+export declare function noopLaneRun(): Promise<void>;
+export declare function hasPendingLaneWork(lanes: Iterable<SyncLaneState>): boolean;
+export declare function publishSyncCoordinatorSnapshot(state: DomainSyncCoordinatorState): void;

package/data/sync/coordinatorState.js

@@ -0,0 +1,72 @@
+import { createDomainSyncSnapshot } from "./syncTelemetry.js";
+export const INITIAL_SYNC_LANE_RUN_STATE = {
+    activeRunToken: null,
+    runAbandoned: false,
+    runCount: 0,
+    running: false,
+};
+function describeSingleSyncLaneError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "object" &&
+        error !== null &&
+        "message" in error &&
+        typeof error.message === "string") {
+        return error.message;
+    }
+    return String(error);
+}
+function readErrorCause(error) {
+    if (typeof error !== "object" || error === null) {
+        return undefined;
+    }
+    return Reflect.get(error, "cause");
+}
+export function describeSyncLaneError(error) {
+    const messages = [];
+    const seen = new Set();
+    let current = error;
+    while (current !== undefined && current !== null && !seen.has(current)) {
+        seen.add(current);
+        const message = describeSingleSyncLaneError(current);
+        if (message.length > 0) {
+            messages.push(message);
+        }
+        current = readErrorCause(current);
+    }
+    return messages.length > 0 ? messages.join(" Caused by: ") : String(error);
+}
+// Observational upload lanes never enter the pump, so their run is never
+// invoked; this satisfies the SyncLaneConfig contract without behavior.
+export function noopLaneRun() {
+    return Promise.resolve();
+}
+// Deliberately ignores activeRunToken (unlike the pump's hasRequestedLaneWork):
+// a watchdog-abandoned run is detached background work, and idle/pending-work
+// reporting must not block on a hung run that may never settle. Its late
+// settle still publishes a snapshot and re-pumps any queued re-request.
+export function hasPendingLaneWork(lanes) {
+    for (const lane of lanes) {
+        if (lane.requested || lane.running) {
+            return true;
+        }
+    }
+    return false;
+}
+export function publishSyncCoordinatorSnapshot(state) {
+    state.snapshot = createDomainSyncSnapshot({
+        hasPendingWork: !!state.pump || hasPendingLaneWork(state.lanes.values()),
+        lanes: state.lanes.values(),
+        pumpActive: !!state.pump,
+    });
+    for (const listener of [...state.listeners]) {
+        try {
+            listener();
+        }
+        catch {
+            // Keep one observer failure from blocking sync or later observers.
+        }
+    }
+}
+//# sourceMappingURL=coordinatorState.js.map

package/data/sync/coordinatorState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinatorState.js","sourceRoot":"","sources":["coordinatorState.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SyncLaneConfig } from \"./syncLaneConfig\";\nimport type {\n  DomainSyncSnapshot,\n  SyncLaneLastAction,\n  SyncLaneProgress,\n} from \"./syncTelemetry\";\nimport { createDomainSyncSnapshot } from \"./syncTelemetry\";\n\nexport interface SyncLaneState {\n  // Identity of the lane's live run, set for the duration of a run INCLUDING\n  // after a watchdog timeout abandons it. Selection skips lanes whose token is\n  // set, so a lane can never run concurrently with its own abandoned run; the\n  // late-settle continuation clears it (matching on identity) and re-pumps.\n  activeRunToken: object | null;\n  blobStorageKey: string | null;\n  config: SyncLaneConfig;\n  errorCount: number;\n  key: string;\n  lastAction: SyncLaneLastAction;\n  lastActionAt: string;\n  lastCompletedAt: string | null;\n  lastError: string | null;\n  lastFailedAt: string | null;\n  lastRequestedAt: string | null;\n  lastStartedAt: string | null;\n  notBeforeAtMs: number | null;\n  progress: SyncLaneProgress | null;\n  // Registered lanes are driven by the coordinator pump. Blob upload lanes\n  // are observational telemetry driven directly by the upload workflow.\n  pumpDriven: boolean;\n  registrationIndex: number;\n  requestCount: number;\n  requested: boolean;\n  runAbandoned: boolean;\n  runCount: number;\n  running: boolean;\n}\n\nexport interface DomainSyncCoordinatorState {\n  // Set by dispose(): the pump force-stops at its next loop check and no new\n  // pump can be scheduled, so a coordinator cannot run after its runtime/React\n  // tree unmounts.\n  disposed: boolean;\n  lanes: Map<string, SyncLaneState>;\n  listeners: Set<() => void>;\n  nextRegistrationIndex: number;\n  pump: Promise<void> | null;\n  snapshot: DomainSyncSnapshot;\n}\n\nexport const INITIAL_SYNC_LANE_RUN_STATE = {\n  activeRunToken: null,\n  runAbandoned: false,\n  runCount: 0,\n  running: false,\n} as const;\n\nfunction describeSingleSyncLaneError(error: unknown): string {\n  if (error instanceof Error) {\n    return error.message;\n  }\n  if (\n    typeof error === \"object\" &&\n    error !== null &&\n    \"message\" in error &&\n    typeof error.message === \"string\"\n  ) {\n    return error.message;\n  }\n\n  return String(error);\n}\n\nfunction readErrorCause(error: unknown): unknown {\n  if (typeof error !== \"object\" || error === null) {\n    return undefined;\n  }\n\n  return Reflect.get(error, \"cause\");\n}\n\nexport function describeSyncLaneError(error: unknown): string {\n  const messages: string[] = [];\n  const seen = new Set<unknown>();\n  let current: unknown = error;\n\n  while (current !== undefined && current !== null && !seen.has(current)) {\n    seen.add(current);\n    const message = describeSingleSyncLaneError(current);\n    if (message.length > 0) {\n      messages.push(message);\n    }\n    current = readErrorCause(current);\n  }\n\n  return messages.length > 0 ? messages.join(\" Caused by: \") : String(error);\n}\n\n// Observational upload lanes never enter the pump, so their run is never\n// invoked; this satisfies the SyncLaneConfig contract without behavior.\nexport function noopLaneRun(): Promise<void> {\n  return Promise.resolve();\n}\n\n// Deliberately ignores activeRunToken (unlike the pump's hasRequestedLaneWork):\n// a watchdog-abandoned run is detached background work, and idle/pending-work\n// reporting must not block on a hung run that may never settle. Its late\n// settle still publishes a snapshot and re-pumps any queued re-request.\nexport function hasPendingLaneWork(lanes: Iterable<SyncLaneState>): boolean {\n  for (const lane of lanes) {\n    if (lane.requested || lane.running) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexport function publishSyncCoordinatorSnapshot(\n  state: DomainSyncCoordinatorState,\n) {\n  state.snapshot = createDomainSyncSnapshot({\n    hasPendingWork: !!state.pump || hasPendingLaneWork(state.lanes.values()),\n    lanes: state.lanes.values(),\n    pumpActive: !!state.pump,\n  });\n  for (const listener of [...state.listeners]) {\n    try {\n      listener();\n    } catch {\n      // Keep one observer failure from blocking sync or later observers.\n    }\n  }\n}\n"]}

package/data/sync/databaseUnavailable.d.ts

@@ -0,0 +1,4 @@
+export declare class DatabaseUnavailableError extends Error {
+    constructor(message: string);
+}
+export declare function isDatabaseUnavailableError(error: unknown): boolean;

package/data/sync/databaseUnavailable.js

@@ -0,0 +1,47 @@
+// "The database was not there", as distinct from "the work was wrong".
+//
+// The runtime is released and rebooted underneath in-flight callers on every
+// identity switch, logout, and Explorer retry, so any long, network-bound
+// operation can lose its database at an await. Callers that treat a vanishing
+// database as a benign outcome — sync lanes, hydration, device-first projection
+// — discriminate on this module rather than on message text or a domain code.
+// Raised when database-backed work is asked for while the database is not ready.
+//
+// Throw this instead of reusing a domain error code: the predicate below
+// discriminates structurally on the type, so a genuine failure that happens to
+// share a code is never silently swallowed.
+export class DatabaseUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DatabaseUnavailableError";
+    }
+}
+// These come from the SQLite worker and its client, which raise plain Errors, so
+// they can only be matched on text. A worker crash belongs here too: the app's
+// database lifecycle observes it directly and reports it once, so the callers
+// whose requests it rejected treat it as the database going away rather than
+// each reporting their own copy.
+const DESTROYED_DATABASE_CLIENT_MESSAGES = [
+    "Database client is unavailable.",
+    "Database worker client has been destroyed.",
+    "Database worker failed.",
+    "DB has been closed.",
+];
+// True when an error means the database went away, not that the caller was
+// wrong. A lane that hits this did not fail — it lost its runtime mid-flight and
+// re-runs once the database is ready again.
+export function isDatabaseUnavailableError(error) {
+    let current = error;
+    while (current instanceof Error) {
+        if (current instanceof DatabaseUnavailableError) {
+            return true;
+        }
+        const errorMessage = current.message;
+        if (DESTROYED_DATABASE_CLIENT_MESSAGES.some((message) => errorMessage.includes(message))) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
+}
+//# sourceMappingURL=databaseUnavailable.js.map

package/data/sync/databaseUnavailable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"databaseUnavailable.js","sourceRoot":"","sources":["databaseUnavailable.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAE9E,iFAAiF;AACjF,EAAE;AACF,yEAAyE;AACzE,+EAA+E;AAC/E,4CAA4C;AAC5C,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACjD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AAED,iFAAiF;AACjF,+EAA+E;AAC/E,8EAA8E;AAC9E,6EAA6E;AAC7E,iCAAiC;AACjC,MAAM,kCAAkC,GAAG;IACzC,iCAAiC;IACjC,4CAA4C;IAC5C,yBAAyB;IACzB,qBAAqB;CACb,CAAC;AAEX,2EAA2E;AAC3E,iFAAiF;AACjF,4CAA4C;AAC5C,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,OAAO,OAAO,YAAY,KAAK,EAAE,CAAC;QAChC,IAAI,OAAO,YAAY,wBAAwB,EAAE,CAAC;YAChD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;QACrC,IACE,kCAAkC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAClD,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAC/B,EACD,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;IAC1B,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// \"The database was not there\", as distinct from \"the work was wrong\".\n//\n// The runtime is released and rebooted underneath in-flight callers on every\n// identity switch, logout, and Explorer retry, so any long, network-bound\n// operation can lose its database at an await. Callers that treat a vanishing\n// database as a benign outcome — sync lanes, hydration, device-first projection\n// — discriminate on this module rather than on message text or a domain code.\n\n// Raised when database-backed work is asked for while the database is not ready.\n//\n// Throw this instead of reusing a domain error code: the predicate below\n// discriminates structurally on the type, so a genuine failure that happens to\n// share a code is never silently swallowed.\nexport class DatabaseUnavailableError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"DatabaseUnavailableError\";\n  }\n}\n\n// These come from the SQLite worker and its client, which raise plain Errors, so\n// they can only be matched on text. A worker crash belongs here too: the app's\n// database lifecycle observes it directly and reports it once, so the callers\n// whose requests it rejected treat it as the database going away rather than\n// each reporting their own copy.\nconst DESTROYED_DATABASE_CLIENT_MESSAGES = [\n  \"Database client is unavailable.\",\n  \"Database worker client has been destroyed.\",\n  \"Database worker failed.\",\n  \"DB has been closed.\",\n] as const;\n\n// True when an error means the database went away, not that the caller was\n// wrong. A lane that hits this did not fail — it lost its runtime mid-flight and\n// re-runs once the database is ready again.\nexport function isDatabaseUnavailableError(error: unknown): boolean {\n  let current = error;\n\n  while (current instanceof Error) {\n    if (current instanceof DatabaseUnavailableError) {\n      return true;\n    }\n\n    const errorMessage = current.message;\n    if (\n      DESTROYED_DATABASE_CLIENT_MESSAGES.some((message) =>\n        errorMessage.includes(message),\n      )\n    ) {\n      return true;\n    }\n\n    current = current.cause;\n  }\n\n  return false;\n}\n"]}

package/data/sync/documentSyncOutgoingBatch.d.ts

@@ -0,0 +1,17 @@
+import type { DocumentSyncRequest } from "../../internal/validators/request/index.js";
+interface DocumentSyncPendingUpdate {
+    readonly updateData: string;
+}
+interface DocumentSyncOutgoingBatchOptions {
+    readonly reservedDataCharacters?: number | undefined;
+    readonly reservedUpdateCount?: number | undefined;
+}
+export declare class DocumentSyncRequestLimitError extends Error {
+    readonly name = "DocumentSyncRequestLimitError";
+}
+export declare function isDocumentSyncRequestLimitError(error: unknown): error is DocumentSyncRequestLimitError;
+export declare function selectDocumentSyncOutgoingBatch<Update extends DocumentSyncPendingUpdate>(updates: readonly Update[], options?: DocumentSyncOutgoingBatchOptions): Update[];
+export declare function limitDocumentSyncRequestBytes(request: DocumentSyncRequest, options?: {
+    readonly requiredOutgoingUpdateId?: string | undefined;
+}): DocumentSyncRequest;
+export {};