@xema/omni-protocol 0.1.25 → 0.1.27

package/dist/testing.js

@@ -1,4 +1,4 @@
-import { browserSessionKey, effectiveTiers, sameCapabilities, } from "./index.js";
+import { browserSessionKey, effectiveLevels, sameCapabilities, } from "./index.js";
 import { assertNoViolations, validateAuthenticationState, validateEventEnvelope, validateHostReport, validateManifest, validateResult, validateSnapshot, } from "./validation.js";
 export { ProtocolConformanceError, assertNoViolations } from "./validation.js";
 /**
@@ -31,8 +31,8 @@ const STATE_SUBJECTS = [
 // Pinned to the event union the way validation pins its closed sets: a type added to
 // `ProviderEvent` without a row here, or a row it lacks, is a compile error.
 const EVENT_TYPES = {
-    snapshot: true, "provider-status": true, "break-state": true, "task-offered": true, "task-updated": true,
-    "task-media-ready": true, "task-media-ended": true, "task-ended": true, announcement: true, "provider-summary": true,
+    snapshot: true, "transport-status": true, "break-state": true, "task-offered": true, "task-updated": true,
+    "task-media-started": true, "task-media-ended": true, "task-ended": true, announcement: true, "queue-summary": true,
     "team-updated": true, "contacts-updated": true, "calendar-updated": true,
 };
 const CONTRACT_SUBJECTS = [
@@ -172,8 +172,8 @@ export async function exerciseAdapter(adapter, context, options = {}) {
     let disconnectWasClean = false;
     try {
         authenticationState = await authentication.state();
-        const tiers = effectiveTiers(adapter.manifest.orgTiers).map(tier => tier.id);
-        violations.push(...validateAuthenticationState(authenticationState, "authentication", { tiers }));
+        const levels = effectiveLevels(adapter.manifest.orgLevels).map(level => level.id);
+        violations.push(...validateAuthenticationState(authenticationState, "authentication", { levels }));
         if (authenticationState.status !== "authenticated") {
             throw new Error(`Adapter contract exercise requires authenticated test state, received ${authenticationState.status}`);
         }
@@ -193,7 +193,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         const reader = () => ({
             self: current().identity.id,
             capabilities: current().capabilities,
-            sessionId: context.sessionId,
+            loginId: context.loginId,
             autoAcceptTasks: context.autoAcceptTasks ?? true,
         });
         // The optional methods are optional only until something declares a need for them. Each
@@ -228,7 +228,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 requireMethod(on, "setPreference", "the login declares capabilities.preferences");
         };
         unsubscribeAuthentication = authentication.subscribe(state => {
-            const own = validateAuthenticationState(state, "authentication", { tiers });
+            const own = validateAuthenticationState(state, "authentication", { levels });
             violations.push(...own);
             if (own.length > 0)
                 return;
@@ -590,7 +590,7 @@ const WORK_BEGUN = new Set(["in-progress", "paused", "completing"]);
 export class TaskStream {
     tasks = new Map();
     static stated(task) {
-        const media = isRecord(task) && (task.media === "ready" || task.media === "ended") ? task.media : "none";
+        const media = isRecord(task) && (task.media === "started" || task.media === "ended") ? task.media : "none";
         return { phase: String(isRecord(task) ? task.phase : undefined), media };
     }
     /** Replaces what is known with a snapshot's tasks, as a snapshot replaces Omni's state. */
@@ -638,30 +638,30 @@ export class TaskStream {
                     }
                 }
                 // A task replaces the task, and an update re-states media without moving it: the
-                // transitions belong to task-media-ready and task-media-ended. Releasing ended is the
+                // transitions belong to task-media-started and task-media-ended. Releasing ended is the
                 // one move an update may make, since wrapped audio has nothing left to end.
                 {
                     const next = TaskStream.stated(event.task);
                     if (known.media !== next.media && !(known.media === "ended" && next.media === "none")) {
-                        refuse("stream.taskUpdated.media", `${at}.task.media`, `a task-updated re-states media, it does not move it: ${id} held ${known.media} and the update says ${next.media}; audio arrives on task-media-ready and ends on task-media-ended`);
+                        refuse("stream.taskUpdated.media", `${at}.task.media`, `a task-updated re-states media, it does not move it: ${id} held ${known.media} and the update says ${next.media}; audio arrives on task-media-started and ends on task-media-ended`);
                     }
                     this.tasks.set(id, next);
                 }
                 break;
-            case "task-media-ready":
+            case "task-media-started":
                 if (id === undefined)
                     break;
                 if (known === undefined) {
-                    refuse("stream.taskMediaReady.unknown", `${at}.taskId`, `${id} was never offered or carried on a snapshot`);
+                    refuse("stream.taskMediaStarted.unknown", `${at}.taskId`, `${id} was never offered or carried on a snapshot`);
                     break;
                 }
                 if (!WORK_BEGUN.has(known.phase)) {
-                    refuse("stream.taskMediaReady.beforeWork", `${at}.taskId`, `media cannot arrive on ${id} while it is ${known.phase}: a task is never its audio, and its work has not begun`);
+                    refuse("stream.taskMediaStarted.beforeWork", `${at}.taskId`, `media cannot arrive on ${id} while it is ${known.phase}: a task is never its audio, and its work has not begun`);
                 }
-                if (known.media === "ready") {
-                    refuse("stream.taskMediaReady.duplicate", `${at}.taskId`, `media is already ready on ${id}; ready and ended alternate`);
+                if (known.media === "started") {
+                    refuse("stream.taskMediaStarted.duplicate", `${at}.taskId`, `media already started on ${id}; started and ended alternate`);
                 }
-                known.media = "ready";
+                known.media = "started";
                 break;
             case "task-media-ended":
                 if (id === undefined)
@@ -673,8 +673,8 @@ export class TaskStream {
                 if (!WORK_BEGUN.has(known.phase)) {
                     refuse("stream.taskMediaEnded.beforeWork", `${at}.taskId`, `media cannot end on ${id} while it is ${known.phase}: a task is never its audio, and its work has not begun`);
                 }
-                if (known.media !== "ready") {
-                    refuse("stream.taskMediaEnded.silent", `${at}.taskId`, `media cannot end on ${id} where none arrived: audio attaches on task-media-ready, or on a task carried with media ready`);
+                if (known.media !== "started") {
+                    refuse("stream.taskMediaEnded.silent", `${at}.taskId`, `media cannot end on ${id} where none arrived: audio attaches on task-media-started, or on a task carried with media started`);
                 }
                 known.media = "ended";
                 break;
@@ -756,7 +756,7 @@ export function assertBreakFollowsItsRequests(envelopes, snapshot) {
 }
 /**
  * The media follows the task and never decides it. Given a provider's stream -- optionally seeded
- * with the snapshot it began from -- every task is introduced once, `task-media-ready` and
+ * with the snapshot it began from -- every task is introduced once, `task-media-started` and
  * `task-media-ended` alternate on work that has begun, media ends only where it arrived, and what
  * follows the media ending is `completing` or `task-ended`.
  */
@@ -769,7 +769,7 @@ export function assertMediaFollowsTheTask(envelopes, snapshot) {
     assertNoViolations(found, "The media follows the task");
 }
 /** A host that reports one thing and never changes: what most adapter tests hand `exerciseAdapter`. */
-export function stillHost(report = { online: true, browsers: { urlVisibility: "hidden" } }) {
+export function stillHost(report = { online: true }) {
     return { report: () => report, subscribe: () => () => undefined };
 }
 const usableLogin = (status) => status === "authenticated" || status === "refreshing";
@@ -833,20 +833,20 @@ export function assertBreakBeginsAfterTask(steps) {
  * implementation; pass 0 to demand an exact match.
  */
 export function assertWrapTimeout(task, mediaEndedAt, observedDeadline, toleranceMs = 1_000) {
-    if (task.completionAllowance === undefined) {
+    if (task.wrapAllowance === undefined) {
         if (observedDeadline !== undefined) {
             throw new Error(`Wrap deadline mismatch: the task states no allowance, so there is no deadline, received ${observedDeadline}`);
         }
         return;
     }
     if (observedDeadline === undefined) {
-        throw new Error(`Wrap deadline mismatch: the task allows ${task.completionAllowance}s, but no deadline was observed`);
+        throw new Error(`Wrap deadline mismatch: the task allows ${task.wrapAllowance}s, but no deadline was observed`);
     }
     const ended = Date.parse(mediaEndedAt);
     const deadline = Date.parse(observedDeadline);
     if (Number.isNaN(ended) || Number.isNaN(deadline))
         throw new Error("Wrap scenario requires valid ISO-8601 times");
-    const expected = ended + task.completionAllowance * 1_000;
+    const expected = ended + task.wrapAllowance * 1_000;
     if (Math.abs(deadline - expected) > toleranceMs) {
         throw new Error(`Wrap deadline mismatch: expected ${new Date(expected).toISOString()} within ${toleranceMs}ms, received ${observedDeadline}`);
     }
@@ -854,14 +854,14 @@ export function assertWrapTimeout(task, mediaEndedAt, observedDeadline, toleranc
 /** The session key one scenario derives, or `undefined` where the browser shares nothing. */
 const sessionKeyFor = (scenario) => browserSessionKey(scenario);
 /** Validates whether two task-browser definitions should share one browser session. */
-export function assertBrowserIsolationAndReuse(left, right, expectedReuse) {
+export function assertBrowserSessionIsolation(left, right, expectedReuse) {
     const leftKey = sessionKeyFor(left);
     const rightKey = sessionKeyFor(right);
-    // A browser that does not reuse has no session key at all, so two of them never share one.
-    // Treating "no key" as a match would report reuse nobody asked for.
+    // A browser that does not share its session has no session key at all, so two of them never share one.
+    // Treating "no key" as a match would report sharing nobody asked for.
     const actualReuse = leftKey !== undefined && leftKey === rightKey;
     if (actualReuse !== expectedReuse) {
-        throw new Error(`Browser reuse mismatch: expected ${expectedReuse}, received ${actualReuse} (${String(leftKey)} vs ${String(rightKey)})`);
+        throw new Error(`Browser session sharing mismatch: expected ${expectedReuse}, received ${actualReuse} (${String(leftKey)} vs ${String(rightKey)})`);
     }
 }
 /**

package/dist/validation.d.ts

@@ -1,4 +1,4 @@
-import { type ProtocolViolation, type SessionCapabilities, type UserId } from "./index.js";
+import { 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[];
@@ -13,8 +13,8 @@ export declare function validateManifest(manifest: unknown, path?: string): Prot
 export interface TaskValidationContext {
     /** The provider's channel, from its manifest. A task must agree with it. */
     channel: string;
-    /** The tier ids in force, from the manifest. The defaults when absent. */
-    tiers?: readonly string[];
+    /** The level ids in force, from the manifest. The defaults when absent. */
+    levels?: readonly string[];
 }
 export declare function validateTask(task: unknown, context: TaskValidationContext, path?: string): ProtocolViolation[];
 /**
@@ -31,11 +31,11 @@ export interface ReaderContext {
      * The login's `AuthenticationState.capabilities`. The login is the permission: a lead's
      * snapshot carries a roster, nobody else's does, and `requests` need `team.consultControl`.
      */
-    capabilities?: SessionCapabilities;
-    /** The tier ids in force. Filled from the manifest by `validateSnapshot` and `validateEventEnvelope`; the defaults otherwise. */
-    tiers?: readonly string[];
-    /** The login's `sessionId`. A snapshot or event naming another belongs to a login that is gone. */
-    sessionId?: string;
+    capabilities?: UserCapabilities;
+    /** The level ids in force. Filled from the manifest by `validateSnapshot` and `validateEventEnvelope`; the defaults otherwise. */
+    levels?: readonly string[];
+    /** The login's `loginId`. A snapshot or event naming another belongs to a login that is gone. */
+    loginId?: string;
     /** `ConnectContext.autoAcceptTasks` as sent, absent meaning `true`: whether `task-offered` carries an `acceptanceMode`. */
     autoAcceptTasks?: boolean;
 }
@@ -59,7 +59,7 @@ export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" |
 export declare function validateResult(result: unknown, method: ResultMethod, path?: string): ProtocolViolation[];
 /** What a login is validated against beyond its own shape. */
 export interface LoginValidationContext {
-    /** The tier ids in force, from the manifest. The defaults when absent. */
-    tiers?: readonly string[];
+    /** The level ids in force, from the manifest. The defaults when absent. */
+    levels?: readonly string[];
 }
 export declare function validateAuthenticationState(state: unknown, path?: string, context?: LoginValidationContext): ProtocolViolation[];