@xema/omni-protocol 0.1.36 → 0.1.37

package/dist/testing.js

@@ -619,7 +619,7 @@ export class TaskStream {
     tasks = new Map();
     // Every dial the stream can place an outcome against: one the host said it placed, or one a
     // task carried on `onCall` or in its record -- which is how a dial made before a transfer is known
-    // to whoever holds the task now. `ended` once its outcome arrived, since an outcome comes once.
+    // to whoever holds the task now. `answered` or `ended` once its outcome arrived, since it comes once.
     dials = new Map();
     /** The host placed a dial: its outcome, whenever it arrives, is one the stream expects. */
     dialled(dialId) {
@@ -640,7 +640,16 @@ export class TaskStream {
     }
     static stated(task) {
         const media = isRecord(task) && (task.media === "started" || task.media === "ended") ? task.media : "none";
-        return { phase: String(isRecord(task) ? task.phase : undefined), media };
+        // The stage of every dialled entry the room names by its dial, so an update can be held to the
+        // outcome that moves it.
+        const stages = new Map();
+        if (isRecord(task) && Array.isArray(task.onCall)) {
+            for (const entry of task.onCall) {
+                if (isRecord(entry) && typeof entry.dialId === "string" && typeof entry.stage === "string")
+                    stages.set(entry.dialId, entry.stage);
+            }
+        }
+        return { phase: String(isRecord(task) ? task.phase : undefined), media, stages };
     }
     /** Replaces what is known with a snapshot's tasks, as a snapshot replaces Omni's state. */
     seed(snapshot) {
@@ -696,6 +705,14 @@ export class TaskStream {
                     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-started and ends on task-media-ended`);
                     }
+                    // The same pairing for a dialled entry: the dial-outcome is the transition, the stage is
+                    // the state, and the outcome comes first. An update that joins an entry on its own is
+                    // moving what only an answered outcome moves.
+                    for (const [dialId, stage] of next.stages) {
+                        if (stage === "joined" && known.stages.get(dialId) === "ringing" && this.dials.get(dialId) !== "answered") {
+                            refuse("stream.taskUpdated.stage", `${at}.task.onCall`, `a task-updated re-states a stage, it does not move it: ${dialId} was ringing and the update says joined before any answered dial-outcome for it`);
+                        }
+                    }
                     this.tasks.set(id, next);
                 }
                 this.noteDials(event.task);
@@ -746,10 +763,10 @@ export class TaskStream {
                 if (dial === undefined) {
                     refuse("stream.dialOutcome.unknown", `${at}.dialId`, `${event.dialId} is not a dial the host placed or a task carried: an outcome ends a dial somebody made`);
                 }
-                else if (dial === "ended") {
+                else if (dial !== "placed") {
                     refuse("stream.dialOutcome.duplicate", `${at}.dialId`, `${event.dialId} already has its outcome; a dial ends once`);
                 }
-                this.dials.set(event.dialId, "ended");
+                this.dials.set(event.dialId, event.outcome === "answered" ? "answered" : "ended");
                 break;
             }
             default:

package/guide.md

@@ -2859,7 +2859,9 @@ still-ringing `destination` calls that dial off, with `cancelled` as its outcome
 **The entry says where it stands.** A dialled entry carries `stage`: `ringing` until its dial is
 answered, `joined` after. The `dial-outcome` is the transition and the stage is the state, the same
 pairing as `task-media-started` and `media`: an `answered` outcome and the task restated with the
-entry `joined` say one thing twice, and any other outcome removes the entry. It is stated rather
+entry `joined` say one thing twice, and any other outcome removes the entry. The outcome comes
+first: a `task-updated` that itself moves an entry from `ringing` to `joined` before an `answered`
+outcome for its dial is refused (`stream.taskUpdated.stage`), as an update that moves `media` is. It is stated rather
 than left to whoever placed the dial because that knowledge lives in one process: after a reload,
 on a second session, or on a supervisor's screen the snapshot is the only source, and a room that
 cannot tell ringing from joined says it contains someone who may never arrive. Nobody ringing is

package/package.json

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