statewire 0.18.1 → 0.18.2

package/src/client/session.ts

@@ -117,7 +117,7 @@ type Session = {
   idle: boolean;
   onSessionLost: StatewireClient.OnSessionLost | undefined;
   onDone: (() => void) | undefined;
-  ctxOps: unknown[] | undefined;
+  ctxNextSeq: number;
   ctxPending: CtxPending[];
   lanesOnAttach: boolean;
   attachLaneSeqs: readonly [ReadonlySet<number>, ReadonlySet<number>];
@@ -244,20 +244,6 @@ const transact = (s: Session, fn: () => void): Promise<void> => {
         adoptReset(s, stored);
       } else if (stored !== null) {
         s.record = stored;
-        if (stored.context !== undefined) {
-          const posted = new Set(
-            s.ctxPending.filter((p) => p.posted).map((p) => p.seq),
-          );
-          s.ctxOps = stored.context.ops;
-          s.contextDocuments = applyDocumentOps(
-            { mode: "mounted", documents: new Map() },
-            stored.context.ops,
-          );
-          s.ctxPending = stored.context.pending.map((p) => ({
-            ...p,
-            posted: posted.has(p.seq),
-          }));
-        }
       }
       fn();
       const persistence = s.store.flush?.();
@@ -388,14 +374,6 @@ const settleAll = (s: Session, detach: "unmount" | "gone") => {
   }
 };
 
-const restateContext = (s: Session) => {
-  s.ctxPending = [];
-  if (s.ctxOps === undefined) return;
-  const seq = s.record.ctxNextSeq;
-  setRecord(s, { ...s.record, ctxNextSeq: seq + 1 });
-  s.ctxPending.push({ seq, ops: s.ctxOps, posted: false });
-};
-
 const settleLost = (s: Session, entries: Pending[]) => {
   for (const entry of entries) {
     s.lifecycle?.onCovered?.(entry.inv);
@@ -432,16 +410,13 @@ const rebaseRecord = (s: Session, adopt: () => void) => {
     s.lifecycle?.onCovered?.(old.inv);
     enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject);
   }
-  restateContext(s);
   publish(s);
   wake(s);
   void pump(s);
 };
 
 const resetRecord = (s: Session, clientId: string) =>
-  rebaseRecord(s, () =>
-    setRecord(s, { clientId, nextSeq: 1, ctxNextSeq: 1, commands: [] }),
-  );
+  rebaseRecord(s, () => setRecord(s, { clientId, nextSeq: 1, commands: [] }));
 
 // Another sharer replaced the record's identity: their reset settles our
 // attempted history and our survivors re-stamp on the stored clocks.
@@ -605,54 +580,11 @@ const publishIngested = (s: Session) => {
   wake(s);
 };
 
-// A hello's cmd watermark may understate a durable record (cold host, tray
-// unloaded): held seqs resend as-is and the frame's answer arbitrates —
-// absorption where the record survived, a gap refusal where it did not.
-const snapCtxClock = (s: Session, ctxWm: number) => {
-  if (s.record.context?.recover === "version-1") {
-    const document = s.contextDocuments.documents.get(0);
-    if (s.contextDocuments.documents.size !== 1 || !document?.main)
-      throw new Error(
-        "statewire: version-1 context recovery requires one main document at doc 0",
-      );
-    const encoded = encodeDocument(document.value);
-    const ops = [
-      {
-        ...(ctxWm === 0
-          ? { op: "mount", protocol: document.protocol, main: true }
-          : { op: "replace", path: [] }),
-        ...encoded,
-      },
-    ];
-    s.ctxPending = [{ seq: ctxWm + 1, ops, posted: false }];
-    setRecord(s, {
-      ...s.record,
-      ctxNextSeq: ctxWm + 2,
-      context: {
-        ops: contextSnapshot(s.contextDocuments),
-        pending: s.ctxPending,
-      },
-    });
-    return;
-  }
-  const ctxAligned =
-    s.ctxPending.every((c, i) => c.seq === ctxWm + 1 + i) &&
-    s.record.ctxNextSeq === ctxWm + s.ctxPending.length + 1;
-  if (!ctxAligned) {
-    if (ctxWm > 0)
-      throw new Error(
-        "statewire: context history is missing; use a new client id",
-      );
-    setRecord(s, { ...s.record, ctxNextSeq: ctxWm + 1 });
-    restateContext(s);
-  }
-};
-
-// The refusal's watermarks are exact: every held statement above them was
-// never admitted by the live record, and the first unposted seq being beyond
+// The refusal's watermark is exact: every held statement above it was never
+// admitted by the live record, and the first unposted seq being beyond
 // watermark+1 proves the record that admitted the missing prefix is gone —
-// its history settles lost and the lane clocks restart at the watermarks.
-const sessionLostInner = (s: Session, seqWm: number, ctxWm: number) => {
+// its history settles lost and the cmd clock restarts at the watermark.
+const sessionLostInner = (s: Session, seqWm: number) => {
   const held = [...s.pending];
   settleLost(s, held);
   s.pending = [];
@@ -660,11 +592,9 @@ const sessionLostInner = (s: Session, seqWm: number, ctxWm: number) => {
   setRecord(s, {
     clientId: s.record.clientId,
     nextSeq: seqWm + 1,
-    ctxNextSeq: s.record.ctxNextSeq,
     commands: [],
     ...(s.record.failed !== undefined && { failed: s.record.failed }),
   });
-  snapCtxClock(s, ctxWm);
   if (
     held.length > 0 &&
     s.onSessionLost?.(held.map((p) => p.inv)) === "requeue"
@@ -690,6 +620,9 @@ const handleHello = (
   if (syn.record !== undefined && syn.record !== "ephemeral") {
     protocolError(`unknown record: ${String(syn.record)}`);
   }
+  if (syn.ctxSeq !== undefined && syn.ctxSeq !== 0) {
+    protocolError(`hello ctxSeq must be 0, got ${syn.ctxSeq}`);
+  }
   s.selection =
     syn.version === undefined || syn.protocols === undefined
       ? undefined
@@ -712,11 +645,7 @@ const handleHello = (
     for (const entry of s.pending) {
       entry.posted = attachCmd.has(entry.seq);
     }
-    const ctxWatermark = syn.ctxSeq ?? 0;
-    s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxWatermark);
     for (const c of s.ctxPending) c.posted = attachCtx.has(c.seq);
-    snapCtxClock(s, ctxWatermark);
-    if (s.ctxOps !== undefined) persistContext(s);
     syncBacklogInner(s);
     s.sessionKnown = true;
   };
@@ -754,7 +683,12 @@ const handleRefusal = (s: Session, syn: StatewireSyn) => {
   if (typeof ctxSeq === "number") {
     s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxSeq);
     for (const c of s.ctxPending) c.posted = false;
-    if (s.ctxOps !== undefined) persistContext(s);
+    const firstCtx = s.ctxPending.find((c) => !c.posted);
+    if (firstCtx !== undefined && firstCtx.seq > ctxSeq + 1) {
+      protocolError(
+        `ctx gap on a live attach: seq ${firstCtx.seq} after watermark ${ctxSeq}`,
+      );
+    }
   }
   if (typeof syn.retry === "number") {
     s.resumeAt = Date.now() + syn.retry;
@@ -763,22 +697,14 @@ const handleRefusal = (s: Session, syn: StatewireSyn) => {
     return;
   }
   const firstCmd = s.pending.find((p) => !p.posted);
-  const firstCtx = s.ctxPending.find((c) => !c.posted);
   const cmdGap =
     typeof seq === "number" &&
     firstCmd !== undefined &&
     firstCmd.seq > Math.max(seq, s.durableSeq) + 1;
-  const ctxGap =
-    typeof ctxSeq === "number" &&
-    firstCtx !== undefined &&
-    firstCtx.seq > ctxSeq + 1;
-  if (cmdGap || ctxGap) {
+  if (cmdGap) {
     transactBackground(
       s,
-      () => {
-        if (cmdGap) sessionLostInner(s, seq!, ctxSeq ?? 0);
-        else snapCtxClock(s, ctxSeq!);
-      },
+      () => sessionLostInner(s, seq),
       () => {
         wake(s);
         void pump(s);
@@ -814,16 +740,13 @@ type Lanes = {
 
 // A lane must be strictly consecutive within a frame: the first unposted run
 // per lane rides now, later runs ride follow-up frames.
-const buildLanes = (s: Session, persisted = false): Lanes | null => {
+const buildLanes = (
+  s: Session,
+  cmdGate: "persisted" | "all" | "none" = "all",
+): Lanes | null => {
   const ctxEntries: CtxPending[] = [];
   for (const entry of s.ctxPending) {
     if (entry.posted) continue;
-    if (
-      persisted &&
-      (s.persistedRecord?.clientId !== s.record.clientId ||
-        entry.seq >= s.persistedRecord.ctxNextSeq)
-    )
-      break;
     if (ctxEntries.length >= MAX_COMMANDS_PER_FRAME) break;
     if (ctxEntries.length > 0 && entry.seq !== ctxEntries.at(-1)!.seq + 1)
       break;
@@ -831,9 +754,10 @@ const buildLanes = (s: Session, persisted = false): Lanes | null => {
   }
   const cmdEntries: Pending[] = [];
   for (const entry of s.pending) {
+    if (cmdGate === "none") break;
     if (entry.posted) continue;
     if (
-      persisted &&
+      cmdGate === "persisted" &&
       (s.persistedRecord?.clientId !== s.record.clientId ||
         entry.seq >= s.persistedRecord.nextSeq)
     )
@@ -861,13 +785,20 @@ const buildLanes = (s: Session, persisted = false): Lanes | null => {
   };
 };
 
+// Context is attach scoped: every attach starts at ctx seq 0 with an empty
+// table, so the full context restates at seq 1 on the attach frame.
+const resetContextLane = (s: Session) => {
+  const ops = contextSnapshot(s.contextDocuments);
+  s.ctxPending = ops.length === 0 ? [] : [{ seq: 1, ops, posted: false }];
+  s.ctxNextSeq = s.ctxPending.length + 1;
+};
+
 const takeAttachLanes = (s: Session): StatewireFrame | null => {
   s.attachLaneSeqs = [new Set(), new Set()];
+  resetContextLane(s);
   const wanted = s.lanesOnAttach;
   s.lanesOnAttach = false;
-  if (!wanted || !s.sessionKnown || s.record.context?.recover !== undefined)
-    return null;
-  const lanes = buildLanes(s, true);
+  const lanes = buildLanes(s, wanted && s.sessionKnown ? "persisted" : "none");
   if (!lanes) return null;
   s.attachLaneSeqs = [
     new Set(lanes.cmdEntries.map((p) => p.seq)),
@@ -1299,83 +1230,38 @@ const contextSnapshot = (documents: StatewireDocuments.State) =>
     };
   });
 
-const persistContext = (s: Session) => {
-  const ops = contextSnapshot(s.contextDocuments);
-  s.ctxOps = ops;
-  setRecord(s, {
-    ...s.record,
-    context: {
-      ops,
-      ...(s.record.context?.recover === undefined
-        ? {}
-        : { recover: s.record.context.recover }),
-      pending: s.ctxPending.map(({ seq, ops }) => ({ seq, ops })),
-    },
-  });
-};
-
 const changeContext = (
   s: Session,
   build: (documents: StatewireDocuments.State) => readonly unknown[],
 ): void => {
-  if (!s.hydrated) {
-    void s
-      .ready!.then(() => changeContext(s, build))
-      .catch((cause: unknown) => {
-        const error = wrapStorageError(cause);
-        s.storageError = error;
-        s.transport?.storageFailed(error);
-      });
-    return;
-  }
   if (!s.running || isFinished(s)) return;
-  const submit = () => {
-    if (!s.running || isFinished(s)) return;
-    const previous =
-      s.record.context === undefined
-        ? s.contextDocuments
-        : applyDocumentOps(
-            { mode: "mounted", documents: new Map() },
-            s.record.context.ops,
-          );
-    const operations = build(previous);
-    if (!operations.length)
-      throw new Error("statewire: context operations must not be empty");
-    const offers = protocolOffers(s.options);
-    const protocols =
-      s.selection?.protocols ?? (offers === "*" ? undefined : offers);
-    s.contextDocuments = applyDocumentOps(
-      previous,
-      operations,
-      protocols,
-      true,
-    );
-    const seq = s.record.ctxNextSeq;
-    s.ctxPending = [
-      ...s.ctxPending,
-      {
-        seq,
-        ops: operations.map((op) => {
-          const value = op as Record<string, unknown>;
-          if (value["doc"] !== 0) return value;
-          const { doc: _doc, ...rest } = value;
-          return rest;
-        }),
-        posted: false,
-      },
-    ];
-    s.record = { ...s.record, ctxNextSeq: seq + 1 };
-    persistContext(s);
-  };
-  if (!s.shared) {
-    submit();
-    wake(s);
-    void pump(s);
-  } else
-    transactBackground(s, submit, () => {
-      wake(s);
-      void pump(s);
-    });
+  const operations = build(s.contextDocuments);
+  if (!operations.length)
+    throw new Error("statewire: context operations must not be empty");
+  const offers = protocolOffers(s.options);
+  const protocols =
+    s.selection?.protocols ?? (offers === "*" ? undefined : offers);
+  s.contextDocuments = applyDocumentOps(
+    s.contextDocuments,
+    operations,
+    protocols,
+    true,
+  );
+  s.ctxPending = [
+    ...s.ctxPending,
+    {
+      seq: s.ctxNextSeq++,
+      ops: operations.map((op) => {
+        const value = op as Record<string, unknown>;
+        if (value["doc"] !== 0) return value;
+        const { doc: _doc, ...rest } = value;
+        return rest;
+      }),
+      posted: false,
+    },
+  ];
+  wake(s);
+  void pump(s);
 };
 
 export const updateContext = (s: Session, operations: readonly unknown[]) =>
@@ -1506,11 +1392,10 @@ const loadSessionRecord = (
   const record = stored ?? {
     clientId: newClientId(),
     nextSeq: 1,
-    ctxNextSeq: 1,
     commands: [],
   };
   if (stored === null) store.save(record);
-  return { record, stored };
+  return record;
 };
 
 export const useStatewireSession = (
@@ -1531,28 +1416,14 @@ export const useStatewireSession = (
     );
   }
   const [s] = useState((): Session => {
-    const { record, stored } =
+    const record =
       store.ready === undefined
         ? loadSessionRecord(store, options)
-        : {
-            record: {
-              clientId: newClientId(),
-              nextSeq: 1,
-              ctxNextSeq: 1,
-              commands: [],
-            },
-            stored: null,
-          };
+        : { clientId: newClientId(), nextSeq: 1, commands: [] };
     const session: Session = {
       options,
       selection: undefined,
-      contextDocuments:
-        stored?.context === undefined
-          ? { mode: "mounted", documents: new Map() }
-          : applyDocumentOps(
-              { mode: "mounted", documents: new Map() },
-              stored.context.ops,
-            ),
+      contextDocuments: { mode: "mounted", documents: new Map() },
       record,
       ctx: {
         beforeAttach: () => persistBeforeSend(session),
@@ -1587,9 +1458,8 @@ export const useStatewireSession = (
       idle: false,
       onSessionLost: undefined,
       onDone: undefined,
-      ctxOps: stored?.context?.ops,
-      ctxPending:
-        stored?.context?.pending.map((p) => ({ ...p, posted: false })) ?? [],
+      ctxNextSeq: 1,
+      ctxPending: [],
       lanesOnAttach: false,
       attachLaneSeqs: [new Set(), new Set()],
       frameFailures: 0,
@@ -1624,21 +1494,7 @@ export const useStatewireSession = (
     };
     if (store.ready !== undefined) {
       session.ready = store.ready.then(() => {
-        const { record } = loadSessionRecord(store, session.options);
-        session.record = record;
-        session.contextDocuments =
-          record.context === undefined
-            ? { mode: "mounted", documents: new Map() }
-            : applyDocumentOps(
-                { mode: "mounted", documents: new Map() },
-                record.context.ops,
-              );
-        session.ctxOps = record.context?.ops;
-        session.ctxPending =
-          record.context?.pending.map((entry) => ({
-            ...entry,
-            posted: false,
-          })) ?? [];
+        session.record = loadSessionRecord(store, session.options);
         session.recordPersisted = true;
         session.hydrated = true;
         if (session.running) session.notify();

package/src/host/http.ts

@@ -226,13 +226,7 @@ const admitAttachFrame = (
   frame: ParsedFrame,
 ) => {
   if (frame.ctx.length === 0 && frame.cmd.length === 0) return;
-  const admission = admitFrame(
-    h,
-    registration.rec,
-    frame,
-    registration.conn.auth,
-    registration.conn.selection,
-  );
+  const admission = admitFrame(h, registration.conn, frame);
   if (admission.type === "refused") {
     sendTo(h, registration.conn, JSON.stringify(admission.syn));
   }
@@ -376,7 +370,6 @@ export const frames = async (
     return Response.json({ error: "stale-lease" }, { status: 423 });
   }
   const clientId = leased.clientId;
-  const rec = h.clients.get(clientId)!;
   const raw = await readFrameBody(request);
   if (raw === null) {
     return Response.json({ error: "frame body too large" }, { status: 413 });
@@ -395,7 +388,7 @@ export const frames = async (
   }
   let admission: ReturnType<typeof admitFrame>;
   try {
-    admission = admitFrame(h, rec, frame, leased.auth, leased.selection);
+    admission = admitFrame(h, leased, frame);
   } catch (error) {
     if (!(error instanceof Error) || error.name !== "StatewireViolation")
       throw error;