@synapse-sdk/client 0.3.3 → 0.3.6

package/dist/tasks.js

@@ -7,9 +7,10 @@
 // unchanged part keeps its object.
 import { SynapseError } from "@synapse-sdk/core";
 import { replaceEqualDeep } from "./util.js";
+import { ulid } from "./scene.js";
 /** The namespaces the facet reads and writes (the runtime's names). */
 export const TASKS_NAMESPACES = { declarations: "tasks", status: "task_status", catalog: "task_catalog" };
-/** What `status.value` is before the runtime said anything: neither scope's state known, no tasks. */
+/** What `status.get()` is before the runtime said anything: neither scope's state known, no tasks. */
 export const EMPTY_TASKS_STATUS = { robot: { state: undefined, tasks: {} }, project: { state: undefined, tasks: {} } };
 const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 /** A run row (`robot` / `project`: `{state, since, reason?}`) as the scope's run fields. */
@@ -49,7 +50,7 @@ export function tasksStatusOf(rows, unplaced = () => { }) {
     return { robot: { ...runOf(rows.robot), tasks: robot }, project: { ...runOf(rows.project), tasks: project } };
 }
 /**
- * A read-only handle over one namespace of the node: `value` is `derive` of the mirror, recomputed only
+ * A read-only handle over one namespace of the node: `get()` is `derive` of the mirror, recomputed only
  * when the mirror changed and shared structurally with the previous value. The namespace is opened on
  * the first touch of any member.
  */
@@ -65,8 +66,8 @@ class DerivedHandle {
         this.#value = empty;
     }
     #handle() { return (this.#h ??= this.open()); }
-    get value() {
-        const rows = this.#handle().value;
+    get() {
+        const rows = this.#handle().get();
         if (rows !== this.#from) {
             this.#from = rows;
             this.#value = replaceEqualDeep(this.#value, this.derive(rows));
@@ -77,9 +78,9 @@ class DerivedHandle {
     ready() { return this.#handle().ready(); }
     async *watch() {
         for await (const _ of this.#handle().watch())
-            yield this.value;
+            yield this.get();
     }
-    subscribe(listener) { return this.#handle().subscribe(listener); }
+    onChange(cb) { return this.#handle().onChange(() => cb(this.get())); }
 }
 /** The robot's declarations: the node's handle on `tasks`; every write waits for the value to be current first. */
 class Declarations {
@@ -89,20 +90,33 @@ class Declarations {
         this.open = open;
     }
     #handle() { return (this.#h ??= this.open()); }
-    get value() { return this.#handle().value; }
-    get(instance) { return this.#handle().get(instance); }
+    get(instance) {
+        const h = this.#handle();
+        return (instance === undefined ? h.get() : h.get(instance));
+    }
     get synced() { return this.#handle().synced; }
     get status() { return this.#handle().status; }
+    changed() { return this.#handle().changed(); }
     ready() { return this.#handle().ready(); }
     async set(a, b) {
         const h = this.#handle();
         await h.ready();
-        await (typeof a === "string" ? h.set(a, b) : h.set(a));
+        if (typeof a === "string") {
+            await h.set(a, b);
+            return;
+        }
+        // One object: a declaration (its `ref` is a string) gets a minted instance; else it is a map of declarations.
+        if (typeof a.ref === "string") {
+            const instance = ulid();
+            await h.set(instance, a);
+            return instance;
+        }
+        await h.set(a);
     }
     async delete(instance) { const h = this.#handle(); await h.ready(); await h.delete(instance); }
     async clear() { const h = this.#handle(); await h.ready(); await h.clear(); }
     watch(instance) { return this.#handle().watch(instance); }
-    subscribe(listener) { return this.#handle().subscribe(listener); }
+    onChange(cb) { return this.#handle().onChange(cb); }
 }
 /** `node.tasks`. `attach(name)` hands out the node's handle on a namespace; `call` starts a call on the current session. */
 export class TasksFacet {

package/dist/topics.d.ts

@@ -147,5 +147,7 @@ export declare class TopicSubscription<T> implements Subscription<T> {
     /** Ends the subscription: the follow task stops, every track is closed, a pending `next()` returns `undefined`. */
     unsubscribe(): void;
     [Symbol.asyncDispose](): Promise<void>;
+    /** The callback form's read loop (`node.subscribe(topic, cb)`): `cb` with each batch `next()` returns, until the subscription ends; a throwing `cb` is rethrown later and the loop goes on. */
+    deliverTo(cb: (batch: Envelope<T>[]) => void): void;
 }
 export {};

package/dist/topics.js

@@ -16,7 +16,7 @@ import { FLAGS, MSGPACK, SynapseError, TYPES, auParamSets, auSyncPoints, decode
 import { Handle, start as startHandle } from "./channel.js";
 import { FecReader, FecWriter, ReportWriter, feedbackListener, requireFec } from "./fec.js";
 import { RETAINED_FRAME_MAX_AGE_MS, StreamWriter, latestSubscription, moqTimestamp, streamTopicSubscription, waitActive, writeLatest } from "./session.js";
-import { AsyncQueue, deferred, withTimeout, TIMEOUT } from "./util.js";
+import { AsyncQueue, deferred, rethrowLater, withTimeout, TIMEOUT } from "./util.js";
 /** moq's cap on one `stream` frame (a group's cache). */
 const STREAM_FRAME_MAX = 32 * 1024 * 1024;
 /** The bound on adding one publisher (its broadcast, its `desc`, its `data` subscription). */
@@ -627,6 +627,22 @@ export class TopicSubscription {
         this.#signal();
     }
     async [Symbol.asyncDispose]() { this.unsubscribe(); }
+    /** The callback form's read loop (`node.subscribe(topic, cb)`): `cb` with each batch `next()` returns, until the subscription ends; a throwing `cb` is rethrown later and the loop goes on. */
+    deliverTo(cb) {
+        void (async () => {
+            for (;;) {
+                const b = await this.next();
+                if (!b)
+                    return;
+                try {
+                    cb(b);
+                }
+                catch (e) {
+                    rethrowLater(e);
+                }
+            }
+        })();
+    }
 }
 /** A source is done: its subscription and its request are closed (its pending read settles as the end). */
 function closeSource(src) {