@xema/omni-protocol 0.1.116 → 0.1.118

package/dist/index.d.ts

@@ -246,7 +246,8 @@ export interface SecretStore {
  * A small store for one login's operational state -- what an adapter holds about open work that
  * its platform cannot hold for it, such as the interaction legs a host reported. Kept by the host for
  * the life of the login, across a reload of the host, and cleared at sign-out. Never for anything
- * sensitive: that is `SecretStore`, whose contract is that a host may clear it aggressively.
+ * sensitive: that is `SecretStore`, whose contract is that a host may clear it aggressively, and
+ * clears it once the session has ended.
  */
 export interface LoginStore {
     get(key: string): Promise<string | undefined>;
@@ -318,6 +319,13 @@ export interface UserCapabilities {
  * Only `authenticated` and `refreshing` know who the agent is and what they may do, and only
  * `authenticated` has something to expire. A state carrying more than it knows is a state Omni
  * would render as fact.
+ *
+ * `signed-out` is the agent's own Sign out on this agent computer, and nothing else. `terminated`
+ * is a session ended from outside it -- a supervisor, the agent on another screen, the platform
+ * itself -- and says who: a person by id, or `provider` where no person was behind it, with the
+ * reason as a failure that is never retryable. `expired` is a session whose time ran out or whose
+ * refresh is failing. The stored secrets go with every ending: signed out, terminated, and expired
+ * unless its failure says `retryable: true`.
  */
 export type AuthenticationState = {
     status: "signed-out";
@@ -336,6 +344,13 @@ export type AuthenticationState = {
     status: "expired";
     identity?: User;
     failure?: AuthenticationFailure;
+} | {
+    status: "terminated";
+    by: UserId | "provider";
+    identity?: User;
+    failure: AuthenticationFailure & {
+        retryable: false;
+    };
 };
 export interface CredentialField {
     name: string;
@@ -401,6 +416,11 @@ export interface AuthenticationSession {
     complete(request: CompleteAuthenticationRequest): Promise<CompleteAuthenticationResult>;
     /** Cancels an abandoned SSO window or credentials form. */
     cancelAuthentication(flowId: string): Promise<AuthenticationActionResult>;
+    /**
+     * The agent's own Sign out. Tells the provider where it can, deletes the stored secrets whatever
+     * happened, and moves to `signed-out`; answers `failed` when the provider could not be told, so
+     * the host can show that a session may remain there. Never called for a `terminated` session.
+     */
     signOut(): Promise<AuthenticationActionResult>;
     close(): Promise<void>;
 }
@@ -493,40 +513,61 @@ export interface TaskRecordingPolicy {
         storageId: string;
     };
 }
-/** Current evidence only. Expiry/disconnect means unknown, never a historical stop. */
-export type RecordingState = {
-    status: "unknown";
-    observationId?: never;
-    observedAt?: never;
-    validUntil?: never;
-    recordingId?: never;
-} | ({
-    observationId: string;
-    observedAt: IsoTimestamp;
-    validUntil: IsoTimestamp;
+/** Whose side of the call a recording captures: the party's channel, or the agent's own. */
+export type RecordingSide = "party" | "agent";
+export declare const RECORDING_SIDES: readonly ["party", "agent"];
+/**
+ * Where a recording stands, as its recorder last stated it. `starting` is asked for and not yet
+ * confirmed. A stop or a pause in flight stays `recording` until the recorder confirms it, since
+ * telling the agent they are not recorded when they may be is the one thing this must never say.
+ */
+export type RecordingStatus = "starting" | "recording" | "paused" | "not-recording" | "unknown";
+export declare const RECORDING_STATUSES: readonly ["starting", "recording", "paused", "not-recording", "unknown"];
+/** Why a recording is paused: someone asked, or the platform paused it while sensitive details are taken. */
+export type RecordingPausedReason = "requested" | "sensitive-details";
+export declare const RECORDING_PAUSED_REASONS: readonly ["requested", "sensitive-details"];
+/** Why a recording's state is unknown: its recorder cannot be reached, or a command could not be settled either way. */
+export type RecordingUnknownReason = "recorder-unreachable" | "unsettled";
+export declare const RECORDING_UNKNOWN_REASONS: readonly ["recorder-unreachable", "unsettled"];
+/**
+ * One recording of one side of the call, published whenever it changes and restated whole with
+ * every publication of the task and on every snapshot. Nothing expires: the mark stands as last
+ * stated until its recorder says otherwise. `id` is the recorder's, minted when the start is
+ * accepted -- before the recorder has answered -- and kept through pause and resume; a later
+ * start is a new recording with a new id.
+ */
+export type Recording = {
+    id: string;
+    follows: RecordingSide;
 } & ({
-    status: "inactive";
-    recordingId?: never;
+    status: "starting" | "recording" | "not-recording";
+    reason?: never;
 } | {
-    status: "active" | "paused";
-    recordingId: string;
-}));
-/** Opaque IDs are scoped by login, task and recorder owner; preserved across pause/resume. */
+    status: "paused";
+    reason: RecordingPausedReason;
+} | {
+    status: "unknown";
+    reason: RecordingUnknownReason;
+});
+/**
+ * A start names the side to record; every other action names the recording by its id, and the
+ * recorder refuses one that no longer stands where the action needs it.
+ */
 export type RecordingCommand = {
     type: "recording";
     source: RecordingSource;
-    /** Compare-and-set against current evidence; never act on a replacement recording. */
-    observationId: string;
 } & ({
     action: "start";
+    follows: RecordingSide;
     recordingId?: never;
 } | {
     action: "pause" | "resume" | "stop" | "cancel";
     recordingId: string;
+    follows?: never;
 });
 export interface HostRecordingReport {
     assignmentId: AssignmentId;
-    state: RecordingState;
+    recordings: Recording[];
 }
 /** Host declaration in ConnectContext, not the provider-owned Manifest. */
 export interface HostRecording {
@@ -814,7 +855,7 @@ export type TaskAttribute = TaskAttributeBase & ({
     type: "timestamp";
     at: IsoTimestamp;
 });
-export type HistoryStep = "queued" | "offered" | "answered" | "held" | "muted" | "transferred" | "conferenced" | "unanswered";
+export type HistoryStep = "queued" | "offered" | "answered" | "held" | "muted" | "transferred" | "conferenced" | "unanswered" | "callback-requested";
 /**
  * The call record: the steps that brought the task here, one entry per occurrence and oldest
  * first, and what they add up to before this agent -- stated by the provider from its own record,
@@ -849,8 +890,9 @@ export interface TaskHistoryStep {
      */
     seconds?: DurationSeconds;
     /**
-     * Who took part. Absent on `queued`, where nobody does; absent on any other step means the
-     * provider could not attribute it, which is a different claim and a legitimate one.
+     * Who took part. Absent on `queued`, where nobody does; absent on `callback-requested`, where the
+     * caller chose it in the queue, and present there when an agent arranged it; absent on any other
+     * step means the provider could not attribute it, which is a different claim and a legitimate one.
      */
     by?: UserId;
     /** On a `muted` step, and only there: whose the silence was, as the host reported it. */
@@ -1044,15 +1086,13 @@ export type Task<C extends Channel = Channel> = {
     attributes?: TaskAttribute[];
     history?: TaskHistory;
 } & TaskCompletion & (C extends "voice" ? {
-    recording?: {
-        provider?: RecordingState;
-    };
+    recordings?: Recording[];
     onCall?: OnCall[];
     leadAssist?: TaskLeadAssist;
     takenOver?: TaskTakenOver;
     audio?: TaskAudioState;
 } : {
-    recording?: never;
+    recordings?: never;
     onCall?: never;
     leadAssist?: never;
     takenOver?: never;
@@ -1858,7 +1898,7 @@ export interface ProviderEventEnvelope<C extends Channel = Channel> {
     occurredAt: IsoTimestamp;
     event: ProviderEvent<C>;
 }
-export declare const OMNI_FAILURE_CODES: readonly ["omni.not-authenticated", "omni.capability-not-enabled", "omni.assignment-not-found", "omni.destination-not-permitted", "omni.phone-not-permitted", "omni.rate-limited", "omni.unavailable", "omni.break-already-committed", "omni.recording-unsettled", "omni.break-forced-by-provider"];
+export declare const OMNI_FAILURE_CODES: readonly ["omni.not-authenticated", "omni.capability-not-enabled", "omni.assignment-not-found", "omni.destination-not-permitted", "omni.phone-not-permitted", "omni.rate-limited", "omni.unavailable", "omni.break-already-committed", "omni.recording-unsettled", "omni.on-hold", "omni.break-forced-by-provider"];
 export type OmniFailureCode = (typeof OMNI_FAILURE_CODES)[number];
 /**
  * What the host refused, told to the adapter that published it: a snapshot the host would not
@@ -2002,7 +2042,10 @@ export declare const assignmentKey: (providerId: string, assignmentId: Assignmen
  * same provider; anything wider goes through this.
  */
 export declare const userKey: (providerId: string, userId: UserId) => string;
-/** Every history step somebody takes part in. `queued` is the one nobody does. */
+/**
+ * Every history step somebody from the provider takes part in. `queued` is the one nobody does, and
+ * `callback-requested` is the caller's choice unless an agent arranged it, so neither is here.
+ */
 export declare const HISTORY_STEPS_WITH_A_PERSON: readonly ["offered", "answered", "held", "muted", "transferred", "conferenced", "unanswered"];
 /** The steps a dial writes, and so the only ones that carry a `dialId` and a `destinationId`. */
 export declare const HISTORY_STEPS_THAT_DIAL: readonly ["transferred", "conferenced", "unanswered"];

package/dist/index.js

@@ -32,6 +32,10 @@ export const LISTENING_MODES = ["listen", "coach", "join-call"];
 export const MUTED_BY = ["host", "station"];
 export const HOST_MUTES = ["stream", "station"];
 export const RECORDING_ACTIONS = ["start", "pause", "resume", "stop", "cancel"];
+export const RECORDING_SIDES = ["party", "agent"];
+export const RECORDING_STATUSES = ["starting", "recording", "paused", "not-recording", "unknown"];
+export const RECORDING_PAUSED_REASONS = ["requested", "sensitive-details"];
+export const RECORDING_UNKNOWN_REASONS = ["recorder-unreachable", "unsettled"];
 // ---------------------------------------------------------------------------
 // Task workspace.
 // ---------------------------------------------------------------------------
@@ -107,6 +111,8 @@ export const OMNI_FAILURE_CODES = [
     "omni.break-already-committed",
     /** A recording command the provider could not settle either way: no start, stop, pause or resume it can vouch for. */
     "omni.recording-unsettled",
+    /** Refused because the caller is on hold: the host's Mute, or end-call, waits for resume. */
+    "omni.on-hold",
     /** A lead asked to lift a break the platform itself imposed; the platform lifts its own. */
     "omni.break-forced-by-provider",
 ];
@@ -158,7 +164,10 @@ export const assignmentKey = (providerId, assignmentId) => `${encodeURIComponent
  * same provider; anything wider goes through this.
  */
 export const userKey = (providerId, userId) => `${encodeURIComponent(providerId)}:${encodeURIComponent(userId)}`;
-/** Every history step somebody takes part in. `queued` is the one nobody does. */
+/**
+ * Every history step somebody from the provider takes part in. `queued` is the one nobody does, and
+ * `callback-requested` is the caller's choice unless an agent arranged it, so neither is here.
+ */
 export const HISTORY_STEPS_WITH_A_PERSON = [
     "offered", "answered", "held", "muted", "transferred", "conferenced", "unanswered",
 ];

package/dist/testing.d.ts

@@ -87,7 +87,7 @@ export declare function assertAuthenticationRestoreAndExpiry(states: readonly Au
  * Capabilities are current, not fixed. A provider that withdraws one republishes `authenticated`
  * with the new set, and the next snapshot agrees with it. `states` is what the authentication
  * session published, first to last: beginning and ending `authenticated` for the same identity,
- * passing only through usable states (`expired` or `signed-out` ends the login instead), with at
+ * passing only through usable states (`expired`, `terminated` or `signed-out` ends the login instead), with at
  * least one capability gone by the end. `snapshot` is the first snapshot published after the last
  * state, validated against that login -- so a team member list still published to a login that no longer
  * leads, or requests to one that may no longer join, is the failure.
@@ -160,8 +160,13 @@ export declare class TaskStream {
      */
     private holdCountdowns;
     private readonly dials;
+    private readonly placedHere;
     /** The host placed a dial: its outcome, whenever it arrives, is one the stream expects. */
     dialled(dialId: string): void;
+    /** A dial the test placed itself and the provider answered dialling: it is owed exactly one outcome. */
+    placedByTest(dialId: string): void;
+    /** The dials the test placed that never got their outcome. */
+    dialsWithoutOutcome(): string[];
     private noteDials;
     /**
      * Why an event names no open task: the assignment ended, so this is the late event that must not
@@ -250,6 +255,15 @@ export declare function stillHost(report?: HostReport, guarantees?: HostGuarante
     mute?: never;
     recording?: never;
 };
+/**
+ * One call's history as it reaches a second task: an earlier agent's task and a later one of the same
+ * call -- a hand-over, a take-over, a callback. The later task restates every earlier step, in order,
+ * as the earlier task had it: the same step, instant, person, dial and destination, and the same
+ * duration wherever the earlier task had already stated one (a leg still open there may be closed
+ * here). Throws on the first step that disagrees, and when either task carries no history, since
+ * two absent records agree about nothing.
+ */
+export declare function assertHistoryAgreesAcrossTasks(earlier: Task, later: Task): void;
 /** One provider as the host sees it when freezing the providers a break attempt asks. */
 export interface BreakCandidate {
     id: string;

package/dist/testing.js

@@ -309,6 +309,17 @@ export async function testAdapter(adapter, context, options = {}) {
             violations.push(...own);
             if (own.length > 0)
                 return;
+            // A session that has ended takes its secrets with it: the adapter deletes them before it
+            // publishes the ending, so a reload has nothing to restore. Only an expiry whose failure is
+            // retryable keeps them, for the retry.
+            if (sessionEnded(state)) {
+                ruleTested("authentication.secrets.retained");
+                if (storedSecrets.size > 0) {
+                    violations.push({ rule: "authentication.secrets.retained", path: "authentication.status",
+                        message: `the session is ${state.status} and the adapter still holds ${storedSecrets.size} stored secret(s): ` +
+                            "an ended session's secrets are deleted before the ending is published, or a reload restores it" });
+                }
+            }
             if (state.status === "refreshing") {
                 violations.push(...refreshingCarriesOver(current(), state, "authentication"));
             }
@@ -678,6 +689,12 @@ export async function testAdapter(adapter, context, options = {}) {
                 violations.push({ rule: "stream.taskOffered.unended", path: "event.task-ended",
                     message: `${id} was offered and never ended: every offer is owed a task-ended, whatever became of the call` });
             }
+            // Every dial the test placed, and the provider answered dialling, is owed exactly one outcome.
+            ruleTested("stream.dialOutcome.missing");
+            for (const id of stream.dialsWithoutOutcome()) {
+                violations.push({ rule: "stream.dialOutcome.missing", path: "event.dial-outcome",
+                    message: `${id} was answered dialling and never got its dial-outcome: every dial ends in exactly one, however it ended` });
+            }
         }
         // Capacity supersedes rather than accumulates, so a decrease is as ordinary as an increase: the
         // host raises it, lowers it, and takes it away, and the provider takes each as the ceiling it is.
@@ -904,6 +921,15 @@ export function assertAuthenticationRestoreAndExpiry(states) {
     }
 }
 /** The tasks an envelope carries: the one a task event names, or a snapshot event's list. */
+/** The failure code of a failed answer, as the provider stated it. */
+function failureCode(answer) {
+    return isRecord(answer.failure) ? answer.failure.code : undefined;
+}
+/** Whether a published state ends the session, so its stored secrets must already be gone. */
+function sessionEnded(state) {
+    return state.status === "signed-out" || state.status === "terminated"
+        || (state.status === "expired" && state.failure?.retryable !== true);
+}
 /** Whether a store key names the task: the id as a delimited token, never as a run of characters inside another id. */
 function namesTask(key, taskId) {
     return key.split(/[^A-Za-z0-9_-]+/).includes(taskId);
@@ -940,7 +966,7 @@ function notYetReadTasks(tasks, path) {
  * Capabilities are current, not fixed. A provider that withdraws one republishes `authenticated`
  * with the new set, and the next snapshot agrees with it. `states` is what the authentication
  * session published, first to last: beginning and ending `authenticated` for the same identity,
- * passing only through usable states (`expired` or `signed-out` ends the login instead), with at
+ * passing only through usable states (`expired`, `terminated` or `signed-out` ends the login instead), with at
  * least one capability gone by the end. `snapshot` is the first snapshot published after the last
  * state, validated against that login -- so a team member list still published to a login that no longer
  * leads, or requests to one that may no longer join, is the failure.
@@ -1173,11 +1199,19 @@ export class TaskStream {
     // task carried on `onCall` or in its record -- which is how a dial made before a take-over is known
     // to whoever holds the task now. `answered` or `ended` once its outcome arrived, since it comes once.
     dials = new Map();
+    placedHere = new Set();
     /** The host placed a dial: its outcome, whenever it arrives, is one the stream expects. */
     dialled(dialId) {
         if (!this.dials.has(dialId))
             this.dials.set(dialId, "placed");
     }
+    /** A dial the test placed itself and the provider answered dialling: it is owed exactly one outcome. */
+    placedByTest(dialId) {
+        this.dialled(dialId);
+        this.placedHere.add(dialId);
+    }
+    /** The dials the test placed that never got their outcome. */
+    dialsWithoutOutcome() { return [...this.placedHere].filter(id => this.dials.get(id) === "placed"); }
     noteDials(task) {
         if (!isRecord(task))
             return;
@@ -1840,6 +1874,7 @@ async function testOneCall(call) {
             call.stream.dialled(dialId);
             if (await send({ type: "dial", dialId }, dialId) === undefined)
                 return found;
+            call.stream.placedByTest(dialId);
         }
         if (latestTask().phase === "preview" && await updated(t => t.phase === "in-progress" || t.phase === "completing", pressCall ? "the task leaving preview after Call" : "the task leaving preview after the provider's dial") === undefined)
             return found;
@@ -1976,6 +2011,9 @@ async function testOneCall(call) {
         if (isRecord(answer) && answer.status !== "failed") {
             refuse("test.recordStep.held", "test.recordStep", "the provider recorded the host's mute begun with the caller on hold: the Mute waits for resume, and the adapter is the second gate");
         }
+        else if (isRecord(answer) && failureCode(answer) !== "omni.on-hold") {
+            refuse("test.recordStep.held", "test.recordStep", `the provider refused the mute begun on hold as ${String(failureCode(answer))}: a refusal because the caller is on hold answers omni.on-hold, so the agent application can say resume first`);
+        }
     };
     // Ending my part from hold would leave the caller in the hold with nobody coming back to them: a
     // host holds it back (command.endCall.held), and an adapter that receives it anyway must refuse
@@ -1995,6 +2033,9 @@ async function testOneCall(call) {
             // Applied, the task leaves paused; the run reads where the adapter put it rather than resuming a call it ended.
             await updated(t => t.phase !== "paused", "the task after an end-call applied from hold");
         }
+        else if (isRecord(answer) && failureCode(answer) !== "omni.on-hold") {
+            refuse("test.command.held", "test.command.end-call", `the provider refused end-call on hold as ${String(failureCode(answer))}: a refusal because the caller is on hold answers omni.on-hold, so the agent application can say resume first`);
+        }
     };
     // 4. Hold and resume, where offered.
     if (latestTask().phase === "in-progress" && offers("hold")) {
@@ -2327,6 +2368,39 @@ export function memoryStore() {
 export function stillHost(report = { online: true }, guarantees = {}, mute) {
     return { guarantees, ...(mute === undefined ? {} : { mute }), report: () => report, subscribe: () => () => undefined };
 }
+/**
+ * One call's history as it reaches a second task: an earlier agent's task and a later one of the same
+ * call -- a hand-over, a take-over, a callback. The later task restates every earlier step, in order,
+ * as the earlier task had it: the same step, instant, person, dial and destination, and the same
+ * duration wherever the earlier task had already stated one (a leg still open there may be closed
+ * here). Throws on the first step that disagrees, and when either task carries no history, since
+ * two absent records agree about nothing.
+ */
+export function assertHistoryAgreesAcrossTasks(earlier, later) {
+    const steps = (task, which) => {
+        const history = task.history;
+        if (history === undefined || !Array.isArray(history.steps)) {
+            throw new Error(`The ${which} task ${task.assignmentId} carries no history to compare`);
+        }
+        return history.steps;
+    };
+    const before = steps(earlier, "earlier");
+    const after = steps(later, "later");
+    if (after.length < before.length) {
+        throw new Error(`${later.assignmentId} restates ${after.length} step(s) of the call and ${earlier.assignmentId} already had ${before.length}: a later task carries every earlier step`);
+    }
+    before.forEach((step, index) => {
+        const restated = after[index];
+        for (const field of ["step", "at", "by", "dialId", "destinationId", "mutedBy"]) {
+            if (step[field] !== restated[field]) {
+                throw new Error(`steps[${index}].${field} is ${String(step[field])} on ${earlier.assignmentId} and ${String(restated[field])} on ${later.assignmentId}: one call has one history`);
+            }
+        }
+        if (step.seconds !== undefined && restated.seconds !== step.seconds) {
+            throw new Error(`steps[${index}].seconds is ${step.seconds} on ${earlier.assignmentId} and ${String(restated.seconds)} on ${later.assignmentId}: a stated duration does not change`);
+        }
+    });
+}
 const usableLogin = (status) => status === "authenticated" || status === "refreshing";
 /**
  * A break one provider forces stops the agent everywhere: the host states a capacity of zero on

package/dist/validation.d.ts

@@ -1,4 +1,4 @@
-import { type RecordingState, type Channel, type Phone, type ProtocolViolation, type UserCapabilities, type UserId } from "./index.js";
+import { type Channel, type Phone, type ProtocolViolation, type UserCapabilities, type UserId } from "./index.js";
 export type { ProtocolViolation } from "./index.js";
 export declare class ProtocolConformanceError extends Error {
     readonly violations: readonly ProtocolViolation[];
@@ -198,24 +198,34 @@ export declare function validateAuthenticationFailure(failure: unknown, path?: s
  */
 export declare function validateAuthenticationResult(result: unknown, method: "start" | "complete", path?: string, context?: LoginValidationContext): ProtocolViolation[];
 export declare function validateAuthenticationState(state: unknown, path?: string, context?: LoginValidationContext): ProtocolViolation[];
-export declare function validateRecordingState(value: unknown, path?: string): ProtocolViolation[];
-/** Supply a trusted current instant in the observer's clock domain. Undefined means clock unknown. */
-export declare function effectiveRecordingState(state: RecordingState | undefined, now: number | undefined): RecordingState;
+/**
+ * One recorder's recordings for one task, as published: each with its id, the side it follows,
+ * its status, and a reason where it is paused or unknown; ids unique, and at most one recording
+ * live on each side at once.
+ */
+export declare function validateRecordings(value: unknown, path?: string): ProtocolViolation[];
 export declare function validateRecordingPolicy(value: unknown, path?: string): ProtocolViolation[];
 export declare function validateHostRecording(value: unknown, softphone: boolean, path?: string): ProtocolViolation[];
 export declare function validateHostRecordings(value: unknown, path?: string): ProtocolViolation[];
 export declare function validateRecordingCommandShape(value: unknown, source: "provider" | "host", path?: string): ProtocolViolation[];
-/** Structural/state permission check. Dispatch MUST also call validateRecordingRequest for scope and freshness. */
-export declare function validateRecordingCommandState(command: unknown, policy: unknown, state: unknown, path?: string): ProtocolViolation[];
-/** Validate immediately before dispatch using current task, host report and trusted observer-domain time. */
+/**
+ * Whether the action is permitted on this recorder, and whether the recordings as last published
+ * let it act: a start on a side with nothing capturing, every other action on the recording it
+ * names, standing where the action needs it. Dispatch MUST also call validateRecordingRequest.
+ */
+export declare function validateRecordingCommandState(command: unknown, policy: unknown, recordings: unknown, path?: string): ProtocolViolation[];
+/** Validate immediately before dispatch, against the current task and, for the host's recorder, its declaration and report. */
 export declare function validateRecordingRequest(request: unknown, task: unknown, context: {
     source: "provider" | "host";
-    now: number | undefined;
     host?: unknown;
     hostReport?: unknown;
     softphone?: boolean;
     /** The same provider/task context used to validate the published task. */
     taskContext?: Omit<TaskValidationContext, "channel">;
 }, path?: string): ProtocolViolation[];
-/** Check recording-specific result semantics against the owner's confirming observations. */
+/**
+ * A recording command's answer against the recordings published before and after it: applied
+ * means the recorder confirmed what was asked -- a new recording on the side for a start, the
+ * same recording in its new status for anything else -- and failed means nothing changed there.
+ */
 export declare function validateRecordingOutcome(command: unknown, before: unknown, after: unknown, result: unknown, path?: string): ProtocolViolation[];