@xema/omni-protocol 0.1.80 → 0.1.82

package/dist/index.d.ts

@@ -427,7 +427,85 @@ export type HostAudioOutput =
  */
 /** What Omni's own chrome shows of a task browser's URL: nothing, the domain, or all of it. */
 export type UrlVisibility = "full" | "domain" | "hidden";
+/** Independent recorder owners. A command never targets both. */
+export type RecordingSource = "provider" | "host";
+export type RecordingAction = "start" | "pause" | "resume" | "stop" | "cancel";
+export declare const RECORDING_ACTIONS: readonly ["start", "pause", "resume", "stop", "cancel"];
+export interface RecordingActions {
+    start?: true;
+    pause?: true;
+    resume?: true;
+    stop?: true;
+    /** Abandon this recording and discard its captured audio. */
+    cancel?: true;
+}
+/** Per-task permission, not a provider-wide recording switch. Absence grants nothing. */
+export interface TaskRecordingPolicy {
+    provider?: RecordingActions;
+    host?: RecordingActions & {
+        destinationId: 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;
+} & ({
+    status: "inactive";
+    recordingId?: never;
+} | {
+    status: "active" | "paused";
+    recordingId: string;
+}));
+/** Opaque IDs are scoped by login, task and recorder owner; preserved across pause/resume. */
+export type RecordingCommand = {
+    type: "recording";
+    source: RecordingSource;
+    requestId: string;
+    /** Compare-and-set against current evidence; never act on a replacement recording. */
+    observationId: string;
+} & ({
+    action: "start";
+    recordingId?: never;
+} | {
+    action: "pause" | "resume" | "stop" | "cancel";
+    recordingId: string;
+});
+export interface HostRecordingReport {
+    taskId: TaskId;
+    allocationId: AllocationId;
+    state: RecordingState;
+}
+/** Host declaration in ConnectContext, not the provider-owned Manifest. */
+export interface HostRecording {
+    /** Audible recording status announcements to the remote party, for host-owned capture only. */
+    announcesToCaller?: true;
+    actions: RecordingAction[];
+    /** Explicitly provisioned destinations. A task chooses one; no upload/storage fallback. */
+    destinationIds: string[];
+    execute(request: HostRecordingRequest): Promise<RecordingCommandResult>;
+}
+/** Recording applies or fails; it never dials. Rejection without result means unknown. */
+export type RecordingCommandResult = Exclude<TaskCommandResult, {
+    status: "dialling";
+}>;
+export interface HostRecordingRequest {
+    taskId: TaskId;
+    allocationId: AllocationId;
+    command: RecordingCommand & {
+        source: "host";
+    };
+}
 export interface HostReport {
+    /** Full current host-owned recording view; never provider-owned state. */
+    recordings?: HostRecordingReport[];
     /** Whether the host has a network interface up. Not a claim that anything is reachable: the adapter knows its own platform's reachability better than the host does. */
     online: boolean;
     audio?: {
@@ -449,6 +527,8 @@ export interface HostGuarantees {
     personConsent?: true;
 }
 export interface Host {
+    /** Voice softphone recording support; policy and destination remain per task. */
+    recording?: HostRecording;
     guarantees: HostGuarantees;
     /** What pressing Mute does on this host. Stated on a softphone login, where the host holds the microphone; absent on a desk phone and off voice. */
     mute?: HostMute;
@@ -494,6 +574,7 @@ export type ConnectContext = {
     phone?: "deskPhone";
     host: {
         mute?: never;
+        recording?: never;
     };
 });
 export type TransportStatus = "connecting" | "active" | "error";
@@ -581,7 +662,7 @@ export type TaskCapabilities<C extends Channel = Channel> = C extends "voice" ?
     /** Ask a lead to join this call, with a note. The lead's decision arrives on `Task.leadAssist`. */
     leadAssist?: Lockable<true>;
     conference?: Lockable<DestinationDirectory>;
-    recording?: Lockable<true>;
+    recording?: Lockable<TaskRecordingPolicy>;
 } : C extends "chat" ? SharedTaskCapabilities & {
     decline?: Lockable<true>;
     hold?: Lockable<true>;
@@ -888,12 +969,16 @@ export type Task<C extends Channel = Channel> = {
     attributes?: TaskAttribute[];
     handlingHistory?: TaskHandlingHistory;
 } & TaskCompletion & (C extends "voice" ? {
+    recording?: {
+        provider?: RecordingState;
+    };
     onCall?: OnCall[];
     leadAssist?: TaskLeadAssist;
     assisting?: TaskAssisting;
     monitoring?: TaskMonitoring;
     media?: TaskMediaState;
 } : {
+    recording?: never;
     onCall?: never;
     leadAssist?: never;
     assisting?: never;
@@ -1040,10 +1125,9 @@ export type VoiceTaskCommand = {
     action: "remove";
     party: true;
     destinationId?: never;
-} | {
-    type: "recording";
-    action: "start" | "pause" | "resume" | "stop";
-} | ({
+} | (RecordingCommand & {
+    source: "provider";
+}) | ({
     type: "complete";
 } & DispositionPayload);
 export type ChatTaskCommand = {

package/dist/index.js

@@ -29,6 +29,7 @@ export const IDLE_CAPABILITY_UI = {
 export const MONITOR_MODES = ["monitor", "whisper", "barge"];
 export const MUTED_BY = ["host", "station"];
 export const HOST_MUTES = ["stream", "station"];
+export const RECORDING_ACTIONS = ["start", "pause", "resume", "stop", "cancel"];
 // ---------------------------------------------------------------------------
 // Task workspace.
 // ---------------------------------------------------------------------------

package/dist/testing.d.ts

@@ -220,6 +220,7 @@ export declare function stillHost(report: HostReport, guarantees: HostGuarantees
 };
 export declare function stillHost(report?: HostReport, guarantees?: HostGuarantees): Host & {
     mute?: never;
+    recording?: never;
 };
 /** One provider as the host sees it when freezing the providers a break attempt asks. */
 export interface BreakCandidate {

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { browserSessionKey, effectiveLevels, sameCapabilities, } from "./index.js";
-import { assertNoViolations, validateAuthenticationState, validateEventEnvelope, validateHostGuarantees, validateHostReport, validateDescribedUsers, observeRules, ruleEvaluated, validateHostMute, validateLoginStore, validateHandlingReport, validateManifest, validateResult, validateSnapshot, validateTask, validateTimeZone, validatePhone, validateTaskCommand, isTimeZone, sameTimeZone, } from "./validation.js";
+import { assertNoViolations, validateAuthenticationState, validateEventEnvelope, validateHostGuarantees, validateHostReport, validateDescribedUsers, observeRules, ruleEvaluated, validateHostMute, validateHostRecording, validateLoginStore, validateHandlingReport, validateManifest, validateResult, validateSnapshot, validateTask, validateTimeZone, validatePhone, validateTaskCommand, isTimeZone, sameTimeZone, } from "./validation.js";
 export { ProtocolConformanceError, assertNoViolations } from "./validation.js";
 /**
  * A part of the contract a run may never reach: state nothing obliges an adapter to publish, so
@@ -267,6 +267,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         // audio and reports it; on a desk phone, or off voice, there is none for it to report.
         violations.push(...validatePhone(context.phone, adapter.manifest, "context.phone"));
         const softphone = adapter.manifest.channel === "voice" && context.phone === "softphone";
+        violations.push(...validateHostRecording(context.host.recording, softphone));
         const first = context.host.report();
         violations.push(...validateHostReport(first, "context.host"));
         const hasAudio = isRecord(first) && first.audio !== undefined;
@@ -291,6 +292,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         // The wrapped host carries the mute kind the test's host stated, so the arms of ConnectContext still hold.
         const host = {
             guarantees: context.host.guarantees,
+            ...(context.host.recording === undefined ? {} : { recording: context.host.recording }),
             ...(context.host.mute === undefined ? {} : { mute: context.host.mute }),
             report: () => { consulted.report = true; return context.host.report(); },
             subscribe: listener => { consulted.subscribe = true; return context.host.subscribe(listener); },
@@ -870,11 +872,11 @@ export function assertTaskCapabilityWithdrawal(tasks, manifest, command) {
     if (withdrawn.length === 0) {
         throw new Error("Task capability withdrawal must end with at least one capability the offer declared withdrawn; a locked control is present without permission, not withdrawn");
     }
-    const before = validateTaskCommand(command, first, "command");
+    const before = validateTaskCommand(command, first, "command", context);
     if (before.length > 0) {
         throw new Error(`Task capability withdrawal: the command must be issuable against the task as offered, or its later refusal proves nothing (${before.map(v => v.rule).join(", ")})`);
     }
-    const after = validateTaskCommand(command, last, "command");
+    const after = validateTaskCommand(command, last, "command", context);
     const forWant = after.filter(v => withdrawn.some(name => v.rule === `command.capability.${name}`));
     if (forWant.length === 0) {
         throw new Error(`Task capability withdrawal: the command must be refused against the republished task for want of ${withdrawn.join(" or ")}; it was ${after.length === 0 ? "accepted" : `refused for ${after.map(v => v.rule).join(", ")}`}`);
@@ -1558,7 +1560,11 @@ async function driveOneCall(drive) {
     // 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) => {
-        const own = validateTaskCommand(command, latestTask(), `drive.command.${String(command.type)}`);
+        const own = validateTaskCommand(command, latestTask(), `drive.command.${String(command.type)}`, {
+            levels: effectiveLevels(drive.manifest.orgLevels).map(level => level.id),
+            dialOutcomesDeclared: drive.manifest.dialOutcomes !== undefined,
+            autoAcceptTasks: drive.context.autoAcceptTasks,
+        });
         found.push(...own);
         if (own.length > 0)
             return undefined;

package/dist/validation.d.ts

@@ -1,4 +1,4 @@
-import { type ProtocolViolation, type UserCapabilities, type UserId } from "./index.js";
+import { type RecordingState, 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[];
@@ -100,7 +100,7 @@ export declare function validateHostReport(report: unknown, path?: string): Prot
  * own shape is checked. A host validates before sending, and an adapter before acting: a command
  * for a control the task never offered is the host's error, and this names it.
  */
-export declare function validateTaskCommand(command: unknown, task?: unknown, path?: string): ProtocolViolation[];
+export declare function validateTaskCommand(command: unknown, task?: unknown, path?: string, taskContext?: Omit<TaskValidationContext, "channel">): ProtocolViolation[];
 /** The connection methods whose results `validateResult` knows. */
 export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamLeadAssist" | "executeTeamMonitor" | "openMedia" | "setPreference" | "recordStep" | "executeTeamPolicy";
 /**
@@ -135,3 +135,24 @@ 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;
+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. */
+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. */
+export declare function validateRecordingOutcome(command: unknown, before: unknown, after: unknown, result: unknown, path?: string): ProtocolViolation[];

package/dist/validation.js

@@ -9,7 +9,7 @@
 // Each list is pinned to its type both ways -- a member the type lacks, or a member the list
 // lacks, fails to compile -- so what the validators accept cannot drift from what the
 // declarations say.
-import { ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, MONITORING_BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, HANDLING_STEPS_THAT_DIAL, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, TASK_COMMAND_NAMES, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
+import { RECORDING_ACTIONS, ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, MONITORING_BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, HANDLING_STEPS_THAT_DIAL, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, TASK_COMMAND_NAMES, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
 export class ProtocolConformanceError extends Error {
     violations;
     constructor(violations, summary = "Adapter violates the Omni protocol") {
@@ -1116,6 +1116,17 @@ function validateTaskInto(task, context, path, into) {
     if (context.locked !== undefined && isPlainObject(task.party) && (isLocked(task.party.number) || isLocked(task.party.email))) {
         validateNothingLeaksInto(task, context.locked, path, into);
     }
+    if (task.recording !== undefined) {
+        into.require(context.channel === "voice", "recording.task.channel", `${path}.recording`, "recording is voice-only");
+        if (!isPlainObject(task.recording))
+            into.add("recording.task.shape", `${path}.recording`, "expected provider recording state");
+        else {
+            for (const key of Object.keys(task.recording))
+                into.require(key === "provider", "recording.task.owner", `${path}.recording.${key}`, "host state belongs in HostReport, never provider task updates");
+            if (task.recording.provider !== undefined)
+                into.violations.push(...validateRecordingState(task.recording.provider, `${path}.recording.provider`));
+        }
+    }
     validateBrowsers(task.browsers, `${path}.browsers`, into);
     validateTaskAttributes(task.attributes, `${path}.attributes`, into, context.levels);
     validateHandlingHistory(task.handlingHistory, `${path}.handlingHistory`, into, { phase: task.phase, media: task.media });
@@ -1181,6 +1192,9 @@ function validateTaskInto(task, context, path, into) {
             continue;
         }
         switch (name) {
+            case "recording":
+                into.violations.push(...validateRecordingPolicy(declared, `${path}.capabilities.recording`));
+                break;
             case "dispositions":
                 validateDispositions(declared, `${path}.capabilities.dispositions`, into);
                 break;
@@ -1946,6 +1960,7 @@ export function validateHostReport(report, path = "host") {
         return into.violations;
     }
     into.require(typeof report.online === "boolean", "host.online", `${path}.online`, "a host report says whether it has a network");
+    into.violations.push(...validateHostRecordings(report.recordings, `${path}.recordings`));
     if (report.audio === undefined)
         return into.violations;
     if (!isPlainObject(report.audio)) {
@@ -2005,7 +2020,6 @@ export function validateHostReport(report, path = "host") {
 const TRANSFER_ACTIONS = ["cold", "warm", "complete", "cancel"];
 const LEAD_ASSIST_ACTIONS = ["request", "cancel", "take-over", "leave"];
 const CONFERENCE_ACTIONS = ["add", "remove"];
-const RECORDING_ACTIONS = ["start", "pause", "resume", "stop"];
 /**
  * What a command needs to be issuable, checked against the task it names: the capability the
  * guide's table gates it on, the phase it belongs to, and the state that has to stand -- a
@@ -2013,7 +2027,7 @@ const RECORDING_ACTIONS = ["start", "pause", "resume", "stop"];
  * own shape is checked. A host validates before sending, and an adapter before acting: a command
  * for a control the task never offered is the host's error, and this names it.
  */
-export function validateTaskCommand(command, task, path = "command") {
+export function validateTaskCommand(command, task, path = "command", taskContext) {
     const into = new Collector();
     if (!isPlainObject(command)) {
         into.add("command.shape", path, "a command must be an object");
@@ -2068,7 +2082,7 @@ export function validateTaskCommand(command, task, path = "command") {
             }
             break;
         case "recording":
-            into.oneOf(command.action, RECORDING_ACTIONS, "command.recording.action", `${path}.action`);
+            into.violations.push(...validateRecordingCommandShape(command, "provider", path));
             break;
         case "complete":
             if (command.disposition !== undefined)
@@ -2086,7 +2100,7 @@ export function validateTaskCommand(command, task, path = "command") {
     // checking against a task nobody has -- so the task is validated first, and a command is held
     // only to a task that stands.
     const published = new Collector();
-    validateTaskInto(task, { channel: channel ?? "voice" }, `${path}.task`, published);
+    validateTaskInto(task, { ...taskContext, channel: channel ?? "voice" }, `${path}.task`, published);
     if (published.violations.length > 0 || !isPlainObject(task)) {
         into.add("command.task", `${path}.task`, `the task the command is held to is not one the wire published (${published.violations.map(v => v.rule).join(", ")}): pass the task as the provider sent it, or validate the command's shape alone`);
         return into.violations;
@@ -2158,10 +2172,20 @@ export function validateTaskCommand(command, task, path = "command") {
             offered("endCall");
             handling();
             break;
-        case "recording":
-            offered("recording");
-            handling();
+        case "recording": {
+            if (!offered("recording"))
+                break;
+            const policy = isPlainObject(capabilities.recording) ? capabilities.recording.provider : undefined;
+            const state = isPlainObject(task.recording) ? task.recording.provider : undefined;
+            into.violations.push(...validateRecordingCommandState(command, policy, state, path));
+            if (command.action === "start" || command.action === "resume") {
+                handling();
+                into.require(task.media === "started", "recording.request.phase", path, "capture needs live media");
+            }
+            else
+                inPhase("command.phase.handling", "in-progress", "paused", "completing");
             break;
+        }
         case "connect-back":
             offered("connectBack");
             inPhase("command.phase.completing", "completing");
@@ -2563,3 +2587,257 @@ export function validateAuthenticationState(state, path = "authentication", cont
     }
     return into.violations;
 }
+// Independent current recording evidence and dispatch validation.
+const object = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const filled = (v) => typeof v === "string" && v.trim().length > 0;
+function collector() {
+    const violations = [];
+    const check = (ok, rule, path, message) => {
+        ruleEvaluated(`recording.${rule}`);
+        if (!ok)
+            violations.push({ rule: `recording.${rule}`, path, message });
+        return Boolean(ok);
+    };
+    const keys = (v, allowed, path) => {
+        for (const key of Object.keys(v))
+            check(allowed.includes(key), "field", `${path}.${key}`, "field is not permitted in this recording variant");
+    };
+    return { violations, check, keys };
+}
+/** Recording observations use canonical UTC millisecond instants, never native capture boundaries. */
+function instant(v) {
+    if (typeof v !== "string" || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(v))
+        return false;
+    const n = Date.parse(v);
+    return Number.isFinite(n) && new Date(n).toISOString() === v;
+}
+export function validateRecordingState(value, path = "recording") {
+    const { violations, check, keys } = collector();
+    if (!object(value)) {
+        check(false, "state.shape", path, "expected recording state");
+        return violations;
+    }
+    if (value.status === "unknown") {
+        keys(value, ["status"], path);
+        return violations;
+    }
+    check(["inactive", "active", "paused"].includes(value.status), "state.status", `${path}.status`, "expected unknown, inactive, active or paused");
+    keys(value, ["status", "observationId", "observedAt", "validUntil", ...(value.status === "inactive" ? [] : ["recordingId"])], path);
+    check(filled(value.observationId), "observationId", `${path}.observationId`, "a confirming observation has an opaque identity");
+    check(instant(value.observedAt), "observedAt", `${path}.observedAt`, "expected canonical UTC millisecond observation instant");
+    check(instant(value.validUntil), "validUntil", `${path}.validUntil`, "expected canonical UTC millisecond expiry instant");
+    if (instant(value.observedAt) && instant(value.validUntil))
+        check(value.observedAt < value.validUntil, "expiry", path, "expiry must be strictly after observation");
+    if (value.status !== "inactive")
+        check(filled(value.recordingId), "recordingId", `${path}.recordingId`, "active and paused states identify the actual recording");
+    return violations;
+}
+/** Supply a trusted current instant in the observer's clock domain. Undefined means clock unknown. */
+export function effectiveRecordingState(state, now) {
+    if (state === undefined || validateRecordingState(state).length || state.status === "unknown" || now === undefined || !Number.isFinite(now))
+        return { status: "unknown" };
+    return Date.parse(state.observedAt) <= now && now < Date.parse(state.validUntil) ? state : { status: "unknown" };
+}
+export function validateRecordingPolicy(value, path = "capabilities.recording") {
+    const { violations, check, keys } = collector();
+    if (!object(value)) {
+        check(false, "policy.shape", path, "expected per-task provider/host action policy; true is no longer supported");
+        return violations;
+    }
+    keys(value, ["provider", "host"], path);
+    check(value.provider !== undefined || value.host !== undefined, "policy.empty", path, "declare at least one recording path");
+    for (const source of ["provider", "host"]) {
+        const policy = value[source];
+        if (policy === undefined)
+            continue;
+        const at = `${path}.${source}`;
+        if (!object(policy)) {
+            check(false, "policy.shape", at, "expected permitted actions");
+            continue;
+        }
+        keys(policy, [...RECORDING_ACTIONS, ...(source === "host" ? ["destinationId"] : [])], at);
+        check(RECORDING_ACTIONS.some(action => policy[action] !== undefined), "policy.empty", at, "omit paths offering no actions");
+        for (const action of RECORDING_ACTIONS) {
+            if (policy[action] === undefined)
+                continue;
+            check(policy[action] === true, "policy.action", `${at}.${action}`, "permission is true or absent");
+        }
+        if (source === "host")
+            check(filled(policy.destinationId), "destination", `${at}.destinationId`, "host storage destination must be explicit per task");
+    }
+    return violations;
+}
+export function validateHostRecording(value, softphone, path = "host.recording") {
+    if (value === undefined)
+        return [];
+    const { violations, check, keys } = collector();
+    check(softphone, "host.channel", path, "initial host recording requires voice softphone media");
+    if (!object(value)) {
+        check(false, "host.shape", path, "expected host recording declaration and executor");
+        return violations;
+    }
+    keys(value, ["actions", "destinationIds", "execute", "announcesToCaller"], path);
+    if (value.announcesToCaller !== undefined)
+        check(value.announcesToCaller === true, "host.announcesToCaller", `${path}.announcesToCaller`, "caller announcement guarantee is true or absent");
+    for (const [key, allowed] of [["actions", RECORDING_ACTIONS], ["destinationIds", undefined]]) {
+        const list = value[key];
+        if (!Array.isArray(list)) {
+            check(false, "host.list", `${path}.${key}`, "expected explicit array");
+            continue;
+        }
+        check(new Set(list).size === list.length, "host.duplicate", `${path}.${key}`, "duplicate declaration");
+        check(list.every(item => filled(item) && (allowed === undefined || allowed.includes(item))), "host.list", `${path}.${key}`, "unsupported or empty declaration");
+        check(list.length > 0, "host.empty", `${path}.${key}`, "declare at least one supported value");
+    }
+    if (Array.isArray(value.actions)) {
+        check(value.actions.includes("pause") === value.actions.includes("resume"), "host.pause", path, "a pausable host supports resume; task permissions may independently restrict it");
+    }
+    check(typeof value.execute === "function", "host.execute", `${path}.execute`, "host recording requires its own executor");
+    return violations;
+}
+export function validateHostRecordings(value, path = "host.recordings") {
+    if (value === undefined)
+        return [];
+    const { violations, check, keys } = collector();
+    if (!Array.isArray(value)) {
+        check(false, "reports.shape", path, "expected full host recording report array");
+        return violations;
+    }
+    const seen = new Set();
+    value.forEach((report, i) => {
+        const at = `${path}[${i}]`;
+        if (!object(report)) {
+            check(false, "report.shape", at, "expected scoped report");
+            return;
+        }
+        keys(report, ["taskId", "allocationId", "state"], at);
+        check(filled(report.taskId) && filled(report.allocationId), "report.scope", at, "report identifies task and allocation");
+        const key = JSON.stringify([report.taskId, report.allocationId]);
+        check(!seen.has(key), "report.duplicate", at, "one host state per task allocation");
+        seen.add(key);
+        violations.push(...validateRecordingState(report.state, `${at}.state`));
+    });
+    return violations;
+}
+export function validateRecordingCommandShape(value, source, path = "command") {
+    const { violations, check, keys } = collector();
+    if (!object(value)) {
+        check(false, "command.shape", path, "expected recording command");
+        return violations;
+    }
+    keys(value, ["type", "source", "requestId", "observationId", "action", ...(value.action === "start" ? [] : ["recordingId"])], path);
+    check(value.type === "recording" && value.source === source, "command.source", path, `this executor accepts only ${source} recording commands`);
+    check(RECORDING_ACTIONS.includes(value.action), "command.action", `${path}.action`, "unsupported recording action");
+    for (const key of ["requestId", "observationId", ...(value.action === "start" ? [] : ["recordingId"])])
+        check(filled(value[key]), "command.identity", `${path}.${key}`, "expected nonempty scoped identity");
+    return violations;
+}
+/** One transition table shared by dispatch checks and outcome checks. */
+const RECORDING_TRANSITIONS = {
+    start: { from: ["inactive"], to: "active" },
+    pause: { from: ["active"], to: "paused" },
+    resume: { from: ["paused"], to: "active" },
+    stop: { from: ["active", "paused"], to: "inactive" },
+    cancel: { from: ["active", "paused"], to: "inactive" },
+};
+function recordingTransition(action) {
+    return typeof action === "string" && Object.hasOwn(RECORDING_TRANSITIONS, action)
+        ? RECORDING_TRANSITIONS[action] : undefined;
+}
+/** Structural/state permission check. Dispatch MUST also call validateRecordingRequest for scope and freshness. */
+export function validateRecordingCommandState(command, policy, state, path = "command") {
+    const { violations, check } = collector();
+    if (!object(command)) {
+        check(false, "command.shape", path, "expected recording command");
+        return violations;
+    }
+    const transition = recordingTransition(command.action);
+    if (transition === undefined) {
+        check(false, "command.action", `${path}.action`, "unsupported recording action");
+        return violations;
+    }
+    const permitted = object(policy) && policy[command.action] === true;
+    check(permitted, "command.permission", path, "task does not permit this action on this recorder");
+    if (!object(state) || validateRecordingState(state).length) {
+        check(false, "command.state", path, "no validated current recorder observation");
+        return violations;
+    }
+    check(transition.from.includes(state.status), "command.state", path, "action is invalid in the observed recorder state");
+    check(command.observationId === state.observationId, "command.stale", path, "observation changed; reconcile before acting");
+    if (command.action !== "start")
+        check(command.recordingId === state.recordingId, "command.recordingId", path, "command targets another recording");
+    return violations;
+}
+/** Validate immediately before dispatch using current task, host report and trusted observer-domain time. */
+export function validateRecordingRequest(request, task, context, path = "request") {
+    const { violations, check, keys } = collector();
+    if (!object(request) || !object(task)) {
+        check(false, "request.shape", path, "request and current task required");
+        return violations;
+    }
+    violations.push(...validateTask(task, { ...context.taskContext, channel: "voice" }, `${path}.task`));
+    keys(request, ["taskId", "allocationId", "command"], path);
+    check(filled(request.taskId) && filled(request.allocationId) && request.taskId === task.id && request.allocationId === task.allocationId, "request.scope", path, "task allocation changed or scope missing");
+    check(task.channel === "voice", "request.channel", path, "recording is voice-only");
+    violations.push(...validateRecordingCommandShape(request.command, context.source, `${path}.command`));
+    if (!object(request.command))
+        return violations;
+    const command = request.command;
+    const caps = object(task.capabilities) ? task.capabilities.recording : undefined;
+    violations.push(...validateRecordingPolicy(caps)); // a locked or missing capability cannot dispatch
+    const policy = object(caps) ? caps[context.source] : undefined;
+    let state = object(task.recording) ? task.recording.provider : undefined;
+    if (context.source === "host") {
+        violations.push(...validateHostRecording(context.host, context.softphone === true));
+        check(object(context.host), "host.required", path, "host did not declare recording support");
+        const reports = object(context.hostReport) ? context.hostReport.recordings : undefined;
+        violations.push(...validateHostRecordings(reports));
+        state = Array.isArray(reports) ? reports.find(r => object(r) && r.taskId === task.id && r.allocationId === task.allocationId)?.state : undefined;
+        if (object(context.host)) {
+            check(Array.isArray(context.host.actions) && context.host.actions.includes(command.action), "host.action", path, "host does not support action");
+            check(object(policy) && Array.isArray(context.host.destinationIds) && context.host.destinationIds.includes(policy.destinationId), "host.destination", path, "task destination is not provisioned by this host");
+        }
+    }
+    const fresh = effectiveRecordingState(state, context.now);
+    check(fresh.status !== "unknown", "request.freshness", path, "current state or trusted observer time unavailable/expired");
+    violations.push(...validateRecordingCommandState(command, policy, fresh, `${path}.command`));
+    const opening = command.action === "start" || command.action === "resume";
+    check(opening ? ["in-progress", "paused"].includes(task.phase) && task.media === "started" : ["in-progress", "paused", "completing"].includes(task.phase), "request.phase", path, "capture needs live task media; terminal controls may finish recordings during wrap-up");
+    return violations;
+}
+/** Check recording-specific result semantics against the owner's confirming observations. */
+export function validateRecordingOutcome(command, before, after, result, path = "recordingOutcome") {
+    const { violations, check } = collector();
+    violations.push(...validateRecordingState(before, `${path}.before`), ...validateRecordingState(after, `${path}.after`));
+    if (!object(command) || !object(before) || !object(after)) {
+        check(false, "outcome.shape", path, "command and both observations required");
+        return violations;
+    }
+    violations.push(...validateRecordingCommandShape(command, command.source === "host" ? "host" : "provider", `${path}.command`));
+    // A rejected promise has no result: any independently evidenced state may follow it.
+    if (result === undefined)
+        return violations;
+    violations.push(...validateResult(result, "execute", `${path}.result`));
+    if (!object(result))
+        return violations;
+    check(result.status === "applied" || result.status === "failed", "outcome.result", path, "recording never returns a dialling result");
+    if (result.status === "failed") {
+        check(before.status !== "unknown" && after.status === before.status && after.recordingId === before.recordingId, "outcome.noEffect", path, "failed promises confirmed no effect; ambiguous or partial effects have no result");
+    }
+    else if (result.status === "applied") {
+        const transition = recordingTransition(command.action);
+        if (transition === undefined)
+            return violations; // shape validation already reported the unknown action
+        check(after.status === transition.to, "outcome.state", path, "applied requires the confirming requested state");
+        check(after.observationId !== before.observationId, "outcome.observation", path, "an applied transition needs new confirming evidence");
+        check(before.observationId === command.observationId, "outcome.stale", path, "command must act against its named observation");
+        check(transition.from.includes(before.status), "outcome.origin", path, "applied cannot claim an impossible transition");
+        if (command.action !== "start")
+            check(command.recordingId === before.recordingId, "outcome.recordingId", path, "command must target the prior recording");
+        if (command.action === "pause" || command.action === "resume")
+            check(after.recordingId === before.recordingId, "outcome.continuity", path, "pause/resume preserves recording identity");
+        if (instant(before.observedAt) && instant(after.observedAt))
+            check(after.observedAt >= before.observedAt, "outcome.order", path, "clock discontinuity requires reconciliation, not a reversed confirmation");
+    }
+    return violations;
+}

package/guide.md

@@ -58,7 +58,7 @@ transport, a task, a break and a call each have a word of their own:
 
 ### `OMNI_PROTOCOL_VERSION`
 
-The exact protocol version implemented by this package. The current value is `1`.
+The exact protocol version implemented by this package. The current value remains `1` during pre-release development. Recording contract changes do not introduce a new protocol version. Hosts and adapters adopt the current declarations together; this does not provide compatibility mapping for older recording shapes.
 
 ### `Manifest.supportedProtocolVersions`
 
@@ -289,7 +289,55 @@ type HostAudioOutput =
 
 type UrlVisibility = "full" | "domain" | "hidden";
 
+type RecordingSource = "provider" | "host";
+type RecordingAction = "start" | "pause" | "resume" | "stop" | "cancel";
+const RECORDING_ACTIONS = ["start", "pause", "resume", "stop", "cancel"] as const satisfies readonly RecordingAction[];
+interface RecordingActions {
+  start?: true;
+  pause?: true;
+  resume?: true;
+  stop?: true;
+  cancel?: true;
+}
+interface TaskRecordingPolicy {
+  provider?: RecordingActions;
+  host?: RecordingActions & { destinationId: string };
+}
+type RecordingState =
+  | { status: "unknown"; observationId?: never; observedAt?: never; validUntil?: never; recordingId?: never }
+  | ({ observationId: string; observedAt: IsoTimestamp; validUntil: IsoTimestamp } & (
+      | { status: "inactive"; recordingId?: never }
+      | { status: "active" | "paused"; recordingId: string }
+    ));
+type RecordingCommand = {
+  type: "recording";
+  source: RecordingSource;
+  requestId: string;
+  observationId: string;
+} & (
+  | { action: "start"; recordingId?: never }
+  | { action: "pause" | "resume" | "stop" | "cancel"; recordingId: string }
+);
+interface HostRecordingReport {
+  taskId: TaskId;
+  allocationId: AllocationId;
+  state: RecordingState;
+}
+interface HostRecording {
+  announcesToCaller?: true;
+  actions: RecordingAction[];
+  destinationIds: string[];
+  execute(request: HostRecordingRequest): Promise<RecordingCommandResult>;
+}
+type RecordingCommandResult = Exclude<TaskCommandResult, { status: "dialling" }>;
+interface HostRecordingRequest {
+  taskId: TaskId;
+  allocationId: AllocationId;
+  command: RecordingCommand & { source: "host" };
+}
+
 type HostReport = {
+  recordings?: HostRecordingReport[];
   online: boolean;
   audio?: {
     input: HostAudioInput;
@@ -303,6 +351,7 @@ type HostGuarantees = {
 };
 
 type Host = {
+  recording?: HostRecording;
   guarantees: HostGuarantees;
   mute?: HostMute;
   report(): HostReport;
@@ -327,7 +376,7 @@ type ConnectContext = {
   log?: (entry: unknown) => void;
 } & (
   | { phone: "softphone"; host: { mute: HostMute } }
-  | { phone?: "deskPhone"; host: { mute?: never } }
+  | { phone?: "deskPhone"; host: { mute?: never; recording?: never } }
 );
 
 type TransportStatus = "connecting" | "active" | "error";
@@ -511,7 +560,7 @@ type TaskCapabilities<C extends Channel = Channel> =
         warmTransfer?: Lockable<DestinationDirectory>;
         leadAssist?: Lockable<true>;
         conference?: Lockable<DestinationDirectory>;
-        recording?: Lockable<true>;
+        recording?: Lockable<TaskRecordingPolicy>;
       }
     : C extends "chat"
       ? SharedTaskCapabilities & { decline?: Lockable<true>; hold?: Lockable<true> }
@@ -686,8 +735,8 @@ type Task<C extends Channel = Channel> = {
   handlingHistory?: TaskHandlingHistory;
 } & TaskCompletion & (
   C extends "voice"
-    ? { onCall?: OnCall[]; leadAssist?: TaskLeadAssist; assisting?: TaskAssisting; monitoring?: TaskMonitoring; media?: TaskMediaState }
-    : { onCall?: never; leadAssist?: never; assisting?: never; monitoring?: never; media?: never }
+    ? { recording?: { provider?: RecordingState }; onCall?: OnCall[]; leadAssist?: TaskLeadAssist; assisting?: TaskAssisting; monitoring?: TaskMonitoring; media?: TaskMediaState }
+    : { recording?: never; onCall?: never; leadAssist?: never; assisting?: never; monitoring?: never; media?: never }
 );
 
 type PreviewDeadline = "calls" | "expires";
@@ -753,7 +802,7 @@ type VoiceTaskCommand =
   | { type: "conference"; action: "add"; dialId: DialId; destinationId: string }
   | { type: "conference"; action: "remove"; destinationId: string; party?: never }
   | { type: "conference"; action: "remove"; party: true; destinationId?: never }
-  | { type: "recording"; action: "start" | "pause" | "resume" | "stop" }
+  | (RecordingCommand & { source: "provider" })
   | ({ type: "complete" } & DispositionPayload);
 
 type ChatTaskCommand =
@@ -2994,7 +3043,7 @@ See **Which commands need a capability**.
 | `warmTransfer` | Secondary menu item: Warm transfer | Omni may park the customer and call a destination first, then hand the customer over or cancel back. See **Warm transfer**. |
 | `leadAssist` | Secondary menu item: Lead assist | Omni may ask a lead to join this call, with a note. The lead's decision reaches the agent on `Task.leadAssist`. See **Lead assist**. |
 | `conference` | Secondary button: Conference | Omni may dial a destination into the active call, and remove one person from it -- a conferenced entry, one still ringing included, which calls the dial off, or the party, leaving the agent with the colleague. See **Ending a call, and removing one person from it**. |
-| `recording` | Overflow menu item: Recording | Omni may expose start, pause, resume, and stop recording controls. |
+| `recording` | Overflow menu item: Recording | Per-task provider and host policies expose only their permitted recording actions; each has independent state and routing. |
 | `dispositions` | Primary button: Complete | Omni may request task disposal with a provider disposition and notes. |
 
 ### Publishing codes and destinations
@@ -4216,7 +4265,7 @@ capability's `notes` setting. A task publishing no codes still receives `complet
 
 Every command reaches the provider through `execute`, with no branch at the call site, and every
 command asks the provider to **perform** something: `hold`, `transfer`, `conference`, `end-call`,
-`recording` and the rest act on the platform's own call leg, its bridge, or its record of the
+Provider-targeted `recording` commands and the rest act on the platform's own call leg, its bridge, or its record of the
 task. Nothing has happened until the provider applies them, and `failed` means nothing happened.
 
 **The provider performs every action; the host only offers it.** A control drawn on the host is
@@ -4325,7 +4374,7 @@ declared:
 | Everything else | Its own named capability. |
 
 **A control on the contact belongs to the handling phases**, `in-progress` and `paused`:
-`hold`, `resume` and `pause`, `end-call`, `recording`, every `transfer` and `conference` action, and
+`hold`, `resume` and `pause`, `end-call`, every `transfer` and `conference` action, and
 every `lead-assist` action. Each acts on the call or the conversation, and only while there is one.
 Before `in-progress` nothing has been placed or opened; in `completing` the handling has ended -- a
 call with nobody on it, a conversation closed -- and a wrap-up that still shows Transfer shows it
@@ -4940,3 +4989,146 @@ belongs in this contract is the boundary. A provider says what a control **is**
 capabilities and what its work is **called** through `phaseLabels` and `taskTypePresentation`; how
 any of it is drawn is Omni's. A task cannot select a design language, inject a component, or
 override the agent's theme and font preferences.
+
+## Independent task recording
+
+Recording is voice-only. A task can arrive already recording, including while pending, and offer
+no recording controls. The provider publishes only its own current state on
+the provider field of the task’s `recording` state. The host publishes its own full scoped view in `HostReport.recordings`.
+A provider task update cannot replace host state. Neither a capability nor an accepted command
+establishes recording. Missing state, lost recorder observation, transport loss and expired
+observation mean unknown; they never mean stopped. Paused means a recording remains open without
+capturing. Task hold, task pause and recording pause are independent.
+
+The per-task policy is `Task.capabilities.recording`, with independently optional provider and host
+action sets. The outer capability may be locked. Absence grants no permission, and a state may
+exist without any permission. A provider may offer only stop for a recording started automatically,
+or withdraw a control on a later task update. There is no global recording mode and no automatic
+start from a capability declaration. Host support is declared on `ConnectContext.host.recording`,
+not the provider-owned manifest. The task chooses an explicitly provisioned host destination;
+unknown destinations or unsupported actions are refused visibly, never redirected to provider
+recording or a default upload location. Initial host support requires voice softphone media and
+capture of both local and remote audio; a host unable to capture either must refuse start/resume.
+This package declares that contract; it supplies no recorder, media mixing, storage or upload.
+
+| Action | Required current recording state | Confirmed outcome |
+| --- | --- | --- |
+| start | inactive | active with a new recording identity |
+| pause | active | paused, preserving recording identity and captured audio |
+| resume | paused | active with the same recording identity |
+| stop | active or paused | inactive; finish and retain captured audio |
+| cancel | active or paused | inactive; abandon and discard captured audio |
+
+Stop finishes the recording and retains captured audio. Cancel abandons the recording and discards
+its captured audio; the task policy offers it with `cancel: true`. There is no configurable cancel
+effect. A recorder that cannot confirm disposal must not offer Cancel; it can offer Stop instead.
+Cancel never means cancelling an in-flight start request or deleting arbitrary past recordings.
+Stop can be applied only after finalization/retention succeeds; Cancel only after both cessation
+and disposal of this recording's audio succeed under the recorder's storage contract.
+Partial success (capture stopped but storage outcome unknown) cannot return failed with a claim
+of no effect. It rejects with unknown outcome, reports the failure visibly and publishes whatever
+current capture state is actually known. Retention is not a promise of sample-perfect audio.
+
+Provider commands go exclusively to `Connection.execute`; host commands go exclusively to
+`HostRecording.execute`. Both include task, allocation, request and observation identities; all
+non-start commands identify the particular recording. IDs are opaque and scoped by provider login,
+task and recorder owner. They are never inferred from filenames or current agent identity. A
+recording ID survives pause/resume and reallocation only where the same recorder confirms continuity;
+commands always name the current allocation. A later start gets a different ID. Reconnect does not
+create a new recording or fresh evidence. After lost continuity, use unknown until reconciled.
+There is no automatic restart, transfer to another recorder, or stop on task hold/disconnect.
+Task removal does not prove recording stopped: outstanding host recorders remain tracked by the
+host until its executor reconciles/finishes them, with visible unresolved cleanup failures.
+
+Only start/resume require an in-progress or paused task with started media. Pause/stop/cancel may
+also finish an independently observed recorder while the task is completing. A pending task may
+show active recording, but agent controls wait until handling begins. The two recording paths may
+both be active. A command to either path has no implied effect on the other.
+
+Each confirmed observation has a fresh opaque observation identity, a canonical UTC millisecond
+observation instant and an exclusive expiry. These times describe current evidence, never historical
+capture boundaries. A trusted observer-domain current time must satisfy observedAt <= now < validUntil.
+Use `effectiveRecordingState` with that explicitly trusted time; an unavailable clock yields unknown.
+Receipt, replay and task publication never extend freshness. Clock discontinuity invalidates evidence;
+consumers must invalidate their clock estimate and use monotonic aging so clock rollback cannot
+revive expired evidence. The executor compares observation identity and recording identity against
+its latest state atomically before I/O. An intervening observation or allocation change refuses the
+stale command; it never acts on a replacement recorder. Providers lacking trustworthy current-state
+identity or observation time publish unknown and offer no issuable controls.
+
+Use `validateTask` and `validateTaskCommand` for published shape and static permissions.
+Immediately before dispatch, additionally use `validateRecordingRequest` against the full current
+task and explicit observer-domain time. For host commands also supply the current host declaration,
+full host report and softphone context. The same checks must run at the executing boundary;
+client validation alone is not authorization. The executor serializes operations on each recorder
+and durably correlates request identity with scope, action and outcome: an exact retry refers to the
+same operation; reuse with different contents is refused. It never silently retries an ambiguous
+operation. Implementations without reliable request correlation must refuse controls.
+
+Keep command progress in host UI separately from authoritative state. Applied means the requested
+transition and disposition actually completed; publish the confirming task or host report before
+resolving applied. Failed means confirmed no effect. Rejected promise means outcome unknown:
+show the failure, reconcile that path and do not automatically retry or pretend inactive. Authoritative
+updates remain full current task/host views, not replayed provider events. These current-state fields
+create no handling-history entries and infer no actors, durations or historical capture boundaries.
+
+Migration is explicit: replace the old true recording capability with per-path action policies,
+replace untargeted commands with scoped commands, and retain protocol version 1. During pre-release
+development, hosts and adapters must align their recording contracts; negotiation does not detect
+differences between package revisions that share that protocol number. No legacy-shape fallback is provided.
+This change does not publish a package or enable recording in any existing host/provider by itself.
+
+`validateRecordingOutcome` checks confirming observations against recording-specific applied/failed
+semantics, including pause/resume identity and rejection of a dialling result. It cannot prove audio
+retention/disposal or source truth from a status flag; those remain executor obligations.
+
+Host destination selection binds storage when start actually creates a recording. Existing recordings
+keep that binding through pause/resume/stop/cancel; a later policy cannot redirect their stored audio.
+The executor rejects a mismatched destination rather than moving or discarding another binding.
+Action permission does not authorize unattended invocation: host controls require the agent's explicit
+act, and provider authorization remains enforced at its authenticated command boundary.
+
+
+Recording dispatch must receive the same known task-validation context as the published task.
+Pass organisation levels and other known restrictions through the optional fourth argument of
+`validateTaskCommand`, and through `taskContext` in `validateRecordingRequest`. This keeps a valid
+custom organisation lock from being rejected against the default ladder, and prevents known
+capability restrictions from disappearing at dispatch. The standalone `validateRecordingCommandState`
+requires an affirmative permission; false, malformed permission declarations and unknown actions grant nothing.
+
+
+### Host recording announcements to the caller
+
+`HostRecording.announcesToCaller`, when true, is a guarantee that the host delivers audible recording
+status messages to the remote party over the call's outgoing audio. It belongs inside the optional
+host recording capability: without that capability there is no such guarantee. Omission makes no
+promise; false is invalid. It does not belong in the provider manifest, the task's recording policy
+or the general `HostGuarantees` object. A provider can inspect this host guarantee when deciding
+whether to permit host recording on a task.
+
+The guarantee applies only to host-owned recordings. Providers implement announcements for their
+own recordings at their end; provider state updates must not cause the host to announce those
+recordings. Both recorders can operate independently on the same call.
+
+On a confirmed host start, the remote party hears that recording started. On a confirmed stop or
+cancel, they hear that recording stopped. If pause/resume is supported, say paused/resumed so a
+pause is not presented as a finished recording. Announcements follow actual capture transitions,
+not button clicks, accepted requests or task-policy changes. When attaching to an already-active
+host recording, announce that recording is active, without inventing its original start time.
+Repeated observations of the same state do not repeat announcements. Unknown or expired evidence
+must never produce a stopped announcement.
+
+A local sound, UI indicator, screen-reader message to the agent, or sound leaking through the
+microphone does not fulfil this guarantee. The host must deliver the message directly in the audio
+sent to the remote party, even when the agent microphone is muted. It may also notify the agent.
+Only declare the guarantee when the host can provide that outgoing audio path. An announcement
+that cannot be delivered, including after the remote party has disconnected, is a visible failure;
+never claim delivery or replay the notice into a different call.
+
+For a command under this guarantee, applied requires both the recording action and its announcement
+to succeed. If capture changes but announcement delivery fails, publish the actual recording state,
+report the announcement failure visibly and reject with unknown command outcome. Do not claim no
+effect, automatically repeat the recording action or silently switch to an agent-only notice.
+
+`validateHostRecording` checks the declaration, including its true-or-absent guarantee. Actual audio
+delivery remains the host implementation's responsibility and must be exercised in its own tests.

package/package.json

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