@resonatehq/sdk 0.11.3 → 0.11.5

package/dist/{context.js → src/context.js}

@@ -1,4 +1,5 @@
 import exceptions from "./exceptions.js";
+import { joinId } from "./ids.js";
 import { randomUUID } from "./platform.js";
 import { Exponential, Never } from "./retries.js";
 import * as util from "./util.js";
@@ -144,7 +145,6 @@ export class InnerContext {
     retryPolicy;
     nonRetryableErrors;
     originId;
-    prefixId;
     branchId;
     parentId;
     clock;
@@ -156,16 +156,14 @@ export class InnerContext {
     rpc = this.rfc.bind(this);
     beginRun = this.lfi.bind(this);
     beginRpc = this.rfi.bind(this);
-    constructor({ id, oId = id, prId = id, bId = id, pId = id, func, clock, registry, dependencies, optsBuilder, timeout, version, retryPolicy, nonRetryableErrors = [], }) {
+    constructor({ id, oId = id, bId = id, pId = id, func, clock, registry, dependencies, optsBuilder, timeout, version, retryPolicy, nonRetryableErrors = [], }) {
         this.id = id;
+        // The lineage origin: everything before the first `:` of every id in this
+        // workflow, set at the top (resonate.run/rpc) and carried through the
+        // resonate:origin tag unchanged forever -- including into detached
+        // children, which mint `${originId}:d${hash}` off it. Also the anchor
+        // every descendant id extends, so it doubles as the id-generation root.
         this.originId = oId;
-        // The id-generation prefix (resonate:prefix). Set once at the top
-        // (resonate.run/rpc) and propagated down unchanged forever -- through every
-        // child AND across detached re-roots -- never tracking the (diverging)
-        // lineage origin. Bounds recursive detached ids: each level mints
-        // `${prefixId}.d${hash}` off this fixed prefix. Mirrors the Python SDK's
-        // `Context.prefix_id`.
-        this.prefixId = prId;
         this.branchId = bId;
         this.parentId = pId;
         this.func = func;
@@ -185,7 +183,6 @@ export class InnerContext {
         return new InnerContext({
             id,
             oId: this.originId,
-            prId: this.prefixId,
             bId: this.branchId,
             pId: this.id,
             func,
@@ -290,7 +287,7 @@ export class InnerContext {
             return new DIE(true, exceptions.REGISTRY_FUNCTION_NOT_REGISTERED(funcOrName.name, opts.version));
         }
         const idChanged = opts.id !== undefined;
-        const id = idChanged ? opts.id : util.detachedId(this.prefixId, this.seqid());
+        const id = idChanged ? opts.id : util.detachedId(this.originId, this.seqid());
         this.seq++;
         const func = registered ? registered.name : funcOrName;
         const version = registered ? registered.version : 1;
@@ -301,16 +298,23 @@ export class InnerContext {
             version: registered ? registered.version : opts.version || 1,
         };
         return new RFI(id, func, version, 
-        // detached ALWAYS breaks the origin lineage (breaksLineage: true): it is
-        // fire-and-forget and runs as its own root, so resonate:origin must equal
-        // its own id (origin == id == branch), starting a fresh lineage. Recursive
-        // detached ids stay bounded NOT via origin but via resonate:prefix, which
-        // is propagated down unchanged (set in remoteCreateReq = this.prefixId) and
-        // is what `util.detachedId(this.prefixId, ...)` roots the id on. So each
-        // level mints `${prefix}.d${hash}` off the same fixed prefix instead of
-        // off its own grown id. Mirrors the Python SDK (detached origin = its id,
-        // prefix carried forward).
-        this.remoteCreateReq({ id, data, opts, maxTimeout: Number.MAX_SAFE_INTEGER, breaksLineage: true }), "detached");
+        // A detached child keeps the *parent's* origin rather than re-rooting
+        // onto its own id: the server derives the origin as everything before
+        // the first `:` and requires every id in a lineage to start with
+        // `{origin}:`. Its id hangs off the origin (`${origin}:d${hash}`, one
+        // segment past it, bounding recursion), so the origin is also the
+        // resonate:parent it declares -- a parent of the spawning context would
+        // be rejected. resonate:branch stays the child's own id: a detached
+        // child roots its own branch. An explicit opts.id still starts a fresh
+        // self-anchored lineage (breaksLineage).
+        this.remoteCreateReq({
+            id,
+            data,
+            opts,
+            maxTimeout: Number.MAX_SAFE_INTEGER,
+            breaksLineage: idChanged,
+            parent: idChanged ? id : this.originId,
+        }), "detached");
     }
     promise({ timeout, data, tags } = {}) {
         const id = this.seqid();
@@ -366,18 +370,18 @@ export class InnerContext {
                 param: { headers: {}, data },
                 tags: {
                     "resonate:scope": "local",
-                    "resonate:branch": this.branchId,
-                    "resonate:parent": this.id,
+                    // An explicit-id child (breaksLineage) starts a fresh self-anchored
+                    // lineage: the server requires an id to extend its declared branch /
+                    // parent / origin, which only the id itself satisfies.
+                    "resonate:branch": breaksLineage ? id : this.branchId,
+                    "resonate:parent": breaksLineage ? id : this.id,
                     "resonate:origin": breaksLineage ? id : this.originId,
-                    // Prefix is set at the top and propagates down unchanged forever,
-                    // independent of origin (which detached/explicit-id may break).
-                    "resonate:prefix": this.prefixId,
                     ...opts.tags,
                 },
             },
         };
     }
-    remoteCreateReq({ id, data, opts, breaksLineage, maxTimeout = this.info.timeout, }) {
+    remoteCreateReq({ id, data, opts, breaksLineage, parent, maxTimeout = this.info.timeout, }) {
         // timeout cannot be greater than parent timeout (unless detached)
         const timeoutAt = Math.min(this.clock.now() + opts.timeout, maxTimeout);
         return {
@@ -390,11 +394,8 @@ export class InnerContext {
                     "resonate:scope": "global",
                     "resonate:target": opts.target,
                     "resonate:branch": id,
-                    "resonate:parent": this.id,
+                    "resonate:parent": parent ?? (breaksLineage ? id : this.id),
                     "resonate:origin": breaksLineage ? id : this.originId,
-                    // Prefix is set at the top and propagates down unchanged forever,
-                    // independent of origin (which detached/explicit-id may break).
-                    "resonate:prefix": this.prefixId,
                     ...opts.tags,
                 },
                 param: { headers: {}, data },
@@ -414,24 +415,29 @@ export class InnerContext {
                 tags: {
                     "resonate:scope": "global",
                     "resonate:branch": id,
-                    "resonate:parent": this.id,
+                    "resonate:parent": breaksLineage ? id : this.id,
                     "resonate:origin": breaksLineage ? id : this.originId,
-                    // Prefix is set at the top and propagates down unchanged forever,
-                    // independent of origin (which detached/explicit-id may break).
-                    "resonate:prefix": this.prefixId,
                     ...tags,
                 },
             },
         };
     }
     sleepCreateOpts({ id, time }) {
+        // The timer is the promise's own deadline: resonate:timer makes the server
+        // settle it RESOLVED (rather than timed out) when the deadline arrives,
+        // which fires the callbacks every sleeper is suspended on. The
+        // resonate:target is what makes that deadline *happen*: the server only
+        // schedules timeouts for promises carrying an address, so a target-less
+        // timer would simply never fire. The flip side is that a target also
+        // spawns a task, dispatched immediately rather than at the wake; a timer
+        // names no function to run, so the worker that receives it drops it and
+        // lets the deadline do the waking (see Core.executeUntilBlocked).
         const tags = {
             "resonate:scope": "global",
+            "resonate:target": this.options().target,
             "resonate:branch": id,
             "resonate:parent": this.id,
             "resonate:origin": this.originId,
-            // Prefix is set at the top and propagates down unchanged forever.
-            "resonate:prefix": this.prefixId,
             "resonate:timer": "true",
         };
         // timeout cannot be greater than parent timeout
@@ -448,7 +454,8 @@ export class InnerContext {
         };
     }
     seqid() {
-        return `${this.id}.${this.seq}`;
+        // A bare root joins its first lineage segment with ':', deeper segments
+        // join with '.' -- see ids.joinId.
+        return joinId(this.id, `${this.seq}`);
     }
 }
-//# sourceMappingURL=context.js.map

package/dist/{core.d.ts → src/core.d.ts}

@@ -42,4 +42,3 @@ export declare class Core {
     private fulfillTask;
     onMessage(msg: Message): Promise<Status | undefined>;
 }
-//# sourceMappingURL=core.d.ts.map

package/dist/{core.js → src/core.js}

@@ -3,6 +3,7 @@ import exceptions, { ResonateError } from "./exceptions.js";
 import { isRedirect, isSuccess } from "./network/types.js";
 import { randomUUID } from "./platform.js";
 import { Constant, Exponential, Linear, Never } from "./retries.js";
+import { TraceCollector } from "./trace.js";
 import * as util from "./util.js";
 export class Core {
     pid;
@@ -37,6 +38,37 @@ export class Core {
     }
     async executeUntilBlocked(task, rootPromise, preload) {
         util.assert(task.state === "acquired", `expected task state to be 'acquired', got '${task.state}'`);
+        // A resonate:timer promise is a durable sleep. It names no function to
+        // run; it only carries a task at all because the target that gets the
+        // server to *schedule* its deadline also spawns one.
+        if (rootPromise.tags["resonate:timer"] === "true") {
+            const collector = new TraceCollector();
+            if (rootPromise.state === "pending") {
+                // Not yet due: drop the task and let the deadline settle the promise,
+                // which is what wakes the sleepers. Dropping means exactly that: no
+                // fulfill (that would end the sleep early), no suspend (a task cannot
+                // await its own promise), and no release (the server re-dispatches a
+                // released task immediately, which would spin). The lease simply
+                // lapses; a re-delivery before the wake is dropped again, and one
+                // after it takes the settled branch below.
+                this.logger.debug({ component: "core", taskId: task.id, timeoutAt: rootPromise.timeoutAt }, "dropping not-yet-due timer task");
+                return { kind: "suspended", awaited: [], trace: collector.getTrace() };
+            }
+            // Settled: a durable sleep whose wake has passed. It carries no
+            // function/args, so it cannot go through the computation; fulfill the
+            // task with the promise's settlement. (The server normally fulfills a
+            // timer's task itself when the deadline settles the promise, so this
+            // only catches a delivery already in flight at that moment.)
+            const status = {
+                kind: "done",
+                id: rootPromise.id,
+                state: rootPromise.state === "resolved" ? "resolved" : "rejected",
+                value: rootPromise.value?.data,
+                trace: collector.getTrace(),
+            };
+            await this.fulfillTask(task, rootPromise, status);
+            return status;
+        }
         const computation = this.createComputation(rootPromise.id, util.buildEffects(this.send, this.codec, { id: task.id, version: task.version }, preload));
         try {
             const status = await computation.executeUntilBlocked(rootPromise);
@@ -140,7 +172,13 @@ export class Core {
             });
         }
         const rootPromise = this.codec.decodePromise(res.data.promise);
-        return this.executeUntilBlocked(res.data.task, rootPromise, res.data.preload);
+        const acquiredTask = res.data.task;
+        this.heartbeat.start(acquiredTask);
+        try {
+            return await this.executeUntilBlocked(acquiredTask, rootPromise, res.data.preload);
+        }
+        finally {
+            this.heartbeat.stop(acquiredTask);
+        }
     }
 }
-//# sourceMappingURL=core.js.map

package/dist/{coroutine.d.ts → src/coroutine.d.ts}

@@ -34,4 +34,3 @@ export declare class Coroutine<T> {
     private settle;
     private completedPromise;
 }
-//# sourceMappingURL=coroutine.d.ts.map

package/dist/{coroutine.js → src/coroutine.js}

@@ -256,4 +256,3 @@ export class Coroutine {
         };
     }
 }
-//# sourceMappingURL=coroutine.js.map

package/dist/{decorator.d.ts → src/decorator.d.ts}

@@ -66,4 +66,3 @@ export declare class Decorator<TRet> {
     private toLiteral;
     private safeGeneratorNext;
 }
-//# sourceMappingURL=decorator.d.ts.map

package/dist/{decorator.js → src/decorator.js}

@@ -147,4 +147,3 @@ export class Decorator {
         }
     }
 }
-//# sourceMappingURL=decorator.js.map

package/dist/{encryptor.d.ts → src/encryptor.d.ts}

@@ -7,4 +7,3 @@ export declare class NoopEncryptor implements Encryptor {
     encrypt(plaintext: Value): Value;
     decrypt(ciphertext: Value): Value;
 }
-//# sourceMappingURL=encryptor.d.ts.map

package/dist/{encryptor.js → src/encryptor.js}

@@ -6,4 +6,3 @@ export class NoopEncryptor {
         return ciphertext;
     }
 }
-//# sourceMappingURL=encryptor.js.map

package/dist/{exceptions.d.ts → src/exceptions.d.ts}

@@ -32,8 +32,8 @@ declare const _default: {
     ENCODING_ARGS_UNDECODEABLE: (f: string, c: any) => ResonateError;
     ENCODING_RETV_UNENCODEABLE: (f: string, c: any) => ResonateError;
     ENCODING_RETV_UNDECODEABLE: (f: string, c: any) => ResonateError;
+    INVALID_ID: (id: string, reason: string) => ResonateError;
     PANIC: (src: string, msg: string | undefined) => ResonateError;
     SERVER_ERROR: (m: any, r?: boolean, e?: ResonateServerError) => ResonateError;
 };
 export default _default;
-//# sourceMappingURL=exceptions.d.ts.map

package/dist/{exceptions.js → src/exceptions.js}

@@ -75,6 +75,11 @@ export default {
             cause: c,
         });
     },
+    INVALID_ID: (id, reason) => {
+        // A caller-supplied root id the server's id format cannot carry — see
+        // `ids.validateRootId`.
+        return new ResonateError("10", "InvalidId", `Invalid id '${id}': ${reason}`);
+    },
     PANIC: (src, msg) => {
         src = src.charAt(0).toUpperCase() + src.slice(1);
         msg = msg ? `: ${msg}` : "";
@@ -86,4 +91,3 @@ export default {
         return new ResonateError("99", "Server", m, { retriable: r, serverError: e });
     },
 };
-//# sourceMappingURL=exceptions.js.map

package/dist/src/heartbeat.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "./logger.js";
+import type { Send } from "./types.js";
+export type HeartbeatTask = {
+    id: string;
+    version: number;
+};
+export interface Heartbeat {
+    start(task: HeartbeatTask): void;
+    stop(task?: HeartbeatTask): void;
+}
+export declare class AsyncHeartbeat implements Heartbeat {
+    private readonly pid;
+    private readonly delay;
+    private readonly send;
+    private readonly logger;
+    private intervalId;
+    private readonly tasks;
+    constructor(pid: string, delay: number, send: Send, logger: Logger);
+    start(task: HeartbeatTask): void;
+    private heartbeat;
+    stop(task?: HeartbeatTask): void;
+}
+export declare class NoopHeartbeat implements Heartbeat {
+    start(_task: HeartbeatTask): void;
+    stop(_task?: HeartbeatTask): void;
+}

package/dist/src/heartbeat.js

@@ -0,0 +1,54 @@
+import { randomUUID } from "./platform.js";
+import { VERSION } from "./util.js";
+export class AsyncHeartbeat {
+    pid;
+    delay;
+    send;
+    logger;
+    intervalId;
+    tasks = new Map();
+    constructor(pid, delay, send, logger) {
+        this.pid = pid;
+        this.delay = delay;
+        this.send = send;
+        this.logger = logger;
+    }
+    start(task) {
+        this.tasks.set(task.id, task.version);
+        if (!this.intervalId) {
+            this.intervalId = setInterval(() => this.heartbeat(), this.delay);
+        }
+    }
+    heartbeat() {
+        if (this.tasks.size === 0)
+            return;
+        this.send({
+            kind: "task.heartbeat",
+            head: { corrId: randomUUID(), version: VERSION },
+            data: {
+                pid: this.pid,
+                tasks: [...this.tasks].map(([id, version]) => ({ id, version })),
+            },
+        }).catch((err) => {
+            this.logger.warn({ component: "heartbeat", pid: this.pid, error: err instanceof Error ? err.message : String(err) }, "Failed to send heartbeat");
+        });
+    }
+    stop(task) {
+        if (task) {
+            if (this.tasks.get(task.id) === task.version) {
+                this.tasks.delete(task.id);
+            }
+        }
+        else {
+            this.tasks.clear();
+        }
+        if (this.tasks.size === 0 && this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+export class NoopHeartbeat {
+    start(_task) { }
+    stop(_task) { }
+}

package/dist/src/ids.d.ts

@@ -0,0 +1,46 @@
+/** Separates the origin from the lineage below it. A bare root joins its
+ * first lineage segment with this. */
+export declare const ORIGIN_SEP = ":";
+/** Separates lineage segments below the origin. */
+export declare const LINEAGE_SEP = ".";
+/**
+ * Append a lineage `segment` to `ancestor`.
+ *
+ * A bare root joins its *first* segment with `:`; an ancestor that already
+ * carries lineage joins deeper segments with `.`, keeping the whole subtree
+ * under one origin:
+ *
+ *   joinId("root", "1")     -> "root:1"
+ *   joinId("root:1", "2")   -> "root:1.2"
+ *   joinId("root:1.2", "3") -> "root:1.2.3"
+ *
+ * This is exactly the separator rule the server's `resonate:branch` /
+ * `resonate:parent` validation applies.
+ */
+export declare function joinId(ancestor: string, segment: string): string;
+/**
+ * The lineage origin of `id`: everything before the first `:`.
+ *
+ * Mirrors the server's `origin()`. An id with no lineage below it (a root) is
+ * its own origin.
+ */
+export declare function originOf(id: string): string;
+/**
+ * Validate a caller-supplied root id (`run` / `rpc` / `schedule` / an explicit
+ * `options({ id })`), returning it.
+ *
+ * Only `:` is **reserved**: a root becomes the origin of its whole lineage,
+ * and the origin is everything before an id's *first* `:`, so an origin
+ * holding one could never be split back out of any id. The server rejects it
+ * outright (`colon_in_origin`).
+ *
+ * `.` is allowed. It separates lineage segments *below* the origin, which is
+ * only ever read after the origin has been split off, so a dotted root id
+ * (`my.app.workflow`) is unambiguous:
+ *
+ *   my.app.workflow -> my.app.workflow:1 -> my.app.workflow:1.1
+ *
+ * @throws {ResonateError} here, at the call site that named the workflow,
+ *   rather than surfacing later as an opaque 400 from a background create.
+ */
+export declare function validateRootId(id: string): string;

package/dist/src/ids.js

@@ -0,0 +1,85 @@
+// The promise id format, in one place.
+//
+// The server treats a promise id as `<origin>:<lineage>`: the **origin** is
+// everything before the first `:`, and the lineage segments below it are
+// `.`-separated:
+//
+//   root -> root:1 -> root:1.1 -> root:1.1.1
+//
+// The origin is load-bearing. `promise.register_callback` and `task.suspend`
+// require an awaiter and its awaited promise to share one, it selects the
+// origin-state partition a request is routed to, and `promise.create` rejects
+// an id that does not extend the `resonate:origin` / `resonate:branch` /
+// `resonate:parent` it declares. So the SDK mints ids with `joinId` and reads
+// them back with `originOf`, both of which mirror the server's own rules.
+//
+// A root id is supplied by the caller and becomes the origin of its whole
+// lineage, so `validateRootId` keeps `:` out of it, exactly as the server does
+// for the origin tag itself. `.` is *not* reserved there: it only separates
+// segments below the origin, and the origin is recovered by splitting on the
+// first `:`, so a dotted root (`my.app.workflow`) survives the round trip
+// intact.
+import exceptions from "./exceptions.js";
+/** Separates the origin from the lineage below it. A bare root joins its
+ * first lineage segment with this. */
+export const ORIGIN_SEP = ":";
+/** Separates lineage segments below the origin. */
+export const LINEAGE_SEP = ".";
+/**
+ * Append a lineage `segment` to `ancestor`.
+ *
+ * A bare root joins its *first* segment with `:`; an ancestor that already
+ * carries lineage joins deeper segments with `.`, keeping the whole subtree
+ * under one origin:
+ *
+ *   joinId("root", "1")     -> "root:1"
+ *   joinId("root:1", "2")   -> "root:1.2"
+ *   joinId("root:1.2", "3") -> "root:1.2.3"
+ *
+ * This is exactly the separator rule the server's `resonate:branch` /
+ * `resonate:parent` validation applies.
+ */
+export function joinId(ancestor, segment) {
+    const sep = ancestor.includes(ORIGIN_SEP) ? LINEAGE_SEP : ORIGIN_SEP;
+    return `${ancestor}${sep}${segment}`;
+}
+/**
+ * The lineage origin of `id`: everything before the first `:`.
+ *
+ * Mirrors the server's `origin()`. An id with no lineage below it (a root) is
+ * its own origin.
+ */
+export function originOf(id) {
+    const sep = id.indexOf(ORIGIN_SEP);
+    return sep === -1 ? id : id.slice(0, sep);
+}
+/**
+ * Validate a caller-supplied root id (`run` / `rpc` / `schedule` / an explicit
+ * `options({ id })`), returning it.
+ *
+ * Only `:` is **reserved**: a root becomes the origin of its whole lineage,
+ * and the origin is everything before an id's *first* `:`, so an origin
+ * holding one could never be split back out of any id. The server rejects it
+ * outright (`colon_in_origin`).
+ *
+ * `.` is allowed. It separates lineage segments *below* the origin, which is
+ * only ever read after the origin has been split off, so a dotted root id
+ * (`my.app.workflow`) is unambiguous:
+ *
+ *   my.app.workflow -> my.app.workflow:1 -> my.app.workflow:1.1
+ *
+ * @throws {ResonateError} here, at the call site that named the workflow,
+ *   rather than surfacing later as an opaque 400 from a background create.
+ */
+export function validateRootId(id) {
+    if (!id) {
+        throw exceptions.INVALID_ID(id, "id must not be empty");
+    }
+    if (id.includes("\0")) {
+        throw exceptions.INVALID_ID(id, "id must not contain null bytes");
+    }
+    if (id.includes(ORIGIN_SEP)) {
+        throw exceptions.INVALID_ID(id, `id must not contain '${ORIGIN_SEP}': it separates the origin from the lineage in the ids the SDK mints below this one, so an id holding one could never be split back out`);
+    }
+    return id;
+}

package/dist/{index.d.ts → src/index.d.ts}

@@ -17,4 +17,3 @@ export { Resonate, type ResonateFunc, type ResonateHandle } from "./resonate.js"
 export { Constant, Exponential, Linear, Never, type RetryPolicy } from "./retries.js";
 export { awaitThenResumeOrSuspend, blockIsSole, dedupIsSole, type Event, exclusiveLifecycle, isWellFormed, rootSpawn, rpcHasCallee, runHasCallee, spawnIsFirst, type Trace, TraceCollector, terminalIsLast, uniqueSpawn, uniqueTerminal, } from "./trace.js";
 export type { Effects, Func } from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/{index.js → src/index.js}

@@ -13,4 +13,3 @@ export { Registry } from "./registry.js";
 export { Resonate } from "./resonate.js";
 export { Constant, Exponential, Linear, Never } from "./retries.js";
 export { awaitThenResumeOrSuspend, blockIsSole, dedupIsSole, exclusiveLifecycle, isWellFormed, rootSpawn, rpcHasCallee, runHasCallee, spawnIsFirst, TraceCollector, terminalIsLast, uniqueSpawn, uniqueTerminal, } from "./trace.js";
-//# sourceMappingURL=index.js.map

package/dist/{logger.d.ts → src/logger.d.ts}

@@ -30,4 +30,3 @@ export declare class ConsoleLogger implements Logger {
     private shouldLog;
     private emit;
 }
-//# sourceMappingURL=logger.d.ts.map

package/dist/{logger.js → src/logger.js}

@@ -51,4 +51,3 @@ export class ConsoleLogger {
         writer(JSON.stringify(entry));
     }
 }
-//# sourceMappingURL=logger.js.map

package/dist/{network → src/network}/http.d.ts

@@ -63,4 +63,3 @@ export declare class PollMessageSource implements HttpAdapter {
     stop(): Promise<void>;
     onReceive(callback: (msg: Message) => void): void;
 }
-//# sourceMappingURL=http.d.ts.map

package/dist/{network → src/network}/http.js

@@ -253,4 +253,3 @@ export class PollMessageSource {
         this.callbacks.push(callback);
     }
 }
-//# sourceMappingURL=http.js.map

package/dist/{network → src/network}/local.d.ts

@@ -185,4 +185,3 @@ export declare class LocalNetwork implements Network {
     recv(callback: (msg: Message) => void): void;
     private dispatchMessages;
 }
-//# sourceMappingURL=local.d.ts.map

package/dist/{network → src/network}/local.js

@@ -6,6 +6,13 @@ import { isResponse } from "./types.js";
 // CONSTANTS
 // =============================================================================
 const PENDING_RETRY_TTL = 30000;
+function isExternalPromise(promise) {
+    const { tags } = promise;
+    return (tags["resonate:scope"] === "global" ||
+        tags["resonate:external"] === "true" ||
+        tags["resonate:target"] !== undefined ||
+        tags["resonate:timer"] === "true");
+}
 export class Server {
     promises = new Map();
     tasks = new Map();
@@ -262,9 +269,15 @@ export class Server {
             listeners: new Set(),
         };
         changes.push(this.setPromise(promise));
-        changes.push(this.setPTimeout({ id: req.data.id, timeout: req.data.timeoutAt }));
         const address = req.data.tags["resonate:target"];
         if (address) {
+            // Only a promise carrying an address is expired by the tick loop. A
+            // target-less promise (a bare ctx.promise) is never timed out by the
+            // scheduler, so a durable timer has to carry a target to fire at all —
+            // see Context.sleep. Scheduling one here regardless would make this
+            // simulation *more* permissive than the server, which is invisible to
+            // every test that only asserts success.
+            changes.push(this.setPTimeout({ id: req.data.id, timeout: req.data.timeoutAt }));
             const delay = Number(req.data.tags["resonate:delay"]);
             const deferred = Number.isFinite(delay) && now < delay;
             const task = {
@@ -354,6 +367,12 @@ export class Server {
             return { response: this.response("promise.register_listener", 404, "Promise not found"), changes: [] };
         }
         const changes = [];
+        if (!isExternalPromise(promise)) {
+            return {
+                response: this.response("promise.register_listener", 422, "Awaited promise is not awaitable"),
+                changes: [],
+            };
+        }
         // Project for the logically-pending check and for the response — the
         // listener is registered only when the promise is logically pending,
         // and the response always reflects the projected awaited promise.
@@ -487,7 +506,12 @@ export class Server {
             listeners: new Set(),
         };
         changes.push(this.setPromise(promise));
-        changes.push(this.setPTimeout({ id: actionData.id, timeout: actionData.timeoutAt }));
+        // Same scheduler invariant as promise.create: only a promise carrying a
+        // target is expired by the tick loop. A task.create root always carries
+        // one in practice, but the guard keeps the invariant explicit.
+        if (actionData.tags["resonate:target"]) {
+            changes.push(this.setPTimeout({ id: actionData.id, timeout: actionData.timeoutAt }));
+        }
         // Step 2: Create task in acquired state
         const task = {
             id: actionData.id,
@@ -1355,4 +1379,3 @@ export class LocalNetwork {
         }
     }
 }
-//# sourceMappingURL=local.js.map

package/dist/{network → src/network}/nats.d.ts

@@ -56,4 +56,3 @@ export declare class NatsNetwork implements Network {
     recv(callback: (msg: Message) => void): void;
     private onMsg;
 }
-//# sourceMappingURL=nats.d.ts.map