statewire 0.10.0 → 0.12.0

package/src/client/session.ts

@@ -1,6 +1,7 @@
 import { useContext, useEffect, useState } from "react";
 import { applyOps } from "../wire/ops";
 import type { StatewirePath } from "../wire/ops";
+import { TERMINAL } from "./connection";
 import type { StatewireCmd, StatewireSyn } from "./connection";
 import {
   encodeParams,
@@ -70,14 +71,22 @@ type AttachState = "detached" | "attached" | "finished";
 
 export type StatewireSessionOptions = {
   sessionStore?: StatewireClient.SessionStorage | undefined;
+  onSessionLost?: StatewireClient.OnSessionLost | undefined;
   onDone?: (() => void) | undefined;
 };
 
+type Shared = {
+  txq: Promise<void>;
+  parked: StatewireClient.SessionVerdict[];
+  unsubscribe: (() => void) | null;
+};
+
 type Session = {
   record: StatewireClient.SessionRecord;
   ctx: StatewireRemoteProps;
   recordPersisted: boolean;
   store: StatewireClient.SessionStorage;
+  shared: Shared | false;
   ephemeral: boolean;
   /** An ephemeral record died with its attach: the storage is off for good. */
   deactivated: boolean;
@@ -85,6 +94,7 @@ type Session = {
   durableSeq: number;
   resumeAt: number;
   idle: boolean;
+  onSessionLost: StatewireClient.OnSessionLost | undefined;
   onDone: (() => void) | undefined;
   ctxOps: unknown[] | undefined;
   ctxPending: CtxPending[];
@@ -144,15 +154,68 @@ const backlog = (s: Session): StatewireClient.SessionCommand[] =>
     .filter((p) => p.seq > s.durableSeq)
     .map((p) => ({ seq: p.seq, ...p.command }));
 
+const mergeBacklog = (s: Session): StatewireClient.SessionCommand[] => {
+  const own = backlog(s);
+  if (!s.shared) return own;
+  const known = new Set(s.pending.map((p) => p.seq));
+  const foreign = s.record.commands.filter(
+    (c) => !known.has(c.seq) && c.seq > s.durableSeq,
+  );
+  return [...foreign, ...own].sort((a, b) => a.seq - b.seq);
+};
+
+const MAX_PARKED_VERDICTS = 64;
+
 // Storage holds what a reload must resend: a command leaves at its dur, at a
 // server verdict, or at a record reset — never at a local channel death.
-const syncBacklog = (s: Session) => {
-  const commands = backlog(s);
+const syncBacklogInner = (s: Session) => {
+  const parked = s.shared ? s.shared.parked.splice(0) : [];
+  const parkedSeqs = new Set(parked.map((v) => v.seq));
+  const commands = mergeBacklog(s).filter((c) => !parkedSeqs.has(c.seq));
+  const verdicts =
+    parked.length > 0
+      ? [...(s.record.verdicts ?? []), ...parked].slice(-MAX_PARKED_VERDICTS)
+      : s.record.verdicts;
   const unchanged =
+    verdicts === s.record.verdicts &&
     commands.length === s.record.commands.length &&
     commands.every((c, i) => c.seq === s.record.commands[i]!.seq);
   if (unchanged) return;
-  setRecord(s, { ...s.record, commands });
+  setRecord(s, {
+    ...s.record,
+    commands,
+    ...(verdicts !== undefined && { verdicts }),
+  });
+};
+
+const syncBacklog = (s: Session) => {
+  if (!s.shared) return syncBacklogInner(s);
+  void transact(s, () => syncBacklogInner(s));
+};
+
+// Every record mutation over shared storage is a locked read-modify-write.
+const transact = (s: Session, fn: () => void): Promise<void> => {
+  if (!s.shared || s.deactivated) {
+    fn();
+    return Promise.resolve();
+  }
+  const shared = s.shared;
+  const run = shared.txq.then(() =>
+    s.store.lock!(async () => {
+      const stored = s.store.load();
+      if (stored !== null && stored.clientId !== s.record.clientId) {
+        adoptReset(s, stored);
+      } else if (stored !== null) {
+        s.record = stored;
+      }
+      fn();
+    }),
+  );
+  shared.txq = run.then(
+    () => {},
+    () => {},
+  );
+  return run;
 };
 
 const setIdle = (s: Session, level: boolean) => {
@@ -192,14 +255,9 @@ const settleEntry = (
   }
 };
 
-const settleAll = (s: Session, detach: "unmount" | "gone" | "superseded") => {
-  const cause = (
-    {
-      unmount: "unmount",
-      gone: "stream-gone",
-      superseded: "superseded",
-    } as const
-  )[detach];
+const settleAll = (s: Session, detach: "unmount" | "gone") => {
+  const cause =
+    detach === "unmount" ? ("unmount" as const) : ("stream-gone" as const);
   const batch = s.pending;
   const detachFailure = (entry: Pending): StatewireClient.SendFailure => {
     if (!entry.attempted) {
@@ -226,35 +284,52 @@ const restateContext = (s: Session) => {
   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);
+    settleEntry(s, entry, {
+      ok: false,
+      failure: { fate: "lost", cause: "session-lost" },
+    });
+  }
+};
+
 // The server-side record's dedup memory is gone: history that may have
 // reached a server settles lost — the new hello's snapshot is the only
 // truth about what survived — and never-attempted statements re-stamp
-// from 1 on the reset lane clocks.
-const resetRecord = (s: Session, clientId: string) => {
-  const survivors: Pending[] = [];
-  for (const entry of [...s.pending]) {
-    if (entry.attempted || entry.applied) {
-      s.lifecycle?.onCovered?.(entry.inv);
-      settleEntry(s, entry, {
-        ok: false,
-        failure: { fate: "lost", cause: "session-lost" },
-      });
-    } else {
-      survivors.push(entry);
-    }
-  }
+// on the adopted lane clocks.
+const rebaseRecord = (s: Session, adopt: () => void) => {
+  const held = [...s.pending];
+  const survivors = held.filter((p) => !p.attempted && !p.applied);
+  settleLost(
+    s,
+    held.filter((p) => p.attempted || p.applied),
+  );
   s.pending = [];
   s.durableSeq = 0;
-  setRecord(s, { clientId, nextSeq: 1, ctxNextSeq: 1, commands: [] });
+  adopt();
   for (const old of survivors) {
     s.lifecycle?.onCovered?.(old.inv);
-    enqueue(s, old.command, old.inv.params, old.resolve, old.reject);
+    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: [] }),
+  );
+
+// Another sharer replaced the record's identity: their reset settles our
+// attempted history and our survivors re-stamp on the stored clocks.
+const adoptReset = (s: Session, stored: StatewireClient.SessionRecord) =>
+  rebaseRecord(s, () => {
+    s.record = stored;
+  });
+
 // The record died with the attach: mint a fresh id for the next one.
 const ephemeralDetach = (s: Session) => {
   s.ephemeral = false;
@@ -272,6 +347,48 @@ const rejectedFailure = (cmd: StatewireCmd): StatewireClient.SendFailure => {
   };
 };
 
+const outcomeOf = (
+  cmd: StatewireCmd,
+):
+  | { ok: true; payload: unknown }
+  | { ok: false; failure: StatewireClient.SendFailure } => {
+  switch (cmd.type) {
+    case "result":
+      return { ok: true, payload: reviveResponse(cmd).payload };
+    case "rejected":
+      return { ok: false, failure: rejectedFailure(reviveResponse(cmd)) };
+    case "failed":
+      return {
+        ok: false,
+        failure: {
+          fate: "failed",
+          cause: "server",
+          ...(cmd.message !== undefined && { message: cmd.message }),
+        },
+      };
+    case "crashed":
+      return { ok: false, failure: { fate: "crashed", cause: "server" } };
+    case "expired":
+      return { ok: false, failure: { fate: "expired", cause: "server" } };
+    default:
+      return protocolError(`unknown cmd type: ${String(cmd.type)}`);
+  }
+};
+
+const TERMINAL_CMD_TYPES: ReadonlySet<string> = new Set(TERMINAL);
+
+const parkVerdict = (s: Session, cmd: StatewireCmd) => {
+  if (!s.shared || !TERMINAL_CMD_TYPES.has(cmd.type!)) return;
+  s.shared.parked.push({
+    seq: cmd.seq,
+    type: cmd.type as StatewireClient.SessionVerdict["type"],
+    ...(cmd.code !== undefined && { code: cmd.code }),
+    ...(cmd.message !== undefined && { message: cmd.message }),
+    ...(cmd.payload !== undefined && { payload: cmd.payload }),
+    ...(cmd.meta !== undefined && { meta: cmd.meta }),
+  });
+};
+
 const handleCmd = (s: Session, cmd: StatewireCmd) => {
   if (!Number.isSafeInteger(cmd.seq) || cmd.seq <= 0) {
     protocolError("cmd.seq must be a positive safe integer");
@@ -288,37 +405,30 @@ const handleCmd = (s: Session, cmd: StatewireCmd) => {
     if (entry) cover(s, entry);
     return;
   }
+  parkVerdict(s, cmd);
   if (!entry) return;
   cover(s, entry);
-  const outcome =
-    cmd.type === "result"
-      ? { ok: true as const, payload: reviveResponse(cmd).payload }
-      : cmd.type === "rejected"
-        ? { ok: false as const, failure: rejectedFailure(reviveResponse(cmd)) }
-        : cmd.type === "failed"
-          ? {
-              ok: false as const,
-              failure: {
-                fate: "failed" as const,
-                cause: "server" as const,
-                ...(cmd.message !== undefined && { message: cmd.message }),
-              },
-            }
-          : cmd.type === "crashed"
-            ? {
-                ok: false as const,
-                failure: { fate: "crashed" as const, cause: "server" as const },
-              }
-            : cmd.type === "expired"
-              ? {
-                  ok: false as const,
-                  failure: {
-                    fate: "expired" as const,
-                    cause: "server" as const,
-                  },
-                }
-              : protocolError(`unknown cmd type: ${String(cmd.type)}`);
-  settleEntry(s, entry, outcome);
+  settleEntry(s, entry, outcomeOf(cmd));
+};
+
+const consumeVerdicts = (s: Session) => {
+  const verdicts = s.record.verdicts ?? [];
+  const consumed = new Set<number>();
+  for (const verdict of verdicts) {
+    const entry = s.pending.find((p) => p.seq === verdict.seq);
+    if (!entry) continue;
+    consumed.add(verdict.seq);
+    cover(s, entry);
+    settleEntry(s, entry, outcomeOf(verdict as StatewireCmd));
+  }
+  if (consumed.size === 0) return;
+  setRecord(s, {
+    ...s.record,
+    commands: s.record.commands.filter((c) => !consumed.has(c.seq)),
+    verdicts: verdicts.filter((v) => !consumed.has(v.seq)),
+  });
+  publish(s);
+  wake(s);
 };
 
 const handleCmds = (s: Session, cmds: StatewireCmd[]) => {
@@ -338,24 +448,10 @@ const publishIngested = (s: Session) => {
   wake(s);
 };
 
-const RECORDS = ["fresh", "resumed", "ephemeral"];
-
-// Snap a resumed session's lane clocks onto the record: seqs above the stated
-// watermark were never admitted, so a stale restored clock re-stamps its
-// never-admitted statements consecutively after the watermark.
-const snapClocks = (s: Session, seqWm: number, ctxWm: number) => {
-  const tail = s.pending.filter((p) => p.seq > seqWm);
-  const cmdAligned =
-    tail.every((p, i) => p.seq === seqWm + 1 + i) &&
-    s.record.nextSeq === seqWm + tail.length + 1;
-  if (!cmdAligned) {
-    s.pending = s.pending.filter((p) => p.seq <= seqWm);
-    setRecord(s, { ...s.record, nextSeq: seqWm + 1 });
-    for (const old of tail) {
-      s.lifecycle?.onCovered?.(old.inv);
-      enqueue(s, old.command, old.inv.params, old.resolve, old.reject);
-    }
-  }
+// 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) => {
   const ctxAligned =
     s.ctxPending.every((c, i) => c.seq === ctxWm + 1 + i) &&
     s.record.ctxNextSeq === ctxWm + s.ctxPending.length + 1;
@@ -365,40 +461,81 @@ const snapClocks = (s: Session, seqWm: number, ctxWm: number) => {
   }
 };
 
+// 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
+// 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) => {
+  const held = [...s.pending];
+  settleLost(s, held);
+  s.pending = [];
+  s.durableSeq = seqWm;
+  setRecord(s, {
+    clientId: s.record.clientId,
+    nextSeq: seqWm + 1,
+    ctxNextSeq: ctxWm + 1,
+    commands: [],
+  });
+  restateContext(s);
+  if (
+    held.length > 0 &&
+    s.onSessionLost?.(held.map((p) => p.inv)) === "requeue"
+  ) {
+    for (const old of held) {
+      enqueueInner(
+        s,
+        old.command,
+        old.inv.params,
+        () => {},
+        () => {},
+      );
+    }
+  }
+  publish(s);
+  wake(s);
+};
+
 const handleHello = (
   s: Session,
   { ops, syn }: { ops: unknown[]; syn: StatewireSyn },
 ) => {
-  const record = syn.record ?? "fresh";
-  if (!RECORDS.includes(record)) {
-    protocolError(`unknown record: ${String(record)}`);
+  if (syn.record !== undefined && syn.record !== "ephemeral") {
+    protocolError(`unknown record: ${String(syn.record)}`);
   }
   ingestOps(s, ops);
   s.attach = "attached";
   s.attachEpoch += 1;
   s.frameFailures = 0;
   s.resumeAt = 0;
-  s.ephemeral = record === "ephemeral";
+  s.ephemeral = syn.record === "ephemeral";
   if (s.ephemeral) s.deactivated = true;
   const [attachCmd, attachCtx] = s.attachLaneSeqs;
   s.attachLaneSeqs = [new Set(), new Set()];
-  if (record === "resumed") {
+  const reconcile = () => {
+    if (s.shared) adoptStored(s);
     // Resending unsettled statements is exactly-once-safe: absorbed replays
     // re-emit their stored verdicts (applied while still in flight).
+    s.durableSeq = syn.seq ?? 0;
     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);
-    snapClocks(s, syn.seq ?? 0, ctxWatermark);
-    syncBacklog(s);
-  } else {
-    resetRecord(s, s.record.clientId);
+    snapCtxClock(s, ctxWatermark);
+    syncBacklogInner(s);
+    s.sessionKnown = true;
+  };
+  if (!s.shared || s.deactivated) {
+    reconcile();
+    publishIngested(s);
+    void pump(s);
+    return;
   }
-  s.sessionKnown = true;
-  publishIngested(s);
-  void pump(s);
+  void transact(s, reconcile).then(() => {
+    publishIngested(s);
+    void pump(s);
+  });
 };
 
 const handleOps = (
@@ -411,8 +548,9 @@ const handleOps = (
   publishIngested(s);
 };
 
-// A {syn} refusal never settles: reconcile the resend queues against the
-// stated watermarks; retry present means wait, absent means resend now.
+// A retry-less {syn} refusal is the one session-loss verdict: a cmd gap
+// against its exact watermark settles the held history lost; a pushback
+// (retry present) or a gapless refusal only reconciles the resend queues.
 const handleRefusal = (s: Session, syn: StatewireSyn) => {
   const { seq, ctxSeq } = syn;
   if (typeof seq === "number") {
@@ -425,19 +563,30 @@ const handleRefusal = (s: Session, syn: StatewireSyn) => {
   }
   if (typeof syn.retry === "number") {
     s.resumeAt = Date.now() + syn.retry;
+    wake(s);
+    void pump(s);
+    return;
   }
   const firstCmd = s.pending.find((p) => !p.posted);
   const firstCtx = s.ctxPending.find((c) => !c.posted);
-  const clocksAhead =
-    (typeof syn.seq === "number" &&
-      firstCmd !== undefined &&
-      firstCmd.seq > Math.max(syn.seq, s.durableSeq) + 1) ||
-    (typeof syn.ctxSeq === "number" &&
-      firstCtx !== undefined &&
-      firstCtx.seq > syn.ctxSeq + 1);
-  // Clocks ahead of a record that cannot admit them: reattach first and let
-  // the hello's record arbitrate.
-  if (clocksAhead) s.transport?.connection.reconnect();
+  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) {
+    void transact(s, () => {
+      if (cmdGap) sessionLostInner(s, seq!, ctxSeq ?? 0);
+      else snapCtxClock(s, ctxSeq!);
+    }).then(() => {
+      wake(s);
+      void pump(s);
+    });
+    return;
+  }
   wake(s);
   void pump(s);
 };
@@ -451,7 +600,7 @@ const handleDetach = (s: Session) => {
 const handleFinish = (s: Session, { reason }: { reason: string }) => {
   if (reason === "evicted" || reason === "error") return;
   s.attach = "finished";
-  settleAll(s, reason === "superseded" ? "superseded" : "gone");
+  settleAll(s, "gone");
   publish(s);
   wake(s);
 };
@@ -536,7 +685,12 @@ const pump = async (s: Session) => {
       for (const entry of lanes.cmdEntries) entry.attempted = true;
       let result;
       try {
-        result = await transport.send(lanes.frame);
+        // Shared storage: the lock across the send keeps per-lane arrival
+        // ordered across sharers during attach handover.
+        const send = () => transport.send(lanes.frame);
+        result = await (s.shared && !s.deactivated
+          ? s.store.lock!(send)
+          : send());
       } catch {
         if (!s.running || isFinished(s)) return;
         s.frameFailures += 1;
@@ -580,17 +734,34 @@ const pump = async (s: Session) => {
 };
 
 const start = (s: Session) => {
+  if (s.shared) {
+    s.shared.unsubscribe = s.store.subscribe!(() => {
+      void transact(s, () => consumeVerdicts(s));
+    });
+    s.running = true;
+    void transact(s, () => {
+      if (s.store.load() === null) s.store.save(s.record);
+      s.recordPersisted = true;
+      adoptStored(s);
+      consumeVerdicts(s);
+    }).then(() => void pump(s));
+    return;
+  }
   if (!s.recordPersisted) {
     s.recordPersisted = true;
     s.store.save(s.record);
   }
-  resume(s);
+  adoptStored(s);
   s.running = true;
   void pump(s);
 };
 
 const stop = (s: Session) => {
   s.running = false;
+  if (s.shared) {
+    s.shared.unsubscribe?.();
+    s.shared.unsubscribe = null;
+  }
   wake(s);
   settleAll(s, "unmount");
 };
@@ -601,7 +772,7 @@ const setTransport = (s: Session, transport: RemoteLink) => {
   wake(s);
 };
 
-const enqueue = (
+const enqueueInner = (
   s: Session,
   command: WireCommand,
   params: readonly unknown[],
@@ -626,15 +797,33 @@ const enqueue = (
     reject,
   };
   s.pending.push(entry);
-  setRecord(s, { ...s.record, nextSeq: seq + 1, commands: backlog(s) });
+  setRecord(s, { ...s.record, nextSeq: seq + 1, commands: mergeBacklog(s) });
   s.lifecycle?.onStart(entry.inv);
-  void pump(s);
 };
 
-// A stored command cannot be told from one that reached the server: attempted
-// keeps a fresh record settling it lost instead of replaying it blind.
-const resume = (s: Session) => {
-  const stored = [...s.record.commands].sort((a, b) => a.seq - b.seq);
+const enqueue = (
+  s: Session,
+  command: WireCommand,
+  params: readonly unknown[],
+  resolve: (payload: unknown) => void,
+  reject: (error: StatewireSendError) => void,
+) => {
+  if (!s.shared) {
+    enqueueInner(s, command, params, resolve, reject);
+    void pump(s);
+    return;
+  }
+  void transact(s, () =>
+    enqueueInner(s, command, params, resolve, reject),
+  ).then(() => void pump(s));
+};
+
+// A stored command may have reached a server: attempted settles it lost,
+// never aborted, when a channel death ends the session.
+const adoptStored = (s: Session) => {
+  const known = new Set(s.pending.map((p) => p.seq));
+  const stored = s.record.commands.filter((c) => !known.has(c.seq));
+  if (stored.length === 0) return;
   for (const { seq, ...command } of stored) {
     const params =
       command.meta === undefined
@@ -659,6 +848,7 @@ const resume = (s: Session) => {
     s.pending.push(entry);
     s.lifecycle?.onStart(entry.inv);
   }
+  s.pending.sort((a, b) => a.seq - b.seq);
 };
 
 const sendCommand = (
@@ -690,8 +880,9 @@ const setContext = (s: Session, value: Record<string, unknown>): void => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error("statewire: context must be a plain object");
   }
+  if (!s.running || isFinished(s)) return;
   const { value: encoded, meta } = encodeValue(value);
-  s.ctxOps = [
+  const ops = [
     {
       op: "replace",
       path: [],
@@ -699,11 +890,22 @@ const setContext = (s: Session, value: Record<string, unknown>): void => {
       ...(meta !== undefined && { meta }),
     },
   ];
-  const seq = s.record.ctxNextSeq;
-  setRecord(s, { ...s.record, ctxNextSeq: seq + 1 });
-  s.ctxPending.push({ seq, ops: s.ctxOps, posted: false });
-  wake(s);
-  void pump(s);
+  s.ctxOps = ops;
+  const mint = () => {
+    const seq = s.record.ctxNextSeq;
+    setRecord(s, { ...s.record, ctxNextSeq: seq + 1 });
+    s.ctxPending.push({ seq, ops, posted: false });
+  };
+  if (!s.shared) {
+    mint();
+    wake(s);
+    void pump(s);
+    return;
+  }
+  void transact(s, mint).then(() => {
+    wake(s);
+    void pump(s);
+  });
 };
 
 export const useStatewireSession = (
@@ -717,6 +919,11 @@ export const useStatewireSession = (
     );
   }
   const store = options.sessionStore ?? mounted ?? defaultStore;
+  if ((store.lock === undefined) !== (store.subscribe === undefined)) {
+    throw new Error(
+      "statewire: session storage must provide lock and subscribe together",
+    );
+  }
   const [s] = useState((): Session => {
     const stored = store.load();
     if (stored !== null && !Array.isArray(stored.commands)) {
@@ -747,12 +954,17 @@ export const useStatewireSession = (
       },
       recordPersisted: stored !== null,
       store,
+      shared:
+        store.lock !== undefined
+          ? { txq: Promise.resolve(), parked: [], unsubscribe: null }
+          : false,
       ephemeral: false,
       deactivated: false,
       sessionKnown: false,
       durableSeq: 0,
       resumeAt: 0,
       idle: false,
+      onSessionLost: undefined,
       onDone: undefined,
       ctxOps: undefined,
       ctxPending: [],
@@ -793,7 +1005,13 @@ export const useStatewireSession = (
     });
     return session;
   });
+  if ((store.lock !== undefined) !== (s.shared !== false)) {
+    throw new Error(
+      "statewire: session storage changed sharedness across renders — lock/subscribe must be present from the first render or never",
+    );
+  }
   s.store = store;
+  s.onSessionLost = options.onSessionLost;
   s.onDone = options.onDone;
   useEffect(() => {
     start(s);