@synapse-sdk/client 0.3.4 → 0.3.6

package/dist/calls.d.ts

@@ -1,7 +1,7 @@
 import { SynapseError, type CallId, type ServiceContract } from "@synapse-sdk/core";
 import type { Node } from "./node.ts";
 import { type RespFrame, type Session } from "./session.ts";
-import type { CallEvent, CallOptions, Run, RunStatus } from "./types.ts";
+import type { CallOptions, Run, RunStatus } from "./types.ts";
 /** A fresh call id (WP §8.2): 16 random bytes. */
 export declare function newCallId(): CallId;
 export declare class RunImpl<U, R> implements Run<U, R> {
@@ -17,12 +17,14 @@ export declare class RunImpl<U, R> implements Run<U, R> {
     get status(): RunStatus;
     get result(): Promise<R>;
     then<A = R, B = never>(onFulfilled?: ((v: R) => A | PromiseLike<A>) | null, onRejected?: ((e: unknown) => B | PromiseLike<B>) | null): Promise<A | B>;
+    catch<B = never>(onRejected?: ((e: unknown) => B | PromiseLike<B>) | null): Promise<R | B>;
+    finally(onFinally?: (() => void) | null): Promise<R>;
     /** The session's demux hands frames here; `null` = the session ended with the call pending. */
     deliver(f: RespFrame | null): void;
     /** Starts the per-frame reader once the request is written (frames can arrive before `writeCall` returns). */
     start(): void;
-    nextUpdate(): Promise<U | undefined>;
-    updates(): AsyncIterable<U>;
+    next(): Promise<U | undefined>;
+    [Symbol.asyncIterator](): AsyncIterator<U>;
     /** Cooperative cancel (WP §8.4): tells the broker, then waits for its `canceled` terminal frame. `connection_lost` without sending once the session ended. */
     cancel(reason?: string): Promise<void>;
     /** Dropped with the call in flight: the runtime is told (best effort). */
@@ -39,5 +41,3 @@ export declare function startOn<U, R>(node: Node, session: Session, svc: string,
  * unhandled rejection.
  */
 export declare function failedRun<U, R>(error: SynapseError): Run<U, R>;
-/** `callStream`: the updates and the result as one ordered stream; `break` cancels. */
-export declare function callStream<U, R>(run: Run<U, R>): AsyncGenerator<CallEvent<U, R>, void, undefined>;

package/dist/calls.js

@@ -4,7 +4,7 @@
 // a frame on a later session (WP §8.4: ownership is checked, never inferred).
 import { FLAGS, SynapseError, TYPES, decode as decodeBody, encode as encodeBody, nowUs, toHex, validateSync } from "@synapse-sdk/core";
 import { outcomeUnknown } from "./session.js";
-import { AsyncQueue, deferred } from "./util.js";
+import { AsyncQueue, deferred, rethrowLater } from "./util.js";
 /** A fresh call id (WP §8.2): 16 random bytes. */
 export function newCallId() { const b = new Uint8Array(16); crypto.getRandomValues(b); return b; }
 export class RunImpl {
@@ -42,6 +42,8 @@ export class RunImpl {
     get status() { return this.#status; }
     get result() { return this.#result.promise; }
     then(onFulfilled, onRejected) { return this.#result.promise.then(onFulfilled, onRejected); }
+    catch(onRejected) { return this.then(undefined, onRejected); }
+    finally(onFinally) { return this.#result.promise.finally(onFinally); }
     /** The session's demux hands frames here; `null` = the session ended with the call pending. */
     deliver(f) { this.#frames.push(f); }
     /** Starts the per-frame reader once the request is written (frames can arrive before `writeCall` returns). */
@@ -93,11 +95,17 @@ export class RunImpl {
                     continue;
                 u = r.value;
             }
-            this.#updates.push(u);
-            try {
-                this.opts.onUpdate?.(u);
+            // The callback form takes the stream (as `subscribe(topic, cb)`): a throwing `onUpdate` is rethrown later and the reading goes on.
+            if (this.opts.onUpdate) {
+                try {
+                    this.opts.onUpdate(u);
+                }
+                catch (e) {
+                    rethrowLater(e);
+                }
             }
-            catch { /* the caller's */ }
+            else
+                this.#updates.push(u);
         }
     }
     #updates = new AsyncQueue(4096);
@@ -129,8 +137,8 @@ export class RunImpl {
             this.#result.resolve(r.value);
         }
     }
-    async nextUpdate() { return this.#updates.next(); }
-    updates() { return this.#updates; }
+    next() { return this.#updates.next(); }
+    [Symbol.asyncIterator]() { return this.#updates[Symbol.asyncIterator](); }
     #sendCancel(reason) {
         if (!this.session.isLive)
             return;
@@ -191,21 +199,11 @@ export function failedRun(error) {
         status: "failed",
         result,
         then: (onFulfilled, onRejected) => result.then(onFulfilled, onRejected),
-        nextUpdate: async () => undefined,
-        updates: async function* () { },
+        catch: onRejected => result.catch(onRejected),
+        finally: onFinally => result.finally(onFinally),
+        next: async () => undefined,
+        [Symbol.asyncIterator]: async function* () { },
         cancel: async () => { },
         [Symbol.asyncDispose]: async () => { },
     };
 }
-/** `callStream`: the updates and the result as one ordered stream; `break` cancels. */
-export async function* callStream(run) {
-    try {
-        for await (const u of run.updates())
-            yield { type: "update", data: u };
-        yield { type: "result", data: await run.result };
-    }
-    finally {
-        if (run.status === "pending" || run.status === "running")
-            run.cancel("caller").catch(() => { });
-    }
-}

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 export * from "@synapse-sdk/core";
 export { Synapse, FIRST_CONNECT_GIVE_UP_MS } from "./synapse.ts";
 export { defaultReconnectPolicy, exponentialPolicy, fixedPolicy, withMaxAttempts } from "./node.ts";
-export { callStream } from "./calls.ts";
 export { isTasksRefusal } from "./tasks.ts";
 export { setMoqDebug } from "./moq_log.ts";
 export type * from "./types.ts";

package/dist/index.js

@@ -2,7 +2,6 @@
 export * from "@synapse-sdk/core";
 export { Synapse, FIRST_CONNECT_GIVE_UP_MS } from "./synapse.js";
 export { defaultReconnectPolicy, exponentialPolicy, fixedPolicy, withMaxAttempts } from "./node.js";
-export { callStream } from "./calls.js";
 export { isTasksRefusal } from "./tasks.js";
 export { setMoqDebug } from "./moq_log.js";
 export { brokerCertHelperUrl, discoverBrokerCertSha256, ensureWebTransport } from "./session.js";

package/dist/scene.d.ts

@@ -132,8 +132,10 @@ export declare class Mirror {
     epoch: string | undefined;
     version: number;
     hash: string;
-    /** An authored diff skipped a version; cleared by the next snapshot. */
-    gap: boolean;
+    /** An authored diff skipped a version (not applied; the track is read again from its snapshot): the highest version seen then. Cleared once the copy is back at it (PLAN v0.34 §2.2). */
+    gap: number | undefined;
+    /** The live track's first keyframe of the incarnation is in the copy. */
+    liveKeyed: boolean;
     pending: number;
     authored: Entities;
     live: LiveTable;
@@ -146,12 +148,16 @@ export declare class Mirror {
     dropHandle(id: number): void;
     /** The hierarchy now (recomputed only after a change of the ids, a parent or an order; the same object while equal). */
     tree(): SceneTree;
-    /** A snapshot of incarnation `epoch` replaces the authored copy. Not yet `attached`: the reader catches up first (`attach`). */
+    /** A snapshot of incarnation `epoch` replaces the authored copy. The first one is not yet `attached`: that is the task's, once the copy is at the version the open answered. */
     applySnapshot(epoch: string, s: Snapshot): void;
-    /** The reader has applied everything this node held when it bound the incarnation. */
+    /** The copy is current as of the attach (the task checked it): `attached`. */
     attach(): void;
-    /** One applied batch: its ops folded into the authored copy. */
-    applyDiff(d: Diff, warn: Warn): void;
+    /**
+     * One applied batch: its ops folded into the authored copy, when it is the next version. Otherwise it is not applied
+     * (`false`): a gap, `synced` false until the copy is back at the version seen; the reader reads the track again from
+     * its snapshot (PLAN v0.34 §2.2).
+     */
+    applyDiff(d: Diff, warn: Warn): boolean;
     /** A keyframe replaces the live table. */
     applyKeyframe(k: LiveFrame): void;
     /** One tick folded into the live table; its removals go to the feeds. */
@@ -177,18 +183,22 @@ type Event = {
 } | {
     kind: "nodeEnded";
 }
+/** The answer of `synapse/scene/open` of attempt `attempt`. */
+ | {
+    kind: "opened";
+    attempt: number;
+    result: Result<unknown>;
+}
 /** The reader applied an authored frame of incarnation `epoch`: the mirror is at `version`. */
  | {
     kind: "applied";
     epoch: string;
     version: number;
 }
-/** Reading `attempt` caught up with incarnation `epoch` at `version`: the task binds the claims, then attaches the handle. */
+/** The reader applied the live track's first keyframe of incarnation `epoch`. */
  | {
-    kind: "attach";
-    attempt: number;
+    kind: "liveKeyed";
     epoch: string;
-    version: number;
 }
 /** The reader of attempt `attempt` ended: the incarnation it bound and its final frame's reason (none: the tracks or the session went). */
  | {
@@ -385,7 +395,8 @@ export declare class SceneHandleImpl implements SceneHandle {
 }
 /**
  * The active project's scene (one per project; one task per node, shared by every handle). Resolves
- * once the handle is attached, or at once `detached` when the runtime says no project is active; the
+ * once the handle is attached (the copy at the version `synapse/scene/open` answered, or past it), or at
+ * once `detached` when the runtime says no project is active; the
  * handle then follows the incarnations as they come and go. Without a session (before the first, between
  * two) the task waits for the next one, like after a drop.
  */