statewire 0.13.1 → 0.15.0

package/src/client/session.ts

@@ -1,6 +1,9 @@
+import { applyDocumentOps } from "../wire/documents";
+import type { StatewireDocuments } from "../wire/documents";
 import { useContext, useEffect, useState } from "react";
-import { applyOps } from "../wire/ops";
+
 import type { StatewirePath } from "../wire/ops";
+import { MAX_COMMANDS_PER_FRAME } from "../wire/limits";
 import { TERMINAL } from "./connection";
 import type { StatewireCmd, StatewireSyn } from "./connection";
 import {
@@ -103,6 +106,7 @@ type Session = {
   frameFailures: number;
   pending: Pending[];
   canonical: unknown;
+  documents: StatewireDocuments.State;
   lastPublished: unknown;
   changed: StatewirePath[];
   source: Statewire.StateSource;
@@ -238,7 +242,7 @@ export const failedCommands = (
   s: Session,
 ): readonly StatewireClient.FailedCommand[] => s.record.failed ?? NO_FAILED;
 
-const retainFailed = (
+const retainFailedInner = (
   s: Session,
   entry: Pending,
   failure: StatewireClient.SendFailure,
@@ -260,6 +264,18 @@ const retainFailed = (
   s.notify();
 };
 
+const retainFailed = (
+  s: Session,
+  entry: Pending,
+  failure: StatewireClient.SendFailure,
+) => {
+  if (!s.shared) {
+    retainFailedInner(s, entry, failure);
+    return;
+  }
+  void transact(s, () => retainFailedInner(s, entry, failure));
+};
+
 const settleEntry = (
   s: Session,
   entry: Pending,
@@ -481,8 +497,9 @@ const handleCmds = (s: Session, cmds: StatewireCmd[]) => {
 };
 
 const ingestOps = (s: Session, ops: unknown[]) => {
-  const applied = applyOps(s.canonical, ops);
-  s.canonical = applied.state;
+  const applied = applyDocumentOps(s.documents, ops);
+  s.documents = applied;
+  s.canonical = applied.documents.get(0)?.value;
   s.changed.push(...applied.changedPaths);
 };
 
@@ -546,6 +563,7 @@ const handleHello = (
   if (syn.record !== undefined && syn.record !== "ephemeral") {
     protocolError(`unknown record: ${String(syn.record)}`);
   }
+  s.documents = { mode: null, documents: new Map() };
   ingestOps(s, ops);
   s.attach = "attached";
   s.attachEpoch += 1;
@@ -642,7 +660,7 @@ const handleDetach = (s: Session) => {
 };
 
 const handleFinish = (s: Session, { reason }: { reason: string }) => {
-  if (reason === "evicted" || reason === "error") return;
+  if (reason === "reconnect" || reason === "error") return;
   s.attach = "finished";
   settleAll(s, "gone");
   publish(s);
@@ -663,6 +681,7 @@ const buildLanes = (s: Session): Lanes | null => {
   const ctxEntries: CtxPending[] = [];
   for (const entry of s.ctxPending) {
     if (entry.posted) continue;
+    if (ctxEntries.length >= MAX_COMMANDS_PER_FRAME) break;
     if (ctxEntries.length > 0 && entry.seq !== ctxEntries.at(-1)!.seq + 1)
       break;
     ctxEntries.push(entry);
@@ -670,6 +689,7 @@ const buildLanes = (s: Session): Lanes | null => {
   const cmdEntries: Pending[] = [];
   for (const entry of s.pending) {
     if (entry.posted) continue;
+    if (cmdEntries.length >= MAX_COMMANDS_PER_FRAME) break;
     if (cmdEntries.length > 0 && entry.seq !== cmdEntries.at(-1)!.seq + 1)
       break;
     cmdEntries.push(entry);
@@ -713,7 +733,8 @@ const pump = async (s: Session) => {
       if (buildLanes(s) === null) return;
       if (s.attach !== "attached" || !transport) {
         if (
-          transport?.connection.status === "idle" ||
+          (transport?.connection.status === "disconnected" &&
+            transport.connection.reason === "idle") ||
           (transport?.parked && s.pending.length > 0)
         ) {
           transport.connection.reconnect();
@@ -861,9 +882,17 @@ const enqueue = (
     void pump(s);
     return;
   }
-  void transact(s, () =>
-    enqueueInner(s, command, params, resolve, reject),
-  ).then(() => {
+  void transact(s, () => {
+    if (!s.running) {
+      reject(new StatewireSendError({ fate: "aborted", cause: "unmount" }));
+      return;
+    }
+    if (isFinished(s)) {
+      reject(new StatewireSendError({ fate: "aborted", cause: "stream-gone" }));
+      return;
+    }
+    enqueueInner(s, command, params, resolve, reject);
+  }).then(() => {
     wake(s);
     void pump(s);
   });
@@ -927,18 +956,25 @@ const sendCommand = (
   return result;
 };
 
-const takeFailed = (
+const findFailed = (
   s: Session,
   entry: StatewireClient.FailedCommand,
-): StatewireClient.FailedCommand => {
-  const failed = s.record.failed ?? [];
-  const found = failed.find(
+): StatewireClient.FailedCommand | undefined =>
+  (s.record.failed ?? []).find(
     (f) =>
       f.seq === entry.seq && f.ts === entry.ts && f.command === entry.command,
   );
-  if (found === undefined) {
-    throw new Error(`statewire: unknown failed command "${entry.command}"`);
-  }
+
+const unknownFailed = (entry: StatewireClient.FailedCommand) =>
+  new Error(`statewire: unknown failed command "${entry.command}"`);
+
+const takeFailed = (
+  s: Session,
+  entry: StatewireClient.FailedCommand,
+): StatewireClient.FailedCommand => {
+  const failed = s.record.failed ?? [];
+  const found = findFailed(s, entry);
+  if (found === undefined) throw unknownFailed(entry);
   setRecord(s, { ...s.record, failed: failed.filter((f) => f !== found) });
   s.notify();
   return found;
@@ -948,7 +984,14 @@ export const discardFailed = (
   s: Session,
   entry: StatewireClient.FailedCommand,
 ): void => {
-  takeFailed(s, entry);
+  if (!s.shared) {
+    takeFailed(s, entry);
+    return;
+  }
+  if (findFailed(s, entry) === undefined) throw unknownFailed(entry);
+  void transact(s, () => {
+    if (findFailed(s, entry) !== undefined) takeFailed(s, entry);
+  });
 };
 
 export const retryFailed = (
@@ -961,23 +1004,52 @@ export const retryFailed = (
   if (isFinished(s)) {
     return rejectedSend({ fate: "aborted", cause: "stream-gone" });
   }
-  const found = takeFailed(s, entry);
+  const found = findFailed(s, entry);
+  if (found === undefined) throw unknownFailed(entry);
   const params =
     found.meta === undefined
       ? found.params
       : (reviveValue([...found.params], found.meta) as unknown[]);
   const result = new Promise<unknown>((resolve, reject) => {
-    enqueue(
-      s,
-      {
-        method: found.command,
-        params: [...found.params],
-        ...(found.meta !== undefined && { meta: found.meta }),
-      },
-      params,
-      resolve,
-      reject,
-    );
+    const retry = () => {
+      if (!s.running) {
+        reject(new StatewireSendError({ fate: "aborted", cause: "unmount" }));
+        return;
+      }
+      if (isFinished(s)) {
+        reject(
+          new StatewireSendError({ fate: "aborted", cause: "stream-gone" }),
+        );
+        return;
+      }
+      const current = findFailed(s, entry);
+      if (current === undefined) {
+        reject(unknownFailed(entry));
+        return;
+      }
+      takeFailed(s, current);
+      enqueueInner(
+        s,
+        {
+          method: current.command,
+          params: [...current.params],
+          ...(current.meta !== undefined && { meta: current.meta }),
+        },
+        params,
+        resolve,
+        reject,
+      );
+    };
+    if (!s.shared) {
+      retry();
+      wake(s);
+      void pump(s);
+      return;
+    }
+    void transact(s, retry).then(() => {
+      wake(s);
+      void pump(s);
+    }, reject);
   });
   result.catch(() => {});
   return result;
@@ -1009,7 +1081,10 @@ const setContext = (s: Session, value: Record<string, unknown>): void => {
     void pump(s);
     return;
   }
-  void transact(s, mint).then(() => {
+  void transact(s, () => {
+    if (!s.running || isFinished(s)) return;
+    mint();
+  }).then(() => {
     wake(s);
     void pump(s);
   });
@@ -1080,6 +1155,7 @@ export const useStatewireSession = (
       frameFailures: 0,
       pending: [],
       canonical: undefined,
+      documents: { mode: null, documents: new Map() },
       lastPublished: undefined,
       changed: [],
       source: {

package/src/host/adapter.ts

@@ -1,3 +1,4 @@
+import { CLIENT_ID_RE } from "./socket";
 import type { StatewireHostInternal } from "../host-internal";
 
 export const CLIENT_QUERY_PARAM = "client";
@@ -20,14 +21,21 @@ export const clientIdFromUrl = (url: string | null | undefined): string => {
       `statewire: url is missing the "${CLIENT_QUERY_PARAM}" query parameter`,
     );
   }
+  if (!CLIENT_ID_RE.test(clientId))
+    throw new Error("statewire: invalid client id");
   return clientId;
 };
 
 export const textFrameOrClose = (
-  socket: Pick<StatewireHostInternal.Socket, "close">,
+  socket: Pick<StatewireHostInternal.Socket, "send" | "close">,
   data: unknown,
 ): string | null => {
   if (typeof data === "string") return data;
-  socket.close(1008, "text frames only");
+  socket.send(
+    JSON.stringify({
+      fin: { reason: "protocol-error", message: "malformed frame" },
+    }),
+  );
+  socket.close(1008, "malformed frame");
   return null;
 };

package/src/host/host.ts

@@ -136,6 +136,7 @@ export type CommandsHost = {
   submit?: (call: CommandsSubmission) => Promise<unknown>;
   /** Registered command names, read live. */
   methods?: () => string[];
+  abort?: () => void;
 };
 
 const commandsHosts = new WeakMap<object, CommandsHost>();
@@ -158,12 +159,15 @@ type QueuedCall = {
 
 type ActiveInvocation = CommandsInvocation & {
   applied: boolean;
+  controller: AbortController;
+  settled: boolean;
   origin?: CommandsSubmission;
 };
 
 type CommandsCell = {
   handlers: Record<string, (...args: never[]) => unknown> | null;
   queue: QueuedCall[];
+  active: Map<ActiveInvocation, QueuedCall>;
   running: boolean;
   listener: CommandsListener | null;
   seq: number;
@@ -178,6 +182,7 @@ const LOCAL_CALLER: StatewireHost.Caller = Object.freeze({
   get clientId(): string {
     throw new Error("statewire: in-process dispatch has no client id");
   },
+  auth: undefined,
   context: null,
   isConnected: true,
 });
@@ -202,6 +207,7 @@ const applyInvocation = (cell: CommandsCell, inv: ActiveInvocation) => {
   if (inv.applied) return;
   inv.applied = true;
   cell.listener?.onApplied(inv);
+  cell.listener?.onCovered?.(inv);
   inv.origin?.onApplied?.();
 };
 
@@ -211,6 +217,9 @@ const settleInvocation = (
   call: QueuedCall,
   settled: Settled,
 ) => {
+  if (inv.settled) return;
+  inv.settled = true;
+  cell.active.delete(inv);
   applyInvocation(cell, inv);
   if (settled.type === "resolved") {
     const outcome: CommandsOutcome =
@@ -229,13 +238,40 @@ const settleInvocation = (
   }
 };
 
+const abortInvocations = (cell: CommandsCell) => {
+  for (const [inv, call] of cell.active) {
+    inv.settled = true;
+    inv.controller.abort();
+    const error = new StatewireSendError({ fate: "crashed", cause: "server" });
+    const outcome: CommandsOutcome = { type: "rejected", error };
+    cell.listener?.onSettle(inv, outcome);
+    inv.origin?.onSettle?.(outcome);
+    call.reject(error);
+  }
+  cell.active.clear();
+};
+
 const isThenable = (value: unknown): value is PromiseLike<unknown> =>
   typeof value === "object" &&
   value !== null &&
   typeof (value as { then?: unknown }).then === "function";
 
+// A command is an own, enumerable, function-valued property — exactly what
+// `Object.keys` shows, so dispatch, `statewire/commands`, and the reserved-
+// namespace guard share one view; prototype-chain names are not commands.
+const handlerOf = (
+  handlers: Record<string, (...args: never[]) => unknown>,
+  method: string,
+): ((...args: never[]) => unknown) | undefined => {
+  if (!Object.prototype.propertyIsEnumerable.call(handlers, method)) {
+    return undefined;
+  }
+  const handler = handlers[method];
+  return typeof handler === "function" ? handler : undefined;
+};
+
 const dispatch = (cell: CommandsCell, call: QueuedCall) => {
-  const handler = cell.handlers![call.method];
+  const handler = handlerOf(cell.handlers!, call.method);
   if (handler === undefined) {
     const error = new StatewireSendError({
       fate: "rejected",
@@ -252,17 +288,22 @@ const dispatch = (cell: CommandsCell, call: QueuedCall) => {
     ts: call.ts,
     seq: ++cell.seq,
     applied: false,
+    controller: new AbortController(),
+    settled: false,
     ...(call.origin !== undefined && { origin: call.origin }),
     ...(call.origin?.clientId !== undefined && {
       clientId: call.origin.clientId,
     }),
   };
+  cell.active.set(inv, call);
   cell.listener?.onStart(inv);
   cell.listener?.onPosted?.(inv);
-  cell.listener?.onCovered?.(inv);
   const ctx: StatewireHost.Ctx = {
     caller: call.origin?.caller ?? LOCAL_CALLER,
-    applied: () => applyInvocation(cell, inv),
+    signal: inv.controller.signal,
+    applied: () => {
+      if (!inv.settled) applyInvocation(cell, inv);
+    },
   };
   try {
     const value = (
@@ -332,6 +373,7 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
     const cell: CommandsCell = {
       handlers: null,
       queue: [],
+      active: new Map(),
       running: false,
       listener: null,
       seq: 0,
@@ -358,10 +400,17 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
         }),
     );
     commandsHosts.set(proxy, {
+      abort: () => abortInvocations(cell),
       setListener: (listener) => {
         cell.listener = listener;
       },
-      methods: () => (cell.handlers ? Object.keys(cell.handlers) : []),
+      methods: () => {
+        const handlers = cell.handlers;
+        if (!handlers) return [];
+        return Object.keys(handlers).filter(
+          (method) => handlerOf(handlers, method) !== undefined,
+        );
+      },
       submit: (origin) =>
         new Promise((resolve, reject) => {
           if (cell.unmounted) {
@@ -394,6 +443,7 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
       }
       queueMicrotask(() => {
         if (!cell.unmounted) return;
+        abortInvocations(cell);
         const queued = cell.queue;
         cell.queue = [];
         for (const call of queued) {