@jskit-ai/assistant-runtime 0.2.6 → 0.2.8

package/fixtures/canonical-conversation/App.vue

@@ -121,6 +121,8 @@ onMounted(() => {
   window.conversationFixture = {
     socket,
     acquireConversation,
+    // A reader's own visibility, as when an application hides a retained view.
+    activity(value) { return ref(value); },
     releaseFactory() { factoryScope.stop(); },
     target(id) { conversationId.value = id; },
     show(value) { visible.value = value; },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -13,19 +13,19 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.4",
+    "@jskit-ai/assistant-core": "0.2.6",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.1",
-    "@jskit-ai/http-web": "0.2.5",
-    "@jskit-ai/kernel": "0.2.1",
-    "@jskit-ai/realtime": "0.2.4",
-    "@jskit-ai/shell-web": "0.2.1",
+    "@jskit-ai/http-runtime": "0.2.3",
+    "@jskit-ai/http-web": "0.2.7",
+    "@jskit-ai/kernel": "0.2.3",
+    "@jskit-ai/realtime": "0.2.6",
+    "@jskit-ai/shell-web": "0.2.3",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.250"
+    "@jskit-ai/database-runtime": "0.1.252"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -136,6 +136,11 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const hasMoreBefore = computed(() => normalizeConversationLogPagination(oldestLoadedPage.value?.pagination).hasMoreBefore);
   const editable = computed(() => active.value && !accessDenied.value);
   const available = computed(() => active.value && !loading.value && !accessDenied.value && Boolean(snapshot.value));
+  // A deferred message keeps the subscription while its view is hidden, so it
+  // is admitted against live state. A failed read leaves that state stale.
+  const deferredWaits = ref(0);
+  const listening = computed(() => active.value || current.value && deferredWaits.value > 0);
+  const admissible = computed(() => listening.value && !loading.value && !accessDenied.value && !error.value && Boolean(snapshot.value));
   const steerable = computed(() => snapshot.value?.status === "working" && snapshot.value?.capabilities?.steering === true);
   const workingPolicy = computed(() => resolveWorkingPolicy(snapshot.value, { deferWhileWorking, admitWhileWorking }));
   const queueing = computed(() => queueWhileSending !== false && (steerable.value || workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking));
@@ -305,7 +310,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       if (denial !== deniedHistoryRevision) {
         throw Object.assign(new Error("Access denied."), { status: 403, messageCode: "assistant.runtime.accessDenied" });
       }
-      return current.value && active.value && subscriptionCurrent();
+      return current.value && listening.value && subscriptionCurrent();
     };
     // A concurrent Load older operation extends the desired span. Retry one
     // refresh in this same read, rather than dropping that newly loaded page.
@@ -354,7 +359,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     }
     return null;
   }
-  watch(active, enabled => {
+  watch(listening, enabled => {
     subscription?.();
     subscription = null;
     historyRevision += 1;
@@ -450,6 +455,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   }
   // A deferred message waits only while the working turn cannot take it. It
   // steers as soon as that turn accepts steering, or sends once it is ready.
+  // Its view may be hidden. While loading or after a failed read there is no
+  // current state to admit it against, so the unsent message keeps waiting;
+  // only Stop, Cancel, retirement or lost access end it.
   function waitForAdmission({ controller }) {
     return new Promise(resolve => {
       let stop;
@@ -459,12 +467,13 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         resolve(admission);
       };
       const check = () => {
-        if (controller.signal.aborted || !available.value) finish(false);
+        if (controller.signal.aborted || accessDenied.value) finish(false);
+        else if (!admissible.value) return;
         else if (snapshot.value.status === "ready") finish("send");
         else if (steerable.value) finish("steer");
         else if (snapshot.value.status !== "working") finish(false);
       };
-      stop = watch([available, snapshot, steerable], check, { flush: "sync" });
+      stop = watch([admissible, snapshot, steerable], check, { flush: "sync" });
       controller.signal.addEventListener("abort", check, { once: true });
       check();
     });
@@ -477,6 +486,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const pending = { controller: new AbortController(), started: false, dispatched: false };
     const { controller } = pending;
     pendingMessages.set(messageId, pending);
+    if (deferred) deferredWaits.value += 1;
     try {
       const result = await delivery.send(payload, {
         messageId, queue, isCurrent: () => current.value, onAccepted,
@@ -490,13 +500,12 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
               // Refresh through the same subscription after a queued predecessor;
               // its receipt may have arrived before the working snapshot.
               await subscription?.reload();
-              if (error.value) return false;
-              if (snapshot.value.status === "working" && !steerable.value) {
+              if (snapshot.value?.status === "working" && !steerable.value) {
                 delivery.wait(messageId, t("jskit.assistant.runtime.delivery.waitingForStep"));
               }
               admission = await waitForAdmission(pending);
               delivery.wait(messageId, "");
-              if (!admission || controller.signal.aborted || !available.value ||
+              if (!admission || controller.signal.aborted || !admissible.value ||
                   snapshot.value.status !== (admission === "steer" ? "working" : "ready")) return false;
               if (submission.displayAttachments?.length && snapshot.value.capabilities?.attachments !== true) {
                 return { ok: false, error: t("jskit.assistant.runtime.attachments.noLongerAccepted") };
@@ -566,6 +575,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       return false;
     } finally {
       if (!pending.started && pendingMessages.get(messageId) === pending) pendingMessages.delete(messageId);
+      if (deferred) deferredWaits.value -= 1;
       if (current.value) subscription?.reload();
     }
   }
@@ -742,6 +752,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const commands = capabilities.goalCommands || {};
     const loading = !goalTargetCurrent.value && !goalLoadError.value;
     const goalAvailable = goalTargetCurrent.value && view?.status === "available" && !goalLoadError.value;
+    const stopPending = Boolean(goalAction.value) || !goalAvailable || !available.value;
     return {
       enabled: active.value && Boolean(loading || (view?.status === "available" && !goalLoadError.value) || goalError.value || goalLoadError.value),
       loading,
@@ -751,9 +762,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       tokenBudgetSupported: capabilities.goalBudgets === true,
       goal: goalAvailable && view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
-      pending: Boolean(goalAction.value) || !goalAvailable || !available.value || delivery.state.sending ||
-        delivery.state.messages.some(message => message.status === "uncertain"),
-      stopPending: Boolean(goalAction.value) || !goalAvailable || !available.value,
+      pending: stopPending || delivery.state.sending || delivery.state.messages.some(message => message.status === "uncertain"),
+      stopPending,
       error: goalError.value || goalLoadError.value || view?.error || "",
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,
       cancelInterruptsTurn: commands.cancel?.interruptsTurn === true,

package/src/client/support/subscribeAssistantConversation.js

@@ -16,10 +16,10 @@ function patchLoadedHistoryPages(pages = [], patch) {
 }
 
 const SNAPSHOT_EVENTS = new Set(["accepted", "settled", "configuration", "phase", "error", "replaced", "goal"]);
-// A connected server may need longer than the normal budget to answer (an
-// overloaded host took 15 s). Abandoning it then discards the server's work and
-// repeats it, so a slow answer only shows a loading notice; it is treated as
-// lost, unsubscribed and retried only after the much longer cap.
+// A connected but busy server may need longer than the notice budget to answer.
+// Abandoning it then would discard the server's work and repeat it, so a slow
+// answer only shows a loading notice; it is treated as lost, unsubscribed and
+// retried only after the much longer cap.
 const SUBSCRIPTION_NOTICE_MS = 10_000;
 const SUBSCRIPTION_LOST_MS = 120_000;
 

package/src/server/actions.js

@@ -93,7 +93,7 @@ const conversationInputValidator = composeSchemaDefinitions(
   { mode: "patch", context: "assistant-runtime conversation action input" }
 );
 
-const conversationInspectInputValidator = composeSchemaDefinitions(
+const conversationDeliveryInputValidator = composeSchemaDefinitions(
   [conversationInputValidator, assistantConversationMessageIdInputValidator],
   { mode: "patch", context: "assistant-runtime conversation delivery inspection input" }
 );
@@ -217,7 +217,7 @@ function createConversationActions({ conversationRuntime, conversationDataSchema
       channels: ["api", "internal"],
       surfaces: runtimeSurfaces,
       permission: { require: "authenticated" },
-      input: conversationInspectInputValidator,
+      input: conversationDeliveryInputValidator,
       output: null,
       idempotency: "none",
       async execute(input, context) {
@@ -232,7 +232,7 @@ function createConversationActions({ conversationRuntime, conversationDataSchema
       channels: ["api", "internal"],
       surfaces: runtimeSurfaces,
       permission: { require: "authenticated" },
-      input: conversationInspectInputValidator,
+      input: conversationDeliveryInputValidator,
       output: null,
       idempotency: "none",
       async execute(input, context) {

package/src/server/repositories/conversationsRepository.js

@@ -228,8 +228,8 @@ function createRepository(knex) {
     };
   }
 
-  async function transaction(callback) {
-    return runInTransaction(knex, callback);
+  async function transaction(callback, options) {
+    return runInTransaction(knex, callback, options);
   }
 
   return Object.freeze({

package/src/server/services/chatService.js

@@ -236,9 +236,9 @@ function createChatService({
     const turns = conversationTurns.get(conversationId);
     turns.count -= 1;
     if (turns.count > 0) return;
-    // A failed disposal keeps the entry, as before: the next turn reuses it and
-    // runtime close retries its save.
-    turns.releasing = Promise.resolve(turns.handle?.dispose()).catch(() => {})
+    // A failed disposal, thrown or rejected, leaves the runtime entry open: the
+    // next turn reuses it and runtime close retries its save.
+    turns.releasing = Promise.try(() => turns.handle?.dispose()).catch(() => {})
       .finally(() => conversationTurns.delete(conversationId));
     await turns.releasing;
   }

package/src/server/sqlConversationStorage.js

@@ -167,10 +167,11 @@ function createSqlConversationStorage({ conversationsRepository, messagesReposit
           });
           entered = true;
           return storage[write ? "write" : "read"](id, operation);
-        });
+        }, { retries: 0 });
       } catch (error) {
         // SQLite cannot wait asynchronously for another connection's writer.
-        // Retry acquiring the snapshot/lock only; never replay a caller or save.
+        // Retry acquiring the snapshot/lock only; never replay a caller or save,
+        // so a deadlock victim is not run again either.
         if (entered || error.code !== "SQLITE_BUSY" || attempt >= 5) throw error;
         await delay(10 * 2 ** attempt);
       }

package/test/assistantConversationBinding.browser.test.js

@@ -887,8 +887,6 @@ for (const status of ["uncertain", "pending", "accepted", "failed", "unrecognise
         return runtime.canSubmit.value;
       }), false, "the uncertain request's own words cannot be sent again");
       await f.page.evaluate(draft => { window.savedBinding.runtime.value.draft.value = draft; }, saved.draft);
-    }
-    if (unconfirmed) {
       const check = f.primary.getByRole("button", { name: "Retry delivery check", exact: true });
       try { await expect(check).toBeEnabled(); }
       catch (failure) {
@@ -1137,6 +1135,85 @@ test("a deferred follow-up explains its wait and steers once the working turn ac
   await expect(f.primary.getByText(/^Pending/)).toHaveCount(0);
 });
 
+// An application keeps a retained view mounted but inactive while another
+// conversation is shown. A message waiting for admission there was never sent:
+// hiding its view must not fail it as "Message could not be sent.", and the
+// person who moved on must not have to return before it is sent.
+test("a deferred message sends while its view is hidden once the session admits it", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.readerActive = window.conversationFixture.activity(true);
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true, active: window.readerActive
+    });
+  });
+  const deferred = () => f.page.evaluate(() => {
+    const runtime = window.deferredBinding.runtime.value;
+    const { id, status, error, waiting } = runtime.delivery.state.messages.find(message => message.text === "Queued while working") || {};
+    return { available: runtime.available.value, status: runtime.snapshot.value?.status, message: { id, status, error, waiting },
+      subscriptions: window.conversationFixture.socket.inspect().active };
+  });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  const { subscriptions } = await deferred();
+  await f.page.evaluate(() => { window.original = window.deferredBinding.runtime.value.send({ message: "Original nonsteerable request" }); });
+  await expect.poll(async () => (await deferred()).status).toBe("working");
+  await f.page.evaluate(() => { window.queued = window.deferredBinding.runtime.value.send({ message: "Queued while working" }); });
+  await expect.poll(async () => (await deferred()).message.waiting).toBe("Waiting for the assistant to finish this step");
+  await f.page.evaluate(() => { window.readerActive.value = false; });
+  await expect.poll(async () => (await deferred()).available).toBe(false);
+  const hidden = await deferred();
+  assert.equal(hidden.message.status, "pending", `hiding the view is not a failed delivery: ${hidden.message.error}`);
+  assert.equal(hidden.subscriptions, subscriptions, "the waiting message keeps its live state");
+  assert.equal((await f.sent()).length, 1, "the working turn still cannot take the message");
+  await f.command("finish", { id: "chat:2" });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(2);
+  const [, followUp] = await f.sent();
+  assert.deepEqual([followUp.input.messageId, followUp.input.text], [hidden.message.id, "Queued while working"]);
+  assert.equal((await f.page.evaluate(() => window.queued)).status, "accepted");
+  const sent = await deferred();
+  assert.equal(sent.available, false, "the message was sent while its view stayed hidden");
+  await expect.poll(async () => (await deferred()).subscriptions, { message: "an empty queue releases the hidden view's subscription" }).toBe(subscriptions - 1);
+  await f.page.evaluate(() => { window.readerActive.value = true; });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  assert.equal((await f.sent()).length, 2, "the queued message is sent once");
+});
+
+// A lost subscription leaves the last snapshot shown with its error while it
+// retries. Its refresh then reads nothing, so that stale error says nothing
+// about the unsent message: it waits for the recovered state and sends once.
+test("a deferred message waits through a failing resubscription instead of failing", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true
+    });
+  });
+  const deferred = () => f.page.evaluate(() => {
+    const runtime = window.deferredBinding.runtime.value;
+    const { id, status, error } = runtime.delivery.state.messages.find(message => message.text === "Sent while reconnecting") || {};
+    return { available: runtime.available.value, error: runtime.error.value, message: { id, status, error } };
+  });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  let failing = true;
+  await f.page.route(url => url.pathname.endsWith("/conversations/chat%3A2"), route => failing && route.request().method() === "GET"
+    ? route.fulfill({ status: 503, contentType: "application/json", body: JSON.stringify({ error: "Conversation temporarily unavailable." }) })
+    : route.continue());
+  await f.page.evaluate(() => window.conversationFixture.socket.reconnect());
+  await expect.poll(async () => (await deferred()).error).toBe("Conversation temporarily unavailable.");
+  assert.equal((await deferred()).available, true, "the last snapshot stays shown");
+  await f.page.evaluate(() => { window.queued = window.deferredBinding.runtime.value.send({ message: "Sent while reconnecting" }); });
+  await expect.poll(async () => (await deferred()).message.status).toBe("pending");
+  const waiting = await deferred();
+  assert.equal((await f.sent()).length, 0, "nothing is admitted against the stale snapshot");
+  failing = false;
+  // The subscription's own retry, not the message, recovers the state.
+  await expect.poll(async () => (await f.sent()).length, { timeout: 15_000 }).toBe(1);
+  const [sent] = await f.sent();
+  assert.deepEqual([sent.input.messageId, sent.input.text], [waiting.message.id, "Sent while reconnecting"]);
+  assert.equal((await f.page.evaluate(() => window.queued)).status, "accepted");
+});
+
 for (const steer of [false, true]) {
   test(`Stop cancels locally queued native ${steer ? "steering" : "startup"} follow-ups`, options, async t => {
     const f = await fixture(t);

package/test/assistantConversationSubscriptions.test.js

@@ -342,6 +342,7 @@ test("a real subscription slower than ten seconds keeps its observer, says it is
   const barrier = f.holdNextRead(id);
   const view = f.view(socket, id);
   await until(f.changes, () => barrier.started);
+  const readStartedAt = performance.now();
   const subscriptionEpoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
   while (!view.errors.length) await once(f.changes, "change", { signal: AbortSignal.timeout(12_000) });
   assert.equal(view.errors[0].message, "Chat is still loading. Waiting for the server; Reload chat to try now.");
@@ -350,6 +351,9 @@ test("a real subscription slower than ten seconds keeps its observer, says it is
   assert.equal(socket.id, socketId);
   assert.equal(socket.connected, true);
   assert.equal(view.states.length, 0);
+  // The client's ten-second wait starts before the server's clock does, so the
+  // read is held until the server has also waited ten seconds.
+  await new Promise(resolve => setTimeout(resolve, Math.max(0, 10_001 - (performance.now() - readStartedAt))));
   barrier.resolve();
   await until(f.changes, () => view.states.length === 1);
   assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-wait");
@@ -1113,8 +1117,6 @@ function slowView(socket) {
 }
 
 test("a connected subscription keeps waiting for a slow server instead of abandoning its work at ten seconds", t => {
-  // Production: an overloaded daemon answered after 14-15 s; the client gave
-  // up at 10 s, unsubscribed and retried with 10 s again, so the chat never loaded.
   const { socket, subscribes, unsubscribes } = slowServerSocket(t);
   const { states, errors, subscription } = slowView(socket);
   t.mock.timers.tick(9_999);

package/test/chatServiceLifecycle.test.js

@@ -556,30 +556,30 @@ test("attachment identifiers use the conversation runtime's shape before any fil
   assert.deepEqual(calls, []);
 });
 
-function countDisposals(runtime) {
+// Counts the conversations the chat service opens and disposes in the runtime.
+function countDisposals() {
   const counts = { opened: 0, disposed: 0 };
-  return { counts, runtime: { ...runtime, async open(input) {
+  const wrapRuntime = (runtime) => ({ ...runtime, async open(input) {
     const handle = await runtime.open(input);
     counts.opened += 1;
     return { ...handle, async dispose(options) { counts.disposed += 1; return handle.dispose(options); } };
-  } } };
+  } });
+  return { counts, wrapRuntime };
 }
 
 test("each settled turn releases its conversation, and a later turn opens it again", async () => {
-  const counted = {};
-  const harness = createHarness([textCompletion("First answer."), textCompletion("Second answer.")], {
-    wrapRuntime(runtime) { Object.assign(counted, countDisposals(runtime)); return counted.runtime; }
-  });
+  const { counts, wrapRuntime } = countDisposals();
+  const harness = createHarness([textCompletion("First answer."), textCompletion("Second answer.")], { wrapRuntime });
 
   assert.equal((await harness.run("First question", { messageId: "message_1" })).status, "completed");
-  assert.deepEqual(counted.counts, { opened: 1, disposed: 1 }, "a finished turn keeps no runtime conversation open");
+  assert.deepEqual(counts, { opened: 1, disposed: 1 }, "a finished turn keeps no runtime conversation open");
   assert.equal((await harness.run("Second question", { messageId: "message_2" })).status, "completed");
-  assert.deepEqual(counted.counts, { opened: 2, disposed: 2 });
+  assert.deepEqual(counts, { opened: 2, disposed: 2 });
   assert.deepEqual(assistantMessages(harness.streamEvents), ["First answer.", "Second answer."]);
 });
 
 test("a conversation stays open until the last of its overlapping turns settles", async () => {
-  const counted = {};
+  const { counts, wrapRuntime } = countDisposals();
   const firstChunk = Promise.withResolvers();
   const continueResponse = Promise.withResolvers();
   async function* held() {
@@ -588,16 +588,39 @@ test("a conversation stays open until the last of its overlapping turns settles"
     await continueResponse.promise;
     yield { choices: [{ delta: {}, finish_reason: "stop" }] };
   }
-  const harness = createHarness([held()], {
-    wrapRuntime(runtime) { Object.assign(counted, countDisposals(runtime)); return counted.runtime; }
-  });
+  const harness = createHarness([held()], { wrapRuntime });
 
   const first = harness.run("First question", { messageId: "message_1" });
   await firstChunk.promise;
   // A second tab sends while the first answer is still running; the runtime refuses it.
   assert.equal((await harness.run("Second question", { messageId: "message_2" })).status, "failed");
-  assert.equal(counted.counts.disposed, 0, "the refused turn must not close the conversation the first turn still uses");
+  assert.equal(counts.disposed, 0, "the refused turn must not close the conversation the first turn still uses");
   continueResponse.resolve();
   assert.equal((await first).status, "completed");
-  assert.deepEqual(counted.counts, { opened: 2, disposed: 1 });
+  assert.deepEqual(counts, { opened: 2, disposed: 1 });
 });
+
+for (const failure of ["rejects", "throws"]) {
+  test(`a conversation whose disposal ${failure} is released like any failed disposal`, async () => {
+    const counts = { opened: 0, disposed: 0 };
+    let openError = null;
+    const wrapRuntime = (runtime) => ({ ...runtime, async open(input) {
+      if (openError) throw openError;
+      const handle = await runtime.open(input);
+      counts.opened += 1;
+      return { ...handle, dispose() {
+        counts.disposed += 1;
+        const error = new Error("The conversation could not be saved.");
+        if (failure === "throws") throw error;
+        return Promise.reject(error);
+      } };
+    } });
+    const harness = createHarness([textCompletion("First answer.")], { wrapRuntime });
+
+    assert.equal((await harness.run("First question", { messageId: "message_1" })).status, "completed",
+      "a failed disposal does not change the settled turn's outcome");
+    openError = new Error("The conversation runtime is closing.");
+    await assert.rejects(harness.run("Second question", { messageId: "message_2" }), /runtime is closing/u);
+    assert.deepEqual(counts, { opened: 1, disposed: 1 }, "a later turn never reuses or disposes the released turn's handle");
+  });
+}

package/test/sqlConversationStorage.test.js

@@ -81,6 +81,12 @@ test("the existing runtime storage contract uses the original SQL rows and rolls
     throw Object.assign(new Error("Caller failure"), { code: "SQLITE_BUSY" });
   }), /Caller failure/);
   assert.equal(invocations, 1, "Lock acquisition retry must never replay a storage callback");
+  invocations = 0;
+  await assert.rejects(f.storage.write(first.id, async () => {
+    invocations += 1;
+    throw Object.assign(new Error("Deadlock victim"), { code: "ER_LOCK_DEADLOCK", errno: 1213 });
+  }), /Deadlock victim/);
+  assert.equal(invocations, 1, "Deadlock retry must never replay a storage callback either");
 });
 
 test("independent SQL connections serialize authored receipt and sequence allocation", async t => {