@xema/omni-protocol 0.1.25 → 0.1.27

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, BROWSER_ISOLATION_SCHEMES, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, negotiateProtocolVersion, DEFAULT_TIERS, effectiveTiers, } from "./index.js";
+import { ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
 export class ProtocolConformanceError extends Error {
     violations;
     constructor(violations, summary = "Adapter violates the Omni protocol") {
@@ -36,7 +36,7 @@ export function assertNoViolations(violations, summary) {
  */
 const membersOf = (members) => Object.keys(members);
 const CHANNELS = membersOf({ voice: true, chat: true, email: true });
-const CONNECTION_RECOVERIES = membersOf({ reconnect: true, reauthenticate: true });
+const TRANSPORT_RECOVERIES = membersOf({ reconnect: true, reauthenticate: true });
 const TASK_PHASES = membersOf({
     pending: true, confirmed: true, preparing: true, "in-progress": true, paused: true, completing: true,
 });
@@ -44,7 +44,7 @@ const COMPLETION_MODES = membersOf({ "agent-command": true, "provider-automatic"
 const ACCEPTANCE_MODES = membersOf({
     "no-preference": true, "require-agent-acceptance": true, "require-automatic-acceptance": true,
 });
-const CONNECTION_STATUSES = membersOf({ connecting: true, active: true, error: true });
+const TRANSPORT_STATUSES = membersOf({ connecting: true, active: true, error: true });
 const AUTHENTICATION_METHODS = membersOf({ "browser-sso": true, credentials: true });
 const AUTHENTICATION_STATUSES = membersOf({
     "signed-out": true, authenticating: true, authenticated: true, refreshing: true, expired: true,
@@ -59,7 +59,7 @@ const HANDLING_STEPS = membersOf({
     queued: true, offered: true, answered: true, held: true, muted: true, transferred: true, conferenced: true, unanswered: true,
 });
 const DESTINATION_KINDS = membersOf({ queue: true, agent: true, external: true });
-const CUSTOM_UI_KINDS = membersOf({ button: true, toggle: true, "menu-item": true });
+const CUSTOM_UI_CONTROLS = membersOf({ button: true, toggle: true, "menu-item": true });
 const CUSTOM_UI_PLACEMENTS = membersOf({ primary: true, secondary: true, overflow: true });
 const NOTES_POLICIES = membersOf({ required: true, optional: true, hidden: true });
 const ACCESS_MODES = membersOf({ "allow-all": true, "block-all": true });
@@ -165,7 +165,7 @@ export function validateContact(contact, path = "contact") {
     validateContactInto(contact, path, into);
     return into.violations;
 }
-function validateContactInto(contact, path, into, tiers) {
+function validateContactInto(contact, path, into, levels) {
     if (!isPlainObject(contact)) {
         into.add("contact.shape", path, "a contact must be an object");
         return;
@@ -174,7 +174,7 @@ function validateContactInto(contact, path, into, tiers) {
         if (contact[field] === undefined)
             continue;
         if ((field === "number" || field === "email") && isLocked(contact[field])) {
-            validateLockedInto(contact[field], `contact.${field}.locked`, `${path}.${field}`, tiers, into);
+            validateLockedInto(contact[field], `contact.${field}.locked`, `${path}.${field}`, levels, into);
             continue;
         }
         into.filled(contact[field], `contact.${field}`, `${path}.${field}`, `${field} must not be empty when present`);
@@ -200,14 +200,14 @@ function validateScheduledActivityInto(activity, path, into) {
             into.require(Date.parse(activity.endsAt) >= Date.parse(activity.startsAt), "activity.endsAt.order", `${path}.endsAt`, "endsAt must not precede startsAt");
         }
     }
-    if (activity.contact !== undefined)
-        validateContactInto(activity.contact, `${path}.contact`, into);
+    if (activity.party !== undefined)
+        validateContactInto(activity.party, `${path}.party`, into);
     validateAttributes(activity.attributes, `${path}.attributes`, into);
 }
 // ---------------------------------------------------------------------------
 // Manifest.
 // ---------------------------------------------------------------------------
-function validateBrowserAccessPolicy(value, path, into) {
+function validateBrowserAccess(value, path, into) {
     if (!isPlainObject(value)) {
         into.add("manifest.personalBrowser.access.shape", path, "an access policy must be an object");
         return;
@@ -246,7 +246,7 @@ function validateIdleCapabilities(value, channel, path, into) {
             into.add("manifest.personalBrowser.shape", `${path}.personalBrowser`, "personalBrowser must be an object when present");
         }
         else {
-            validateBrowserAccessPolicy(browser.access, `${path}.personalBrowser.access`, into);
+            validateBrowserAccess(browser.access, `${path}.personalBrowser.access`, into);
             if (browser.accessPolicyScope !== undefined) {
                 into.oneOf(browser.accessPolicyScope, ACCESS_POLICY_SCOPES, "manifest.personalBrowser.accessPolicyScope", `${path}.personalBrowser.accessPolicyScope`);
             }
@@ -257,7 +257,7 @@ function validateIdleCapabilities(value, channel, path, into) {
             into.add("manifest.dial.shape", `${path}.dial`, "dial must be an object when present");
         }
         else {
-            into.oneOf(value.dial.destinationPolicy, DIAL_DESTINATION_POLICIES, "manifest.dial.destinationPolicy", `${path}.dial.destinationPolicy`);
+            into.oneOf(value.dial.destinations, DIAL_DESTINATION_POLICIES, "manifest.dial.destinations", `${path}.dial.destinations`);
         }
     }
     for (const flag of ["calendar", "contacts"]) {
@@ -312,34 +312,34 @@ export function validateManifest(manifest, path = "manifest") {
             }
         }
     }
-    if (manifest.orgTiers !== undefined) {
-        if (!Array.isArray(manifest.orgTiers)) {
-            into.add("manifest.orgTiers.shape", `${path}.orgTiers`, "orgTiers must be an array when present");
+    if (manifest.orgLevels !== undefined) {
+        if (!Array.isArray(manifest.orgLevels)) {
+            into.add("manifest.orgLevels.shape", `${path}.orgLevels`, "orgLevels must be an array when present");
         }
         else {
             const ids = new Set();
             let wellFormed = true;
-            manifest.orgTiers.forEach((tier, index) => {
-                const at = `${path}.orgTiers[${index}]`;
-                if (!isPlainObject(tier)) {
-                    into.add("manifest.orgTier.shape", at, "each tier must be an object with an id and a label");
+            manifest.orgLevels.forEach((level, index) => {
+                const at = `${path}.orgLevels[${index}]`;
+                if (!isPlainObject(level)) {
+                    into.add("manifest.orgLevel.shape", at, "each level must be an object with an id and a label");
                     wellFormed = false;
                     return;
                 }
-                if (into.filled(tier.id, "manifest.orgTier.id", `${at}.id`, "a tier needs an id")) {
-                    if (ids.has(tier.id)) {
-                        into.add("manifest.orgTier.unique", `${at}.id`, `duplicate tier: ${tier.id}`);
+                if (into.filled(level.id, "manifest.orgLevel.id", `${at}.id`, "a level needs an id")) {
+                    if (ids.has(level.id)) {
+                        into.add("manifest.orgLevel.unique", `${at}.id`, `duplicate level: ${level.id}`);
                         wellFormed = false;
                     }
-                    ids.add(tier.id);
+                    ids.add(level.id);
                 }
                 else
                     wellFormed = false;
-                if (!into.filled(tier.label, "manifest.orgTier.label", `${at}.label`, "a tier needs the label a desk shows for it"))
+                if (!into.filled(level.label, "manifest.orgLevel.label", `${at}.label`, "a level needs the label a desk shows for it"))
                     wellFormed = false;
             });
             if (wellFormed && !ids.has("person")) {
-                into.add("manifest.orgTiers.person", `${path}.orgTiers`, "a declared ladder states the whole ladder and must include person, the subject of every resolution");
+                into.add("manifest.orgLevels.person", `${path}.orgLevels`, "a declared ladder states the whole ladder and must include person, the subject of every resolution");
             }
         }
     }
@@ -460,7 +460,7 @@ function validateCustomCapabilities(value, path, into) {
             into.add("task.custom.ui", `${at}.ui`, "a custom capability needs a ui description");
             return;
         }
-        into.oneOf(custom.ui.kind, CUSTOM_UI_KINDS, "task.custom.ui.kind", `${at}.ui.kind`);
+        into.oneOf(custom.ui.control, CUSTOM_UI_CONTROLS, "task.custom.ui.control", `${at}.ui.control`);
         into.filled(custom.ui.label, "task.custom.ui.label", `${at}.ui.label`, "a custom control needs a label");
         into.oneOf(custom.ui.placement, CUSTOM_UI_PLACEMENTS, "task.custom.ui.placement", `${at}.ui.placement`);
         if (custom.ui.render !== undefined)
@@ -485,48 +485,48 @@ function validateCustomCapabilities(value, path, into) {
         }
     });
 }
-const DEFAULT_TIER_IDS = DEFAULT_TIERS.map(tier => tier.id);
+const DEFAULT_LEVEL_IDS = DEFAULT_LEVELS.map(level => level.id);
 const POLICY_SETTINGS = membersOf({ on: true, off: true, agent: true });
 const POLICY_KEYS = new Set([
     ...TASK_CAPABILITIES.voice, ...TASK_CAPABILITIES.chat, ...TASK_CAPABILITIES.email, "dial",
 ].filter(name => name !== "browsers" && name !== "dispositions" && name !== "custom"));
 const AGENT_SETTABLE = /^(hold|mute|skill:.+)$/;
 const isLocked = (value) => isPlainObject(value) && value.lockedBy !== undefined;
-/** The tier ids in force: the manifest's, or the defaults when the caller holds no manifest. */
-const tierIds = (tiers) => tiers ?? DEFAULT_TIER_IDS;
-/** `lockedBy`: a declared tier other than `person`, who never locks their own value. */
-function validateLockedByInto(value, rule, path, tiers, into) {
-    if (!into.filled(value, rule, path, "lockedBy names the tier that locked it"))
+/** The level ids in force: the manifest's, or the defaults when the caller holds no manifest. */
+const levelIds = (levels) => levels ?? DEFAULT_LEVEL_IDS;
+/** `lockedBy`: a declared level other than `person`, who never locks their own value. */
+function validateLockedByInto(value, rule, path, levels, into) {
+    if (!into.filled(value, rule, path, "lockedBy names the level that locked it"))
         return;
     into.require(value !== "person", `${rule}.person`, path, "a person never locks their own value");
-    into.require(tierIds(tiers).includes(value), `${rule}.unknown`, path, `${String(value)} is not a tier this manifest declares: in force are ${tierIds(tiers).join(", ")}`);
+    into.require(levelIds(levels).includes(value), `${rule}.unknown`, path, `${String(value)} is not a level this manifest declares: in force are ${levelIds(levels).join(", ")}`);
 }
 /** `{ lockedBy, reason? }` standing in for a value: who locked it, and a reason if given. */
-function validateLockedInto(value, rule, path, tiers, into) {
-    validateLockedByInto(value.lockedBy, `${rule}.lockedBy`, `${path}.lockedBy`, tiers, into);
+function validateLockedInto(value, rule, path, levels, into) {
+    validateLockedByInto(value.lockedBy, `${rule}.lockedBy`, `${path}.lockedBy`, levels, into);
     if (value.reason !== undefined)
         into.filled(value.reason, `${rule}.reason`, `${path}.reason`, "a reason must not be empty when present");
 }
 /** What every resolved value carries: who set it, and who locked it if anyone. */
-function validateResolvedInto(value, rule, path, tiers, into) {
-    if (into.filled(value.setBy, `${rule}.setBy`, `${path}.setBy`, "setBy names who stated the value: a tier, or provisioning")) {
-        into.require(value.setBy === "provisioning" || tierIds(tiers).includes(value.setBy), `${rule}.setBy.unknown`, `${path}.setBy`, `${String(value.setBy)} is neither provisioning nor a tier this manifest declares`);
+function validateResolvedInto(value, rule, path, levels, into) {
+    if (into.filled(value.setBy, `${rule}.setBy`, `${path}.setBy`, "setBy names who stated the value: a level, or provisioning")) {
+        into.require(value.setBy === "provider" || levelIds(levels).includes(value.setBy), `${rule}.setBy.unknown`, `${path}.setBy`, `${String(value.setBy)} is neither provisioning nor a level this manifest declares`);
     }
     if (value.lockedBy !== undefined)
-        validateLockedByInto(value.lockedBy, `${rule}.lockedBy`, `${path}.lockedBy`, tiers, into);
+        validateLockedByInto(value.lockedBy, `${rule}.lockedBy`, `${path}.lockedBy`, levels, into);
     if (value.reason !== undefined) {
         into.filled(value.reason, `${rule}.reason`, `${path}.reason`, "a reason must not be empty when present");
         into.require(value.lockedBy !== undefined, `${rule}.reason.unexpected`, `${path}.reason`, "a reason goes with lockedBy: it says why it was locked");
     }
 }
-/** The tier ids a manifest puts in force, for validators that receive one. */
-function manifestTiers(manifest) {
+/** The level ids a manifest puts in force, for validators that receive one. */
+function manifestLevels(manifest) {
     if (!isPlainObject(manifest))
         return undefined;
-    const declared = Array.isArray(manifest.orgTiers)
-        ? manifest.orgTiers.filter((tier) => isPlainObject(tier) && typeof tier.id === "string")
+    const declared = Array.isArray(manifest.orgLevels)
+        ? manifest.orgLevels.filter((level) => isPlainObject(level) && typeof level.id === "string")
         : undefined;
-    return effectiveTiers(declared).map(tier => tier.id);
+    return effectiveLevels(declared).map(level => level.id);
 }
 const CUSTOM_RENDERS = membersOf({ inline: true, page: true });
 const CREDENTIAL_FIELD_TYPES = membersOf({ text: true, password: true });
@@ -556,6 +556,9 @@ function validateBrowsers(value, path, into) {
             names.add(browser.name);
         }
         into.filled(browser.purpose, "task.browser.purpose", `${at}.purpose`, "a browser needs a purpose");
+        if (browser.urlVisibility !== undefined) {
+            into.oneOf(browser.urlVisibility, URL_VISIBILITIES, "task.browser.urlVisibility", `${at}.urlVisibility`);
+        }
         if (into.filled(browser.url, "task.browser.url", `${at}.url`, "a browser needs a url")) {
             let scheme;
             try {
@@ -569,7 +572,7 @@ function validateBrowsers(value, path, into) {
         // Reuse and its scheme travel together. A reusing browser with no scheme would otherwise
         // inherit whatever a host happened to default to, which is how two tasks end up sharing a
         // session nobody intended. The guide names the rule for the missing case.
-        if (browser.reuse === true) {
+        if (browser.sharedSession === true) {
             if (browser.isolationScheme === undefined) {
                 into.add("task.browser.isolationScheme.required", `${at}.isolationScheme`, `a reusing browser must declare one of: ${ISOLATION_SCHEME_VALUES.join(", ")}`);
             }
@@ -577,11 +580,11 @@ function validateBrowsers(value, path, into) {
                 into.require(ISOLATION_SCHEME_VALUES.includes(browser.isolationScheme), "task.browser.isolationScheme", `${at}.isolationScheme`, `an isolation scheme must be one of: ${ISOLATION_SCHEME_VALUES.join(", ")}`);
             }
         }
-        else if (browser.reuse === false) {
-            into.require(browser.isolationScheme === undefined, "task.browser.isolationScheme.unexpected", `${at}.isolationScheme`, "a browser that does not reuse must not declare an isolation scheme");
+        else if (browser.sharedSession === false) {
+            into.require(browser.isolationScheme === undefined, "task.browser.isolationScheme.unexpected", `${at}.isolationScheme`, "a browser that does not share its session must not declare an isolation scheme");
         }
         else {
-            into.add("task.browser.reuse", `${at}.reuse`, "a browser must say whether it reuses a session");
+            into.add("task.browser.sharedSession", `${at}.sharedSession`, "a browser must say whether its session is shared across tasks");
         }
     });
 }
@@ -649,7 +652,7 @@ function validateHandlingHistory(value, path, into) {
     });
 }
 /** Present only while consulting, and only on voice: elsewhere there is nobody to consult. */
-const TASK_MEDIA_STATES = membersOf({ ready: true, ended: true });
+const TASK_MEDIA_STATES = membersOf({ started: true, ended: true });
 /** Real-time media is a voice affair, and its state is one of two words. */
 function validateTaskMedia(value, channel, path, into) {
     if (value === undefined)
@@ -674,7 +677,7 @@ function validateConsultation(value, channel, path, into) {
     if (value.since !== undefined)
         into.timestamp(value.since, "task.consultation.since", `${path}.since`);
 }
-const LEAD_STATUSES = membersOf({ requested: true, joined: true });
+const LEAD_STAGES = membersOf({ requested: true, joined: true });
 /** The agent's request for a lead. Voice only; `joined` names the lead, `requested` cannot. */
 function validateLead(value, channel, path, into) {
     if (value === undefined)
@@ -685,8 +688,8 @@ function validateLead(value, channel, path, into) {
         into.add("task.lead.shape", path, "lead must be an object when present");
         return;
     }
-    if (into.oneOf(value.status, LEAD_STATUSES, "task.lead.status", `${path}.status`)) {
-        if (value.status === "joined") {
+    if (into.oneOf(value.stage, LEAD_STAGES, "task.lead.stage", `${path}.stage`)) {
+        if (value.stage === "joined") {
             into.require(isUserId(value.leadId), "task.lead.leadId", `${path}.leadId`, "a joined lead is named by their user id");
         }
         else {
@@ -730,11 +733,11 @@ function validateTaskInto(task, context, path, into) {
     // The allowance is coupled to the mode: a provider that will complete the task itself is going
     // to act on the allowance, so it must state one; a provider waiting for `complete` may omit it
     // to say it imposes no deadline. Present, it is a duration either way.
-    if (task.completionAllowance === undefined) {
-        into.require(task.completionMode !== "provider-automatic", "task.completionAllowance.required", `${path}.completionAllowance`, "provider-automatic completion needs an allowance to act on");
+    if (task.wrapAllowance === undefined) {
+        into.require(task.completionMode !== "provider-automatic", "task.wrapAllowance.required", `${path}.wrapAllowance`, "provider-automatic completion needs an allowance to act on");
     }
     else {
-        into.require(isDurationSeconds(task.completionAllowance), "task.completionAllowance", `${path}.completionAllowance`, "completionAllowance must be a whole number of seconds, zero or more, or omitted under agent-command");
+        into.require(isDurationSeconds(task.wrapAllowance), "task.wrapAllowance", `${path}.wrapAllowance`, "wrapAllowance must be a whole number of seconds, zero or more, or omitted under agent-command");
     }
     // The channel is fixed per provider by its manifest, so a task claiming another one is a
     // task Omni would render with the wrong controls.
@@ -742,8 +745,8 @@ function validateTaskInto(task, context, path, into) {
     if (task.reference !== undefined) {
         into.filled(task.reference, "task.reference", `${path}.reference`, "a reference must not be empty when present");
     }
-    if (task.contact !== undefined)
-        validateContactInto(task.contact, `${path}.contact`, into, context.tiers);
+    if (task.party !== undefined)
+        validateContactInto(task.party, `${path}.party`, into, context.levels);
     validateBrowsers(task.browsers, `${path}.browsers`, into);
     validateTaskAttributes(task.attributes, `${path}.attributes`, into);
     validateHandlingHistory(task.handlingHistory, `${path}.handlingHistory`, into);
@@ -775,7 +778,7 @@ function validateTaskInto(task, context, path, into) {
         // queue provides -- browsers, dispositions, custom controls -- is content, not a control.
         if (isLocked(declared)) {
             if (into.require(name !== "browsers" && name !== "dispositions" && name !== "custom", "task.capability.locked.unexpected", `${path}.capabilities.${name}`, `${name} is what the queue provides, not a control anyone locks`)) {
-                validateLockedInto(declared, "task.capability.locked", `${path}.capabilities.${name}`, context.tiers, into);
+                validateLockedInto(declared, "task.capability.locked", `${path}.capabilities.${name}`, context.levels, into);
             }
             continue;
         }
@@ -826,15 +829,15 @@ function validateBreakState(value, path, into) {
         return;
     }
     into.oneOf(value.approval, BREAK_APPROVALS, "break.approval", `${path}.approval`);
-    into.require(typeof value.accepting === "boolean", "break.accepting", `${path}.accepting`, "accepting must be a boolean");
+    into.require(typeof value.mayAsk === "boolean", "break.mayAsk", `${path}.mayAsk`, "mayAsk says whether the agent may ask for a break: a boolean");
     for (const field of ["refusedReason", "decisionReason"]) {
         if (value[field] !== undefined) {
             into.filled(value[field], `break.${field}`, `${path}.${field}`, `${field} must not be empty when present`);
         }
     }
-    // The refusal is the reason the control is withdrawn; beside `accepting: true` it explains nothing.
+    // The refusal is the reason the control is withdrawn; beside `mayAsk: true` it explains nothing.
     if (value.refusedReason !== undefined) {
-        into.require(value.accepting !== true, "break.refusedReason.accepting", `${path}.refusedReason`, "refusedReason is shown when accepting is false; omit it while the agent may ask");
+        into.require(value.mayAsk !== true, "break.refusedReason.mayAsk", `${path}.refusedReason`, "refusedReason is shown when mayAsk is false; omit it while the agent may ask");
     }
     if (value.retryAfterMs !== undefined) {
         into.require(typeof value.retryAfterMs === "number" && Number.isFinite(value.retryAfterMs) && value.retryAfterMs >= 0, "break.retryAfterMs", `${path}.retryAfterMs`, "retryAfterMs must be a non-negative number when present");
@@ -910,7 +913,7 @@ function validateTeamRosterInto(roster, path, context, into) {
         }
     }
     if (roster.policies !== undefined)
-        validateTeamPoliciesInto(roster.policies, `${path}.policies`, into, context.tiers);
+        validateTeamPoliciesInto(roster.policies, `${path}.policies`, into, context.levels);
     if (roster.requests === undefined) {
         // `[]` says nobody is asking; omission says the lead may not be asked. A login that may be
         // asked therefore always carries the list.
@@ -986,11 +989,11 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
         return into.violations;
     }
     const channel = isPlainObject(manifest) && typeof manifest.channel === "string" ? manifest.channel : "voice";
-    const tiers = context.tiers ?? manifestTiers(manifest);
-    into.oneOf(snapshot.status, CONNECTION_STATUSES, "snapshot.status", `${path}.status`);
-    if (into.filled(snapshot.sessionId, "snapshot.sessionId", `${path}.sessionId`, "a snapshot needs the session id it belongs to")
-        && context.sessionId !== undefined) {
-        into.require(snapshot.sessionId === context.sessionId, "snapshot.sessionId.mismatch", `${path}.sessionId`, `a snapshot for session ${String(snapshot.sessionId)} on a login whose session is ${context.sessionId}`);
+    const levels = context.levels ?? manifestLevels(manifest);
+    into.oneOf(snapshot.transport, TRANSPORT_STATUSES, "snapshot.transport", `${path}.status`);
+    if (into.filled(snapshot.loginId, "snapshot.loginId", `${path}.loginId`, "a snapshot needs the login id it belongs to")
+        && context.loginId !== undefined) {
+        into.require(snapshot.loginId === context.loginId, "snapshot.loginId.mismatch", `${path}.loginId`, `a snapshot for session ${String(snapshot.loginId)} on a login whose session is ${context.loginId}`);
     }
     validateBreakState(snapshot.break, `${path}.break`, into);
     // The count is the provider's confirmation of how much work it answered with. Stated, never
@@ -1006,7 +1009,7 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
         const seen = new Set();
         let assisting;
         snapshot.tasks.forEach((task, index) => {
-            validateTaskInto(task, { channel, tiers }, `${path}.tasks[${index}]`, into);
+            validateTaskInto(task, { channel, levels }, `${path}.tasks[${index}]`, into);
             // A lead assists one call at a time.
             if (isPlainObject(task) && task.assisting !== undefined) {
                 if (assisting !== undefined)
@@ -1071,7 +1074,7 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
         into.add("team.required", `${path}.team`, "the login declares capabilities.team, so every snapshot carries a roster: [] when nobody is in it");
     }
     if (snapshot.team !== undefined)
-        validateTeamRosterInto(snapshot.team, `${path}.team`, { ...context, tiers }, into);
+        validateTeamRosterInto(snapshot.team, `${path}.team`, { ...context, levels }, into);
     return into.violations;
 }
 // ---------------------------------------------------------------------------
@@ -1114,7 +1117,7 @@ function validateTaskOutcome(value, path, into) {
             into.add("event.taskEnded.outcome.type", `${path}.type`, `unsupported outcome: ${String(value.type)}`);
     }
 }
-function validateProviderSummary(value, path, into) {
+function validateQueueSummary(value, path, into) {
     if (!isPlainObject(value)) {
         into.add("event.summary.shape", path, "a provider summary must be an object");
         return;
@@ -1155,11 +1158,11 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
         return into.violations;
     }
     const channel = isPlainObject(manifest) && typeof manifest.channel === "string" ? manifest.channel : "voice";
-    const tiers = context.tiers ?? manifestTiers(manifest);
+    const levels = context.levels ?? manifestLevels(manifest);
     into.filled(envelope.id, "event.id", `${path}.id`, "an event needs an id");
-    if (into.filled(envelope.sessionId, "event.sessionId", `${path}.sessionId`, "an event needs the session id it belongs to")
-        && context.sessionId !== undefined) {
-        into.require(envelope.sessionId === context.sessionId, "event.sessionId.mismatch", `${path}.sessionId`, `an event for session ${String(envelope.sessionId)} on a login whose session is ${context.sessionId}`);
+    if (into.filled(envelope.loginId, "event.loginId", `${path}.loginId`, "an event needs the login id it belongs to")
+        && context.loginId !== undefined) {
+        into.require(envelope.loginId === context.loginId, "event.loginId.mismatch", `${path}.loginId`, `an event for session ${String(envelope.loginId)} on a login whose session is ${context.loginId}`);
     }
     const idle = isPlainObject(manifest) && isPlainObject(manifest.idleCapabilities) ? manifest.idleCapabilities : {};
     into.timestamp(envelope.occurredAt, "event.occurredAt", `${path}.occurredAt`);
@@ -1172,28 +1175,28 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
     switch (event.type) {
         case "snapshot":
             into.oneOf(event.reason, SNAPSHOT_REASONS, "event.snapshot.reason", `${at}.reason`);
-            into.violations.push(...validateSnapshot(event.snapshot, manifest, `${at}.snapshot`, { ...context, tiers }));
+            into.violations.push(...validateSnapshot(event.snapshot, manifest, `${at}.snapshot`, { ...context, levels }));
             break;
-        case "provider-status":
-            into.oneOf(event.status, CONNECTION_STATUSES, "event.providerStatus.status", `${at}.status`);
+        case "transport-status":
+            into.oneOf(event.status, TRANSPORT_STATUSES, "event.transportStatus.status", `${at}.status`);
             // An error says how to revive it; any other status has nothing to revive.
             if (event.status === "error") {
-                if (into.require(event.recovery !== undefined, "event.providerStatus.recovery.required", `${at}.recovery`, "an error names its recovery: reconnect, or reauthenticate")) {
-                    into.oneOf(event.recovery, CONNECTION_RECOVERIES, "event.providerStatus.recovery", `${at}.recovery`);
+                if (into.require(event.recovery !== undefined, "event.transportStatus.recovery.required", `${at}.recovery`, "an error names its recovery: reconnect, or reauthenticate")) {
+                    into.oneOf(event.recovery, TRANSPORT_RECOVERIES, "event.transportStatus.recovery", `${at}.recovery`);
                 }
             }
             else {
-                into.require(event.recovery === undefined, "event.providerStatus.recovery.unexpected", `${at}.recovery`, "recovery goes with an error; nothing needs reviving here");
+                into.require(event.recovery === undefined, "event.transportStatus.recovery.unexpected", `${at}.recovery`, "recovery goes with an error; nothing needs reviving here");
             }
             if (event.message !== undefined) {
-                into.filled(event.message, "event.providerStatus.message", `${at}.message`, "a message must not be empty when present");
+                into.filled(event.message, "event.transportStatus.message", `${at}.message`, "a message must not be empty when present");
             }
             break;
         case "break-state":
             validateBreakState(event.break, `${at}.break`, into);
             break;
         case "task-offered":
-            validateTaskInto(event.task, { channel, tiers }, `${at}.task`, into);
+            validateTaskInto(event.task, { channel, levels }, `${at}.task`, into);
             // An offer introduces work that is not yet under way; work in progress arrives only on a snapshot.
             if (isPlainObject(event.task) && typeof event.task.phase === "string") {
                 into.require(OFFERABLE_PHASES.includes(event.task.phase), "event.taskOffered.phase", `${at}.task.phase`, `task-offered introduces a task as ${OFFERABLE_PHASES.join(", ")}, never as ${event.task.phase}`);
@@ -1214,10 +1217,10 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             }
             break;
         case "task-updated":
-            validateTaskInto(event.task, { channel, tiers }, `${at}.task`, into);
+            validateTaskInto(event.task, { channel, levels }, `${at}.task`, into);
             break;
-        case "task-media-ready":
-            into.require(isTaskId(event.taskId), "event.taskMediaReady.taskId", `${at}.taskId`, "a task id is required");
+        case "task-media-started":
+            into.require(isTaskId(event.taskId), "event.taskMediaStarted.taskId", `${at}.taskId`, "a task id is required");
             break;
         case "task-media-ended":
             into.require(isTaskId(event.taskId), "event.taskMediaEnded.taskId", `${at}.taskId`, "a task id is required");
@@ -1235,11 +1238,11 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
                 into.require(typeof event.html === "string", "event.announcement.html", `${at}.html`, "html must be a string when present");
             }
             break;
-        case "provider-summary":
-            validateProviderSummary(event.summary, `${at}.summary`, into);
+        case "queue-summary":
+            validateQueueSummary(event.summary, `${at}.summary`, into);
             break;
         case "team-updated":
-            validateTeamRosterInto(event.team, `${at}.team`, { ...context, tiers }, into);
+            validateTeamRosterInto(event.team, `${at}.team`, { ...context, levels }, into);
             break;
         case "contacts-updated":
             into.require(idle.contacts === true, "event.contacts.capability", `${at}.contacts`, "contacts-updated requires the contacts idle capability");
@@ -1278,7 +1281,7 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
 // ---------------------------------------------------------------------------
 const PREFERENCE_ID = /^(hold|mute|skill:.+)$/;
 /** The choices left to the person, each with where it stands. */
-function validatePreferencesInto(value, path, into, tiers) {
+function validatePreferencesInto(value, path, into, levels) {
     if (!Array.isArray(value)) {
         into.add("preferences.shape", path, "preferences must be an array");
         return;
@@ -1297,11 +1300,11 @@ function validatePreferencesInto(value, path, into, tiers) {
         }
         into.filled(preference.label, "preference.label", `${at}.label`, "a preference needs a label");
         into.require(typeof preference.enabled === "boolean", "preference.enabled", `${at}.enabled`, "a preference says where it stands");
-        validateResolvedInto(preference, "preference", at, tiers, into);
+        validateResolvedInto(preference, "preference", at, levels, into);
     });
 }
 /** The team's policy per capability as the lead sees it: the setting, who set it, who locked it. */
-function validateTeamPoliciesInto(value, path, into, tiers) {
+function validateTeamPoliciesInto(value, path, into, levels) {
     if (!isPlainObject(value)) {
         into.add("team.policies.shape", path, "policies must be an object keyed by capability");
         return;
@@ -1319,7 +1322,7 @@ function validateTeamPoliciesInto(value, path, into, tiers) {
         if (into.oneOf(policy.setting, POLICY_SETTINGS, "team.policy.setting", `${at}.setting`)) {
             into.require(policy.setting !== "agent" || AGENT_SETTABLE.test(key), "team.policy.agent", `${at}.setting`, `${key} is the team's, on or off; only hold, mute and skills may be left to the person`);
         }
-        validateResolvedInto(policy, "team.policy", at, tiers, into);
+        validateResolvedInto(policy, "team.policy", at, levels, into);
         into.require(policy.setBy !== "person", "team.policy.setBy", `${at}.setBy`, "a team policy is not set by a person");
     }
 }
@@ -1365,12 +1368,6 @@ 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");
-    if (!isPlainObject(report.browsers)) {
-        into.add("host.browsers.shape", `${path}.browsers`, "a host report says what its chrome shows of a task browser's URL");
-    }
-    else {
-        into.oneOf(report.browsers.urlVisibility, URL_VISIBILITIES, "host.browsers.urlVisibility", `${path}.browsers.urlVisibility`);
-    }
     if (report.audio === undefined)
         return into.violations;
     if (!isPlainObject(report.audio)) {
@@ -1474,7 +1471,7 @@ function validateUser(value, rule, path, into) {
     into.require(isUserId(value.id), `${rule}.id`, `${path}.id`, "an identity needs a provider-issued user id");
     into.filled(value.displayName, `${rule}.displayName`, `${path}.displayName`, "an identity needs a display name");
 }
-function validateSessionCapabilitiesInto(value, path, into, tiers) {
+function validateUserCapabilitiesInto(value, path, into, levels) {
     if (!isPlainObject(value)) {
         into.add("authentication.capabilities.shape", path, "a usable login declares its capabilities: an object, {} when it has none");
         return;
@@ -1488,7 +1485,7 @@ function validateSessionCapabilitiesInto(value, path, into, tiers) {
             if (Array.isArray(declared) && declared.length === 0) {
                 into.add("authentication.capability.preferences.empty", `${path}.preferences`, "a login with nothing left to the person omits preferences rather than declaring an empty list");
             }
-            validatePreferencesInto(declared, `${path}.preferences`, into, tiers);
+            validatePreferencesInto(declared, `${path}.preferences`, into, levels);
             continue;
         }
         if (name === "team") {
@@ -1521,7 +1518,7 @@ export function validateAuthenticationState(state, path = "authentication", cont
     // may carry an identity. Anything else is a state claiming knowledge it does not have.
     if (state.status === "authenticated" || state.status === "refreshing") {
         validateUser(state.identity, "authentication.identity", `${path}.identity`, into);
-        validateSessionCapabilitiesInto(state.capabilities, `${path}.capabilities`, into, context.tiers);
+        validateUserCapabilitiesInto(state.capabilities, `${path}.capabilities`, into, context.levels);
     }
     else if (state.status === "expired") {
         if (state.identity !== undefined)