statewire 0.23.0 → 0.24.1

package/src/client/core.ts

@@ -16,7 +16,6 @@ export const CONNECTED_CONNECTION: StatewireClient.Connection = {
   reconnect: () => {},
 };
 
-const NO_FAILED: readonly StatewireClient.FailedCommand[] = [];
 const NO_OUTBOX: readonly StatewireClient.OutboxEntry[] = [];
 
 const failureOf = (error: unknown): StatewireClient.SendFailure =>
@@ -28,13 +27,17 @@ const failureOf = (error: unknown): StatewireClient.SendFailure =>
         message: error instanceof Error ? error.message : String(error),
       };
 
-type Overlay = { inv: CommandsInvocation; dropped: boolean };
+type Overlay = { inv: CommandsInvocation };
 
 type Core = {
   getOptions: () => StatewireClient.Options<any, any>;
   value: Statewire<unknown> | null;
   source: Statewire.StateSource | null;
   overlays: Overlay[];
+  overlayOutbox: readonly StatewireClient.OutboxEntry[];
+  /** Folds whose reducer threw. */
+  dropped: WeakSet<object>;
+  droppedIds: Set<string>;
   updates: Statewire.CommandUpdate[];
   pendingChanged: StatewirePath[];
   canonical: unknown;
@@ -45,7 +48,6 @@ type Core = {
   notifiedConnection: StatewireClient.Connection | null;
   notifiedError: StatewireClient.ConnectionError | undefined;
   notifiedBusy: boolean;
-  notifiedFailed: readonly StatewireClient.FailedCommand[];
   notifiedOutbox: readonly StatewireClient.OutboxEntry[];
   stale: boolean;
   everAttached: boolean;
@@ -58,7 +60,6 @@ type Core = {
   commandsListener: CommandsListener;
   getState: () => unknown;
   getBusy: () => boolean;
-  getFailed: () => readonly StatewireClient.FailedCommand[];
   getOutbox: () => readonly StatewireClient.OutboxEntry[];
   rematerialize: () => void;
   commands: Statewire.CommandsProxy<any>;
@@ -100,15 +101,6 @@ const drainCanonical = (c: Core) => {
   }
 };
 
-const dropCovered = (c: Core) => {
-  const { failureCovered } = c.getOptions();
-  const failures = c.value?.failures;
-  if (!failureCovered || !failures || c.canonical === undefined) return;
-  for (const entry of failures.list()) {
-    if (failureCovered(c.canonical as never, entry)) failures.discard(entry);
-  }
-};
-
 const recompute = (c: Core) => {
   if (!c.value) return;
   const { optimistic, materialize, materializeKey } = c.getOptions();
@@ -117,44 +109,82 @@ const recompute = (c: Core) => {
   c.stale = false;
   const prevCanonical = c.canonical;
   drainCanonical(c);
-  if (c.canonical !== prevCanonical) dropCovered(c);
+  const outbox = c.value.outbox?.list() ?? NO_OUTBOX;
+  if (outbox !== c.overlayOutbox) {
+    c.overlayOutbox = outbox;
+    c.overlaysDirty = true;
+  }
   if (c.canonical === prevCanonical && !c.overlaysDirty && !rekeyed) return;
   c.overlaysDirty = false;
   c.materializeKey = materializeKey;
   let next = c.canonical;
   let paths: readonly StatewirePath[] = [];
   if (optimistic && c.canonical !== undefined) {
-    for (const overlay of c.overlays) {
-      if (overlay.dropped) continue;
-      const { inv } = overlay;
-      if (
-        inv.protocol !== undefined &&
-        inv.protocol !== (c.getOptions().protocol ?? "default")
-      )
+    const protocol = c.getOptions().protocol ?? "default";
+    const unsent = outbox.filter((e) => e.state !== "sending");
+    const unsentIds = new Set(unsent.map((e) => e.id));
+    const clientId = c.value.outbox?.clientId();
+    // In queue order: the commands on their way, then the outbox's queued
+    // and held entries across sharers.
+    const folds: {
+      key: object;
+      id: string | undefined;
+      method: string;
+      params: readonly unknown[];
+      ctx: StatewireClient.OptimisticContext;
+    }[] = [
+      ...c.overlays
+        .filter(
+          ({ inv }) => inv.protocol === undefined || inv.protocol === protocol,
+        )
+        .filter(({ inv }) => inv.id === undefined || !unsentIds.has(inv.id))
+        .map(({ inv }) => ({
+          key: inv,
+          id: inv.id,
+          method: inv.method,
+          params: inv.params,
+          ctx: {
+            ts: inv.ts,
+            ...(inv.seq !== undefined && { seq: inv.seq }),
+            ...(inv.clientId !== undefined && { clientId: inv.clientId }),
+            state:
+              inv.seq !== undefined ? "sending" : inv.held ? "held" : "queued",
+            localMeta: inv.localMeta,
+          } satisfies StatewireClient.OptimisticContext,
+        })),
+      ...unsent
+        .filter((e) => e.protocol === protocol)
+        .map((e) => ({
+          key: e,
+          id: e.id,
+          method: e.command.method,
+          params: e.command.params,
+          ctx: {
+            ts: e.ts,
+            ...(clientId !== undefined && { clientId }),
+            state: e.state,
+            localMeta: e.localMeta,
+          } satisfies StatewireClient.OptimisticContext,
+        })),
+    ];
+    for (const fold of folds) {
+      if (c.dropped.has(fold.key) || (fold.id && c.droppedIds.has(fold.id)))
         continue;
-      const ctx: StatewireClient.OptimisticContext = {
-        ts: inv.ts,
-        ...(inv.seq !== undefined && { seq: inv.seq }),
-        ...(inv.clientId !== undefined && { clientId: inv.clientId }),
-        held:
-          inv.seq === undefined && inv.hold !== undefined
-            ? { meta: inv.hold.meta }
-            : null,
-      };
       try {
         const recorded = recordMutations(next, (draft) =>
           optimistic(
             draft as never,
-            { method: inv.method, params: inv.params } as Statewire.Command,
-            ctx,
+            { method: fold.method, params: fold.params } as Statewire.Command,
+            fold.ctx,
           ),
         );
         next = recorded.state;
         paths = [...paths, ...recorded.changedPaths];
       } catch (error) {
-        overlay.dropped = true;
+        c.dropped.add(fold.key);
+        if (fold.id) c.droppedIds.add(fold.id);
         console.error(
-          `statewire: optimistic reducer threw for "${inv.method}"; dropping its optimistic update`,
+          `statewire: optimistic reducer threw for "${fold.method}"; dropping its optimistic update`,
           error,
         );
       }
@@ -224,18 +254,8 @@ const flush = (c: Core, scheduled = false) => {
     const busy = c.getBusy();
     const busyChanged = busy !== c.notifiedBusy;
     c.notifiedBusy = busy;
-    // The failed snapshot advances only on the scheduled pass: settles land
+    // The outbox snapshot advances only on the scheduled pass: settles land
     // mid-unmount, where a changed snapshot re-renders the unmounting tree.
-    const failed = c.value?.failures?.list() ?? NO_FAILED;
-    let failedChanged = false;
-    if (failed !== c.notifiedFailed) {
-      if (scheduled) {
-        c.notifiedFailed = failed;
-        failedChanged = true;
-      } else {
-        schedule(c);
-      }
-    }
     const outbox = c.value?.outbox?.list() ?? NO_OUTBOX;
     let outboxChanged = false;
     if (outbox !== c.notifiedOutbox) {
@@ -246,13 +266,7 @@ const flush = (c: Core, scheduled = false) => {
         schedule(c);
       }
     }
-    if (
-      stateChanged ||
-      connectionChanged ||
-      busyChanged ||
-      failedChanged ||
-      outboxChanged
-    ) {
+    if (stateChanged || connectionChanged || busyChanged || outboxChanged) {
       for (const listener of [...c.listeners]) listener();
     }
   } finally {
@@ -274,6 +288,7 @@ const note = (
     params: inv.params as never[],
     ...(inv.seq !== undefined && { seq: inv.seq }),
     status,
+    ...(inv.localMeta !== undefined && { localMeta: inv.localMeta }),
     ...extra,
   });
   schedule(c);
@@ -329,6 +344,9 @@ export const useStatewireCore = (
       value: null,
       source: null,
       overlays: [],
+      overlayOutbox: NO_OUTBOX,
+      dropped: new WeakSet(),
+      droppedIds: new Set(),
       updates: [],
       pendingChanged: [],
       canonical: undefined,
@@ -339,7 +357,6 @@ export const useStatewireCore = (
       notifiedConnection: null,
       notifiedError: undefined,
       notifiedBusy: true,
-      notifiedFailed: NO_FAILED,
       notifiedOutbox: NO_OUTBOX,
       stale: false,
       everAttached: false,
@@ -354,7 +371,7 @@ export const useStatewireCore = (
       }),
       commandsListener: {
         onStart: (inv) => {
-          c.overlays.push({ inv, dropped: false });
+          c.overlays.push({ inv });
           c.overlaysDirty = true;
           markStale(c);
           note(c, inv, "queued");
@@ -373,15 +390,16 @@ export const useStatewireCore = (
           c.overlaysDirty = true;
           markStale(c);
         },
-        onSettle: (inv, outcome) => {
-          note(
-            c,
-            inv,
-            "settled",
-            outcome.type === "accepted"
-              ? { result: outcome.payload }
-              : { failure: failureOf(outcome.error) },
-          );
+        onSettle: (inv, outcome, durable) => {
+          if (!durable)
+            note(
+              c,
+              inv,
+              "settled",
+              outcome.type === "accepted"
+                ? { result: outcome.payload }
+                : { failure: failureOf(outcome.error) },
+            );
           flush(c);
         },
       },
@@ -390,7 +408,6 @@ export const useStatewireCore = (
         return c.published;
       },
       getBusy: () => c.value?.isBusy ?? true,
-      getFailed: () => c.notifiedFailed,
       getOutbox: () => c.notifiedOutbox,
       rematerialize: () => flush(c),
       commands: createMethodProxy<Statewire.CommandsProxy<any>>(