@xema/omni-protocol 0.1.72 → 0.1.74

package/dist/index.d.ts

@@ -174,6 +174,13 @@ export interface Manifest<C extends Channel = Channel> {
      * when it ended, and a running report is refused: what a provider never asked for never crosses.
      */
     runningStepReports?: true;
+    /**
+     * How long after an applied disposal -- `complete`, `transfer` `complete`, `lead-assist`
+     * `take-over` -- the provider's `task-ended` is owed, in milliseconds. `applied` says the provider
+     * has disposed of the task; the ending follows within this, or the host resyncs and shows the
+     * task as unsettled. Stated per provider, since platforms settle at different speeds.
+     */
+    disposalSettleMs: number;
 }
 export interface SecretStore {
     get(key: string): Promise<string | undefined>;

package/dist/testing.d.ts

@@ -133,6 +133,11 @@ export declare function assertReconnectWithMissedAssignments<C extends Channel>(
  * both.
  */
 export declare function assertDeniedAndRetriedBreak(approvals: readonly BreakApproval[]): void;
+/**
+ * The event kinds a snapshot restates, and so supersedes when delivered while it is read. Every
+ * other kind reports a transaction no snapshot carries, and a host applies it after the snapshot.
+ */
+export declare const SUPERSEDED_BY_A_SNAPSHOT: ReadonlySet<string>;
 export declare class TaskStream {
     private readonly tasks;
     private readonly allocations;

package/dist/testing.js

@@ -162,6 +162,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
     const stream = new TaskStream();
     const breaks = new BreakStream();
     let seeded = false;
+    const duringRead = [];
     const storedSecrets = new Map();
     const authenticationSecrets = {
         get: async (key) => storedSecrets.get(key),
@@ -369,9 +370,12 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 }
                 eventPayloads.set(envelope.id, payload);
             }
-            // Cross-event rules apply once the stream has a beginning: the connect snapshot.
+            // Cross-event rules apply once the stream has a beginning: the connect snapshot. An event
+            // delivered while that snapshot is read is held until it lands, and read then against it.
             if (seeded)
                 violations.push(...stream.apply(envelope), ...breaks.apply(envelope));
+            else
+                duringRead.push(envelope);
             events.push(envelope);
             for (const waiter of waiters)
                 waiter(envelope);
@@ -426,6 +430,32 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         stream.seed(snapshot);
         breaks.seed(snapshot);
         seeded = true;
+        // A snapshot supersedes what it restates and nothing else. Of the events held during the read,
+        // a state-replacing kind is dropped, since the snapshot carries that state and must account for
+        // it; the rest -- a dial's outcome, a diagnostic, an announcement, a queue summary -- report
+        // transactions no snapshot carries, and are applied after it, in order.
+        ruleEvaluated("snapshot.accounts.task", "snapshot.accounts.ended");
+        const carried = new Set();
+        for (const task of Array.isArray(snapshot?.tasks) ? snapshot.tasks : []) {
+            if (isRecord(task) && typeof task.allocationId === "string")
+                carried.add(task.allocationId);
+        }
+        for (const held of duringRead) {
+            const event = held.event;
+            if (!SUPERSEDED_BY_A_SNAPSHOT.has(String(event.type))) {
+                violations.push(...stream.apply(held), ...breaks.apply(held));
+                continue;
+            }
+            if ((event.type === "task-offered" || event.type === "task-updated") && isRecord(event.task) && typeof event.task.allocationId === "string" && !carried.has(event.task.allocationId)) {
+                violations.push({ rule: "snapshot.accounts.task", path: "snapshot.tasks",
+                    message: `${String(event.task.id)} (${event.task.allocationId}) was published while the snapshot was read and the snapshot does not carry it: a snapshot accounts for everything the adapter emitted before it resolved` });
+            }
+            if (event.type === "task-ended" && typeof event.allocationId === "string" && carried.has(event.allocationId)) {
+                violations.push({ rule: "snapshot.accounts.ended", path: "snapshot.tasks",
+                    message: `${String(event.taskId)} (${event.allocationId}) ended while the snapshot was read and the snapshot still carries it: a snapshot accounts for everything the adapter emitted before it resolved` });
+            }
+        }
+        duringRead.length = 0;
         requireCapabilityMethods(live, current().capabilities);
         if (publishesUserIds(snapshot)) {
             requireMethod(live, "describeUsers", "the snapshot publishes a UserId");
@@ -905,6 +935,14 @@ const REACHABLE_PHASES = {
     paused: new Set(["paused", "in-progress", "completing"]),
     completing: new Set(["completing"]),
 };
+/**
+ * The event kinds a snapshot restates, and so supersedes when delivered while it is read. Every
+ * other kind reports a transaction no snapshot carries, and a host applies it after the snapshot.
+ */
+export const SUPERSEDED_BY_A_SNAPSHOT = new Set([
+    "snapshot", "transport-status", "break-state", "task-offered", "task-updated", "task-ended",
+    "task-media-started", "task-media-ended", "team-updated", "contacts-updated", "calendar-updated",
+]);
 export class TaskStream {
     tasks = new Map();
     // Every allocation this login has seen, and the ones whose task has ended: an offer never reuses
@@ -1217,7 +1255,7 @@ async function driveOneCall(drive) {
     const refuse = (rule, path, message) => found.push({ rule, path, message });
     const isTask = (value) => isRecord(value) && typeof value.id === "string";
     // Wait for an envelope that satisfies `matches`, looking first at what already arrived.
-    const waitFor = (what, matches, from) => new Promise(resolve => {
+    const waitFor = (what, matches, from, within = { ms: drive.timeoutMs, onExpiry: () => refuse("drive.timeout", "drive", `the provider owed ${what} within ${drive.timeoutMs}ms and it never arrived`) }) => new Promise(resolve => {
         for (let index = from; index < drive.events.length; index += 1) {
             const hit = matches(drive.events[index]);
             if (hit !== undefined) {
@@ -1227,9 +1265,9 @@ async function driveOneCall(drive) {
         }
         const timer = setTimeout(() => {
             drive.waiters.delete(waiter);
-            refuse("drive.timeout", "drive", `the provider owed ${what} within ${drive.timeoutMs}ms and it never arrived`);
+            within.onExpiry();
             resolve(undefined);
-        }, drive.timeoutMs);
+        }, within.ms);
         const waiter = (envelope) => {
             const hit = matches(envelope);
             if (hit === undefined)
@@ -1368,10 +1406,10 @@ async function driveOneCall(drive) {
         return undefined;
     }, cursor).then(hit => { if (hit)
         cursor = hit.at; return hit; });
-    const ended = () => waitFor("a task-ended for the driven task", envelope => {
+    const ended = (within) => waitFor("a task-ended for the driven task", envelope => {
         const event = envelope.event;
         return event.type === "task-ended" && event.taskId === taskId ? event : undefined;
-    }, cursor);
+    }, cursor, within);
     // Every command the drive sends is validated against the task as published, and its answer for its method.
     ruleEvaluated("drive.timeout");
     const send = async (command, dialId) => {
@@ -1465,46 +1503,47 @@ async function driveOneCall(drive) {
     // 3b. The microphone is the host's. With the audio open, the drive mutes it for a moment and
     // reports the leg the provider's record would otherwise miss -- begun, then ended -- and
     // expects each report recorded. If the provider restates the task's record afterwards, the leg is in it.
-    let mutedLeg;
-    if (session !== undefined && typeof session.setMuted === "function" && typeof drive.connection.recordStep === "function") {
+    const reportedLegs = [];
+    const canRecordMute = session !== undefined && typeof session.setMuted === "function" && typeof drive.connection.recordStep === "function";
+    const report = async (body) => {
+        ruleEvaluated("drive.recordStep.rejected", "drive.recordStep.failed");
+        // The drive holds its own report to the contract before it crosses, as a host must.
+        const leg = { taskId, allocationId: allocationOf(), step: "muted", mutedBy: "host", ...body };
+        const own = validateHandlingReport(leg, "drive.recordStep.report", drive.manifest);
+        found.push(...own);
+        if (own.length > 0)
+            return;
+        let answer;
+        try {
+            answer = await drive.connection.recordStep(leg);
+        }
+        catch (error) {
+            refuse("drive.recordStep.rejected", "drive.recordStep", `recordStep rejected rather than answered: ${String(error)}`);
+            return;
+        }
+        found.push(...validateResult(answer, "recordStep", "drive.recordStep.result"));
+        if (isRecord(answer) && answer.status === "failed") {
+            refuse("drive.recordStep.failed", "drive.recordStep", `the provider refused to record the host's muted leg: ${String(isRecord(answer.failure) ? answer.failure.code : answer.failure)}`);
+        }
+    };
+    const setMuted = (muted) => {
+        try {
+            session.setMuted(muted);
+        }
+        catch {
+            refuse("drive.openMedia.setMuted", "drive.openMedia", `the media session threw on setMuted(${String(muted)})`);
+        }
+    };
+    if (canRecordMute) {
         const at = new Date().toISOString();
-        const report = async (body) => {
-            ruleEvaluated("drive.recordStep.rejected", "drive.recordStep.failed");
-            // The drive holds its own report to the contract before it crosses, as a host must.
-            const leg = { taskId, allocationId: allocationOf(), step: "muted", at, mutedBy: "host", ...body };
-            const own = validateHandlingReport(leg, "drive.recordStep.report", drive.manifest);
-            found.push(...own);
-            if (own.length > 0)
-                return;
-            let answer;
-            try {
-                answer = await drive.connection.recordStep(leg);
-            }
-            catch (error) {
-                refuse("drive.recordStep.rejected", "drive.recordStep", `recordStep rejected rather than answered: ${String(error)}`);
-                return;
-            }
-            found.push(...validateResult(answer, "recordStep", "drive.recordStep.result"));
-            if (isRecord(answer) && answer.status === "failed") {
-                refuse("drive.recordStep.failed", "drive.recordStep", `the provider refused to record the host's muted leg: ${String(isRecord(answer.failure) ? answer.failure.code : answer.failure)}`);
-            }
-        };
-        const setMuted = (muted) => {
-            try {
-                session.setMuted(muted);
-            }
-            catch {
-                refuse("drive.openMedia.setMuted", "drive.openMedia", `the media session threw on setMuted(${String(muted)})`);
-            }
-        };
         const began = Date.now();
         setMuted(true);
-        await report({});
+        await report({ at });
         // A leg's duration is whole seconds and a leg shorter than one cannot be stated, so the mute holds for one.
         await new Promise(resolve => setTimeout(resolve, 1000));
         setMuted(false);
-        await report({ seconds: Math.round((Date.now() - began) / 1000), ended: true });
-        mutedLeg = { at, task: latestTask() };
+        await report({ at, seconds: Math.round((Date.now() - began) / 1000), ended: true });
+        reportedLegs.push({ at, task: latestTask() });
         // 3c. A host reload destroys the adapter object and keeps the login's store. Built again from
         // the same login, a second adapter carries the task and the leg -- from its platform, or from
         // the store -- or it composed the record in memory and the record died with it.
@@ -1525,8 +1564,18 @@ async function driveOneCall(drive) {
             }
         }
     }
-    // 5. End the call, where the agent may.
+    // 5. End the call, where the agent may -- with the microphone muted, as agents do. The leg left
+    // open at media end is the provider's to close, since the provider knows the instant the media
+    // ended; the host's own closing report can only follow what it hears, is answered recorded, and
+    // changes nothing. So the drive mutes, does not report the end before end-call, and reports it
+    // after the media has ended.
     if (drive.channel === "voice" && latestTask().phase === "in-progress" && offers("endCall")) {
+        let openLeg;
+        if (canRecordMute) {
+            openLeg = { at: new Date().toISOString(), began: Date.now() };
+            setMuted(true);
+            await report({ at: openLeg.at });
+        }
         if (await send({ type: "end-call" }) !== undefined) {
             // A task that completes with its audio still up is refused by the stream as it passes
             // (stream.taskUpdated.mediaOpen); the drive does not also wait out the clock for an ending
@@ -1541,6 +1590,12 @@ async function driveOneCall(drive) {
             }, cursor);
             if (mediaEnded?.found === "ended")
                 cursor = mediaEnded.at;
+            if (openLeg !== undefined) {
+                setMuted(false);
+                // Stated at the record's grain: a leg that rounds to nought is 1.
+                await report({ at: openLeg.at, seconds: Math.max(1, Math.round((Date.now() - openLeg.began) / 1000)), ended: true });
+                reportedLegs.push({ at: openLeg.at, task: latestTask() });
+            }
             if (await updated(t => t.phase === "completing", "the task completing after its media ended") !== undefined && offers("hold")) {
                 await holdRefusedOutsideHandling();
             }
@@ -1564,18 +1619,42 @@ async function driveOneCall(drive) {
         if (isRecord(dispositions) && dispositions.required === true && Array.isArray(dispositions.codes) && isRecord(dispositions.codes[0])) {
             command.disposition = dispositions.codes[0].id;
         }
-        if (await send(command) !== undefined && await ended() !== undefined)
-            await storeReleased();
+        if (await send(command) !== undefined) {
+            // applied says the provider has disposed of the task, and its ending follows within the bound
+            // the manifest stated. Past it the host resyncs: a snapshot still carrying the task is a task
+            // held open by a provider that said it was done, and the desk shows it as unsettled.
+            ruleEvaluated("drive.disposal.unsettled");
+            const settle = Number(drive.manifest.disposalSettleMs);
+            let unsettled = false;
+            const end = await ended({ ms: settle, onExpiry: () => { unsettled = true; } });
+            if (end !== undefined)
+                await storeReleased();
+            else if (unsettled) {
+                let resync;
+                try {
+                    resync = await drive.connection.snapshot();
+                }
+                catch (error) {
+                    refuse("drive.command.rejected", "drive.disposal", `snapshot() after an unsettled disposal rejected: ${String(error)}`);
+                }
+                const still = isRecord(resync) && Array.isArray(resync.tasks) && resync.tasks.some(t => isRecord(t) && t.id === taskId && t.allocationId === allocationOf());
+                refuse("drive.disposal.unsettled", "drive.disposal", still
+                    ? `complete was applied and ${settle}ms later the task-ended has not come and a snapshot still carries ${taskId}: applied says the provider disposed of the task, and it has not`
+                    : `complete was applied and ${settle}ms later the task-ended has not come; a snapshot no longer carries ${taskId}, so the ending was owed and never sent`);
+            }
+        }
     }
     else if (latestTask().phase === "completing") {
         if (await ended() !== undefined)
             await storeReleased();
     }
-    // The record kept by the provider has the leg the host reported, wherever the provider restated it.
-    if (mutedLeg !== undefined && latestTask() !== mutedLeg.task) {
+    // The record kept by the provider has every leg the host reported, wherever the provider restated it.
+    for (const reported of reportedLegs) {
+        if (latestTask() === reported.task)
+            continue;
         const history = latestTask().handlingHistory;
         if (isRecord(history) && Array.isArray(history.steps)) {
-            const { at } = mutedLeg;
+            const { at } = reported;
             const leg = history.steps.find(entry => isRecord(entry) && entry.step === "muted" && entry.at === at);
             if (leg === undefined) {
                 refuse("drive.recordStep.history", "drive.recordStep", `the provider restated the task's record after the host reported a muted leg at ${at}, and the leg is not in it`);

package/dist/validation.js

@@ -422,6 +422,7 @@ export function validateManifest(manifest, path = "manifest") {
     if (manifest.runningStepReports !== undefined) {
         into.require(manifest.runningStepReports === true, "manifest.runningStepReports", `${path}.runningStepReports`, "runningStepReports is declared by presence, as true; a provider that takes begin and end only omits it");
     }
+    into.require(typeof manifest.disposalSettleMs === "number" && Number.isInteger(manifest.disposalSettleMs) && manifest.disposalSettleMs > 0, "manifest.disposalSettleMs", `${path}.disposalSettleMs`, "disposalSettleMs is how long after an applied disposal the task-ended is owed, a positive whole number of milliseconds, stated by every provider");
     if (manifest.orgLevels !== undefined) {
         if (!Array.isArray(manifest.orgLevels)) {
             into.add("manifest.orgLevels.shape", `${path}.orgLevels`, "orgLevels must be an array when present");
@@ -778,7 +779,7 @@ function validateHandlingHistory(value, path, into, task = {}) {
                 into.require(task.phase === "paused", "task.handlingHistory.held.open", `${at}.seconds`, `a held entry without seconds is a hold still running, and the task is ${String(task.phase)}: the hold has ended, and its duration is stated`);
             }
             if (entry.step === "muted") {
-                into.require(task.media !== "ended" && task.phase !== "completing", "task.handlingHistory.muted.open", `${at}.seconds`, "a muted entry without seconds is a mute still running, and the call is over: the host ends its legs when the media ends, and the duration is stated");
+                into.require(task.media !== "ended" && task.phase !== "completing", "task.handlingHistory.muted.open", `${at}.seconds`, "a muted entry without seconds is a mute still running, and the call is over: the provider closes every open leg at the instant the media ends, and the duration is stated");
             }
         }
         // A muted entry carries whose the silence was, as the host reported it; no other step has it.

package/guide.md

@@ -193,6 +193,7 @@ type Manifest<C extends Channel = Channel> = {
   dialOutcomes?: C extends "voice" ? DialOutcome[] : never;
   phones?: C extends "voice" ? Phone[] : never;
   runningStepReports?: true;
+  disposalSettleMs: number;
 };
 ```
 
@@ -1471,6 +1472,7 @@ export default defineAdapter({
     channel: "voice",
     supportedProtocolVersions: [OMNI_PROTOCOL_VERSION],
     authenticationMethods: ["browser-sso"],
+    disposalSettleMs: 5000,
     idleCapabilities: {
       dial: { destinations: "any-number" },
     },
@@ -1506,6 +1508,7 @@ compile time.
 | `phones` | Voice only, and required there: the phones this platform can put an agent on, `softphone` (the call's audio lands in the host) and/or `deskPhone` (a handset the platform rings; the host shows the call and opens nothing). The host picks one per login. See **How the agent hears the call**. |
 | `dialOutcomes` | Voice only. How a dial can end on this platform, as it distinguishes them: `answered` and at least one way of not reaching the destination. Required of a provider that dials at all — an idle dialpad, or tasks that transfer, conference or call back — and a `dial-outcome` carries only a declared member. See **Every dial has an outcome**. |
 | `runningStepReports` | The provider takes running reports of a host-performed step — `recordStep` with `seconds` so far and no `ended`. Omitted, the host sends exactly two reports per leg, when it began and when it ended, and a running one is refused. See **The host records what it performs**. |
+| `disposalSettleMs` | Required. How long after an applied disposal -- `complete`, `transfer` `complete`, `lead-assist` `take-over` -- the provider's `task-ended` is owed, a positive whole number of milliseconds (`manifest.disposalSettleMs`). Stated per provider, since platforms settle at different speeds. See **`task-ended`**. |
 
 ### Authentication methods
 
@@ -2061,9 +2064,15 @@ report that: `granted` is a promise to honour a later commit.
 
 Returns the provider's complete authoritative state at one point in time.
 
-- Omni registers `subscribe()` before awaiting the initial snapshot and discards anything delivered
-  while the snapshot is read, because the snapshot accounts for it. Events after it are applied in
-  order.
+- Omni registers `subscribe()` before awaiting the initial snapshot. An event delivered while the
+  snapshot is read is held until it lands, and what happens to it then depends on what it is. A
+  snapshot restates state, so an event of a state-replacing kind -- `task-offered`, `task-updated`,
+  `task-ended`, `task-media-started`, `task-media-ended`, `break-state`, `team-updated`,
+  `contacts-updated`, `calendar-updated`, `transport-status`, `snapshot` -- is dropped, because the
+  snapshot accounts for it. An event that reports a transaction no snapshot carries --
+  `dial-outcome`, `diagnostic`, `announcement`, `queue-summary` -- is applied after the snapshot,
+  in order: a dial's outcome delivered during a resync still ends the dial, and **Every dial has an
+  outcome** holds through a snapshot. Events after it are applied in order.
 - `tasks` must contain every task currently owned by this agent for this provider.
 - A snapshot replaces Omni's state for this provider; it is not a partial patch.
 - The adapter may return synchronously when it already holds current live values, or
@@ -2537,7 +2546,13 @@ only while its media is up, so a `held` entry without `seconds` on a task that i
 (`task.handlingHistory.held.open`, `.muted.open`). Whoever performs the leg closes it — the
 provider whose platform parks the caller, the host whose microphone it is — by restating the entry
 with its duration, and **an entry that cannot be closed is not written**: open for ever is a
-plausible nought one level down from a total. There is no resumed step; a resume is the end of a
+plausible nought one level down from a total. **A leg still open when the media ends is closed by
+the provider**, at that instant, in the same publication that says the media ended: the provider
+is the one that knows the instant, and the host can only learn of it afterwards. Agents end calls
+muted, so the host's leg is routinely open at media end; the provider closes it with the duration
+from the leg's `at` to the media's end, and the host's own closing report for that leg, which
+follows what it hears, is answered `recorded` and changes nothing, the entry standing as the
+provider closed it. One publisher of the closed leg, and no order between them to get right. There is no resumed step; a resume is the end of a
 hold, at the entry's `at` plus its `seconds`, and nothing is lost by not naming it twice. The same goes for every step: two mutes are two
 `muted` entries, and a call that joined two queues -- a menu's, then this one -- has two `queued`
 entries, one per join. Order is enforced: an entry earlier than the one before it is refused
@@ -4344,9 +4359,13 @@ a backend that does not know the session yet — yields no snapshot, and the ada
 `connecting` holding what it holds. See **Snapshots establish state; events report transactions**.
 
 A snapshot must account for **everything the adapter has emitted before it resolves**, not merely
-everything emitted when it was requested. Omni discards events buffered during the read on that
-promise; an adapter that serves a stale snapshot and then lets an earlier event through will have
-Omni apply state the snapshot already superseded.
+everything emitted when it was requested. Omni drops the state-replacing events held during the
+read on that promise, and applies the rest after it (see **`Connection.snapshot()`**); an adapter
+that serves a stale snapshot and then lets an earlier event through will have Omni apply state the
+snapshot already superseded. The harness reads its connect snapshot the same way, and holds the
+snapshot to accounting for every task event it superseded: a task published during the read and
+missing from the snapshot, or ended during the read and still carried, is named
+(`snapshot.accounts.task`, `snapshot.accounts.ended`).
 
 #### Liveness
 
@@ -4492,8 +4511,16 @@ Every outcome ends the task for this agent. On `task-ended`, Omni:
 A `left` outcome ends the task for this agent alone: the call continues without them, as it does
 when a lead who joined it leaves -- see **Lead assist**.
 
-A successful `complete` or `transfer` command does not clear the task. Omni waits for `task-ended`.
-The `task-media-ended` event and the `completing` phase are likewise non-terminal. A replacement
+A successful `complete` or `transfer` command does not clear the task. Omni waits for `task-ended`,
+and not for ever: `applied` to a disposal -- `complete`, `transfer` `complete`, `lead-assist`
+`take-over` -- says the provider has disposed of the task, and its `task-ended` follows within the
+manifest's `disposalSettleMs`. A provider never answers `applied` for a disposal it has not yet
+performed. Past the bound the host calls `snapshot()`: a snapshot still carrying the task is a task
+held open by a provider that said it was done, and the desk shows it as unsettled -- "Completing...
+the provider has not confirmed" -- naming the command; a snapshot no longer carrying it clears the
+task, since the ending was owed and lost. The drive holds a provider to the same bound
+(`drive.disposal.unsettled`). The `task-media-ended` event and the `completing` phase are likewise
+non-terminal. A replacement
 snapshot that no longer contains the task also clears it. Repeated `task-ended` delivery with the
 same envelope ID is harmless, and a `task-ended` naming an allocation that has already ended is
 recognised as the late event it is, never applied to the life now open under the same id.
@@ -4714,8 +4741,11 @@ as each case was considered, so a test that needs a rule to have run asserts it
 inferring it from an empty `violations`, and a rule absent from it was never looked at, which is a
 gap and not a pass. With the audio open on a softphone,
 the drive mutes it for one second and reports the leg through `recordStep`, begun and then ended,
-expecting each report `recorded` (`drive.recordStep.failed`, `.rejected`); and where the provider
-restates the task's record afterwards, the leg is in it or the hole is named
+expecting each report `recorded` (`drive.recordStep.failed`, `.rejected`); then it mutes again and
+ends the call muted, as agents do, so the leg is open when the media ends, the provider closes it
+in the completing publication or the open entry is refused (`task.handlingHistory.muted.open`),
+and the drive's closing report after the media ended is expected `recorded` and to change nothing.
+Where the provider restates the task's record afterwards, each leg is in it or the hole is named
 (`drive.recordStep.history`). Given `rebuild`, a way to build the adapter again as a host reload
 does, the drive reloads the host as a reload happens: the first client is unsubscribed,
 disconnected and its session closed (`drive.reload.handover`), and only then is a second adapter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xema/omni-protocol",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "description": "The Omni protocol: the contract every provider adapter implements",
   "type": "module",
   "license": "MIT",