statewire 0.8.0 → 0.9.0

package/src/client/sessionStore.ts

@@ -1,6 +1,7 @@
 export type StatewireSessionRecord = {
   clientId: string;
   nextSeq: number;
+  ctxNextSeq: number;
 };
 
 export type StatewireSessionStore = {

package/src/client/timing.ts

@@ -6,9 +6,3 @@ export const timing = {
 
 export const backoff = (attempt: number) =>
   Math.min(timing.backoffBaseMs * 2 ** (attempt - 1), timing.backoffMaxMs);
-
-export const retryDelay = (error: unknown, attempt: number): number => {
-  const retryAfterMs = (error as { retryAfterMs?: unknown } | undefined)
-    ?.retryAfterMs;
-  return typeof retryAfterMs === "number" ? retryAfterMs : backoff(attempt);
-};

package/src/host/draft.ts

@@ -4,11 +4,9 @@ import { sanitizeValue } from "../wire/ops";
 import { isUnsafeKey } from "../util/statePath";
 import { sharedDraftTraps } from "../util/draftTraps";
 
-export type ServerOp = Exclude<Statewire.Op, { op: "event" }>;
-
 export type DraftHost = {
   snapshot: () => unknown;
-  record: (op: ServerOp, changedPath: StatewirePath) => void;
+  record: (op: Statewire.Op, changedPath: StatewirePath) => void;
 };
 
 export type StateDraft<T> = {

package/src/host/host.ts

@@ -4,7 +4,7 @@ import type { StatewirePath } from "../wire/ops";
 import { StatewireReject } from "./engine";
 import { createStateDraft } from "./draft";
 import { createMethodProxy } from "../util/methodProxy";
-import type { ServerOp, StateDraft } from "./draft";
+import type { StateDraft } from "./draft";
 import { StatewireSendError } from "../types";
 import type { Statewire } from "../types";
 import type { StatewireHost } from "../host";
@@ -25,7 +25,7 @@ type StateCell = {
   current: unknown;
   draft: StateDraft<object> | null;
   changed: StatewirePath[];
-  onOp: ((op: ServerOp) => void) | null;
+  onOp: ((op: Statewire.Op) => void) | null;
   onChange: (() => void) | null;
   ctl: StatewireHost.StateCtl;
   host: StatewireHost.StateHost;
@@ -51,15 +51,10 @@ export const useStatewireState = <TState>(
       ctl: {
         apply: (ops) => {
           const result = applyOps(commit(), ops);
-          if (result.events.length > 0) {
-            throw new Error(
-              "statewire: event ops do not apply to state — route them to emit",
-            );
-          }
           c.current = result.state;
           c.draft?.invalidate();
           c.changed.push(...result.changedPaths);
-          if (c.onOp) for (const op of ops) c.onOp(op as ServerOp);
+          if (c.onOp) for (const op of ops) c.onOp(op);
           c.bump();
           c.onChange?.();
         },
@@ -121,7 +116,7 @@ export type CommandsOutcome =
 export type CommandsListener = {
   onStart: (inv: CommandsInvocation) => void;
   onPosted?: (inv: CommandsInvocation) => void;
-  onAck: (inv: CommandsInvocation) => void;
+  onApplied: (inv: CommandsInvocation) => void;
   /** Canonical state now covers the invocation's effect — drop any overlay. */
   onCovered?: (inv: CommandsInvocation) => void;
   onSettle: (inv: CommandsInvocation, outcome: CommandsOutcome) => void;
@@ -132,13 +127,15 @@ export type CommandsSubmission = {
   params: readonly unknown[];
   clientId?: string;
   caller?: StatewireHost.Caller;
-  onAck?: () => void;
+  onApplied?: () => void;
   onSettle?: (outcome: CommandsOutcome) => void;
 };
 
 export type CommandsHost = {
   setListener: (listener: CommandsListener | null) => void;
   submit?: (call: CommandsSubmission) => Promise<unknown>;
+  /** Registered command names, read live. */
+  methods?: () => string[];
 };
 
 const commandsHosts = new WeakMap<object, CommandsHost>();
@@ -160,7 +157,7 @@ type QueuedCall = {
 };
 
 type ActiveInvocation = CommandsInvocation & {
-  acked: boolean;
+  applied: boolean;
   origin?: CommandsSubmission;
 };
 
@@ -188,19 +185,24 @@ const LOCAL_CALLER: StatewireHost.Caller = Object.freeze({
 const toSendError = (error: unknown): StatewireSendError =>
   error instanceof StatewireSendError
     ? error
-    : new StatewireSendError({
-        fate: "rejected",
-        cause: "server",
-        message: error instanceof Error ? error.message : String(error),
-        ...(error instanceof StatewireReject &&
-          error.payload !== undefined && { payload: error.payload }),
-      });
-
-const ackInvocation = (cell: CommandsCell, inv: ActiveInvocation) => {
-  if (inv.acked) return;
-  inv.acked = true;
-  cell.listener?.onAck(inv);
-  inv.origin?.onAck?.();
+    : error instanceof StatewireReject
+      ? new StatewireSendError({
+          fate: "rejected",
+          cause: "server",
+          message: error.message,
+          ...(error.payload !== undefined && { payload: error.payload }),
+        })
+      : new StatewireSendError({
+          fate: "failed",
+          cause: "server",
+          message: error instanceof Error ? error.message : String(error),
+        });
+
+const applyInvocation = (cell: CommandsCell, inv: ActiveInvocation) => {
+  if (inv.applied) return;
+  inv.applied = true;
+  cell.listener?.onApplied(inv);
+  inv.origin?.onApplied?.();
 };
 
 const settleInvocation = (
@@ -209,7 +211,7 @@ const settleInvocation = (
   call: QueuedCall,
   settled: Settled,
 ) => {
-  ackInvocation(cell, inv);
+  applyInvocation(cell, inv);
   if (settled.type === "resolved") {
     const outcome: CommandsOutcome =
       settled.value === undefined
@@ -236,8 +238,9 @@ const dispatch = (cell: CommandsCell, call: QueuedCall) => {
   const handler = cell.handlers![call.method];
   if (handler === undefined) {
     const error = new StatewireSendError({
-      fate: "unknown-command",
+      fate: "rejected",
       cause: "server",
+      code: "unknown-command",
     });
     call.origin?.onSettle?.({ type: "rejected", error });
     call.reject(error);
@@ -248,7 +251,7 @@ const dispatch = (cell: CommandsCell, call: QueuedCall) => {
     params: call.params,
     ts: call.ts,
     seq: ++cell.seq,
-    acked: false,
+    applied: false,
     ...(call.origin !== undefined && { origin: call.origin }),
     ...(call.origin?.clientId !== undefined && {
       clientId: call.origin.clientId,
@@ -259,7 +262,7 @@ const dispatch = (cell: CommandsCell, call: QueuedCall) => {
   cell.listener?.onCovered?.(inv);
   const ctx: StatewireHost.Ctx = {
     caller: call.origin?.caller ?? LOCAL_CALLER,
-    ack: () => ackInvocation(cell, inv),
+    applied: () => applyInvocation(cell, inv),
   };
   try {
     const value = (
@@ -358,6 +361,7 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
       setListener: (listener) => {
         cell.listener = listener;
       },
+      methods: () => (cell.handlers ? Object.keys(cell.handlers) : []),
       submit: (origin) =>
         new Promise((resolve, reject) => {
           if (cell.unmounted) {
@@ -400,39 +404,18 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
   }, [built]);
 
   useEffect(() => {
+    if (commands) {
+      for (const method of Object.keys(commands)) {
+        if (method.startsWith("statewire/")) {
+          throw new Error(
+            `statewire: cannot register "${method}": the "statewire/" method namespace is reserved`,
+          );
+        }
+      }
+    }
     built.cell.handlers = commands || null;
     pump(built.cell);
   });
 
   return built.proxy;
 };
-
-// ─── emit ───────────────────────────────────────────────
-
-export type EmitHost = {
-  setSink: (sink: ((event: unknown) => void) | null) => void;
-};
-
-const emitHosts = new WeakMap<object, EmitHost>();
-
-export const getEmitHost = (emit: object | undefined): EmitHost | undefined =>
-  emit && emitHosts.get(emit);
-
-export const useStatewireEmit = <TEvent>(): ((event: TEvent) => void) => {
-  const [built] = useState(() => {
-    const cell = { sink: null as ((event: unknown) => void) | null };
-    const emit = (event: TEvent) => {
-      if (!cell.sink) {
-        throw new Error("statewire: emit before a host bound the event sink");
-      }
-      cell.sink(sanitizeValue(event));
-    };
-    emitHosts.set(emit, {
-      setSink: (sink) => {
-        cell.sink = sink;
-      },
-    });
-    return emit;
-  });
-  return built;
-};