@resonatehq/sdk 0.10.0 → 0.10.2

package/dist/network/local.js

@@ -6,9 +6,6 @@ import { isResponse } from "./types.js";
 // CONSTANTS
 // =============================================================================
 const PENDING_RETRY_TTL = 30000;
-// =============================================================================
-// SERVER
-// =============================================================================
 export class Server {
     promises = new Map();
     tasks = new Map();
@@ -17,6 +14,15 @@ export class Server {
     tTimeouts = [];
     sTimeouts = [];
     outgoing = [];
+    // When "eager", every action handler converges physical state to logical
+    // state by running tryEagerTimeout for the relevant id(s) before the
+    // handler body. When "none", convergence happens only via debug.tick (or
+    // an equivalent background mechanism) — read paths must rely on
+    // projection to return the logical state.
+    timeoutMode;
+    constructor(opts = {}) {
+        this.timeoutMode = opts.timeoutMode ?? "eager";
+    }
     apply(now, req) {
         const changes = [];
         const error = this.validate(req);
@@ -26,28 +32,28 @@ export class Server {
         let result;
         switch (req.kind) {
             case "promise.get": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.promiseGet(now, req);
                 break;
             }
             case "promise.create": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.promiseCreate(now, req);
                 break;
             }
             case "promise.settle": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.promiseSettle(now, req);
                 break;
             }
             case "promise.register_callback": {
-                changes.push(...this.tryAutoTimeout(now, req.data.awaited));
-                changes.push(...this.tryAutoTimeout(now, req.data.awaiter));
+                changes.push(...this.tryEagerTimeout(now, req.data.awaited));
+                changes.push(...this.tryEagerTimeout(now, req.data.awaiter));
                 result = this.promiseRegisterCallback(now, req);
                 break;
             }
             case "promise.register_listener": {
-                changes.push(...this.tryAutoTimeout(now, req.data.awaited));
+                changes.push(...this.tryEagerTimeout(now, req.data.awaited));
                 result = this.promiseRegisterListener(now, req);
                 break;
             }
@@ -56,51 +62,51 @@ export class Server {
                 break;
             }
             case "task.get": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.taskGet(now, req);
                 break;
             }
             case "task.create": {
-                changes.push(...this.tryAutoTimeout(now, req.data.action.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.action.data.id));
                 result = this.taskCreate(now, req);
                 break;
             }
             case "task.acquire": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.taskAcquire(now, req);
                 break;
             }
             case "task.release": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.taskRelease(now, req);
                 break;
             }
             case "task.fulfill": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.taskFulfill(now, req);
                 break;
             }
             case "task.suspend": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 for (const action of req.data.actions) {
-                    changes.push(...this.tryAutoTimeout(now, action.data.awaited));
+                    changes.push(...this.tryEagerTimeout(now, action.data.awaited));
                 }
                 result = this.taskSuspend(now, req);
                 break;
             }
             case "task.halt": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.taskHalt(now, req);
                 break;
             }
             case "task.continue": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
                 result = this.taskContinue(now, req);
                 break;
             }
             case "task.fence": {
-                changes.push(...this.tryAutoTimeout(now, req.data.id));
-                changes.push(...this.tryAutoTimeout(now, req.data.action.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.id));
+                changes.push(...this.tryEagerTimeout(now, req.data.action.data.id));
                 result = this.taskFence(now, req);
                 break;
             }
@@ -192,13 +198,20 @@ export class Server {
         if (!promise) {
             return { response: this.response("promise.get", 404, "Promise not found"), changes: [] };
         }
-        return { response: this.response("promise.get", 200, { promise: this.toPromiseRecord(promise) }), changes: [] };
+        return {
+            response: this.response("promise.get", 200, {
+                promise: this.toPromiseRecord(this.projectedPromise(now, promise)),
+            }),
+            changes: [],
+        };
     }
     promiseCreate(now, req) {
-        const existing = this.promises.get(req.data.id);
-        if (existing) {
+        const existingPromise = this.promises.get(req.data.id);
+        if (existingPromise) {
             return {
-                response: this.response("promise.create", 200, { promise: this.toPromiseRecord(existing) }),
+                response: this.response("promise.create", 200, {
+                    promise: this.toPromiseRecord(this.projectedPromise(now, existingPromise)),
+                }),
                 changes: [],
             };
         }
@@ -214,13 +227,23 @@ export class Server {
                 createdAt: req.data.timeoutAt,
                 settledAt: req.data.timeoutAt,
                 timeoutAt: req.data.timeoutAt,
-                awaiters: new Set(),
-                subscribers: new Set(),
+                callbacks: new Set(),
+                listeners: new Set(),
             };
             changes.push(this.setPromise(promise));
-            changes.push(...this.enqueueSettle(req.data.id));
-            changes.push(...this.resumeAwaiters(req.data.id, now));
-            changes.push(...this.notifySubscribers(req.data.id));
+            // Create fulfilled task inline if promise has a target
+            const address = req.data.tags["resonate:target"];
+            if (address) {
+                changes.push(this.setTask({
+                    id: req.data.id,
+                    state: "fulfilled",
+                    version: 0,
+                    pid: undefined,
+                    ttl: undefined,
+                    resumes: new Set(),
+                }));
+            }
+            changes.push(...this.triggerSettlement(req.data.id, now));
             return {
                 response: this.response("promise.create", 200, { promise: this.toPromiseRecord(promise) }),
                 changes,
@@ -235,8 +258,8 @@ export class Server {
             createdAt: now,
             settledAt: null,
             timeoutAt: req.data.timeoutAt,
-            awaiters: new Set(),
-            subscribers: new Set(),
+            callbacks: new Set(),
+            listeners: new Set(),
         };
         changes.push(this.setPromise(promise));
         changes.push(this.setPTimeout({ id: req.data.id, timeout: req.data.timeoutAt }));
@@ -270,26 +293,28 @@ export class Server {
         if (!promise) {
             return { response: this.response("promise.settle", 404, "Promise not found"), changes: [] };
         }
-        if (promise.state !== "pending") {
+        // Idempotent return: if the promise is already physically terminal OR
+        // pending past its deadline (logically settled), return the projected
+        // logical state without writing.
+        const projected = this.projectedPromise(now, promise);
+        if (projected.state !== "pending") {
             return {
-                response: this.response("promise.settle", 200, { promise: this.toPromiseRecord(promise) }),
+                response: this.response("promise.settle", 200, { promise: this.toPromiseRecord(projected) }),
                 changes: [],
             };
         }
         const changes = [];
-        const settled = {
+        const settledPromise = {
             ...promise,
             state: req.data.state,
             value: req.data.value,
             settledAt: now,
         };
-        changes.push(this.setPromise(settled));
+        changes.push(this.setPromise(settledPromise));
         changes.push(this.delPTimeout(req.data.id));
-        changes.push(...this.enqueueSettle(req.data.id));
-        changes.push(...this.resumeAwaiters(req.data.id, now));
-        changes.push(...this.notifySubscribers(req.data.id));
+        changes.push(...this.triggerSettlement(req.data.id, now));
         return {
-            response: this.response("promise.settle", 200, { promise: this.toPromiseRecord(settled) }),
+            response: this.response("promise.settle", 200, { promise: this.toPromiseRecord(settledPromise) }),
             changes,
         };
     }
@@ -307,13 +332,19 @@ export class Server {
             return { response: this.response("promise.register_callback", 422, "Awaiter has no address"), changes: [] };
         }
         const changes = [];
-        // Add to awaiters if awaited is pending and awaiter is not settled
-        if (awaitedPromise.state === "pending" && awaiterPromise.state === "pending") {
-            awaitedPromise.awaiters.add(req.data.awaiter);
+        // Project for the logically-pending check and for the response — the
+        // callback is written only when both sides are logically pending, and
+        // the response always reflects the projected awaited promise.
+        const awaitedProjected = this.projectedPromise(now, awaitedPromise);
+        const awaiterProjected = this.projectedPromise(now, awaiterPromise);
+        if (awaitedProjected.state === "pending" && awaiterProjected.state === "pending") {
+            awaitedPromise.callbacks.add(req.data.awaiter);
             changes.push(this.setPromise(awaitedPromise));
         }
         return {
-            response: this.response("promise.register_callback", 200, { promise: this.toPromiseRecord(awaitedPromise) }),
+            response: this.response("promise.register_callback", 200, {
+                promise: this.toPromiseRecord(awaitedProjected),
+            }),
             changes,
         };
     }
@@ -323,13 +354,18 @@ export class Server {
             return { response: this.response("promise.register_listener", 404, "Promise not found"), changes: [] };
         }
         const changes = [];
-        // Add subscriber if promise is pending
-        if (promise.state === "pending") {
-            promise.subscribers.add(req.data.address);
+        // 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.
+        const projected = this.projectedPromise(now, promise);
+        if (projected.state === "pending") {
+            promise.listeners.add(req.data.address);
             changes.push(this.setPromise(promise));
         }
         return {
-            response: this.response("promise.register_listener", 200, { promise: this.toPromiseRecord(promise) }),
+            response: this.response("promise.register_listener", 200, {
+                promise: this.toPromiseRecord(projected),
+            }),
             changes,
         };
     }
@@ -341,7 +377,12 @@ export class Server {
         if (!task) {
             return { response: this.response("task.get", 404, "Task not found"), changes: [] };
         }
-        return { response: this.response("task.get", 200, { task: this.toTaskRecord(task) }), changes: [] };
+        return {
+            response: this.response("task.get", 200, {
+                task: this.toTaskRecord(this.projectedTask(now, task)),
+            }),
+            changes: [],
+        };
     }
     taskCreate(now, req) {
         const existingTask = this.tasks.get(req.data.action.data.id);
@@ -349,10 +390,12 @@ export class Server {
             const promise = this.getPromiseOrThrow(existingTask.id);
             // Pending → Acquired (acquire and return 200)
             if (existingTask.state === "pending") {
+                const newVersion = existingTask.version + 1;
                 const changes = [];
                 changes.push(this.setTask({
                     ...existingTask,
                     state: "acquired",
+                    version: newVersion,
                     pid: req.data.pid,
                     ttl: req.data.ttl,
                     resumes: new Set(),
@@ -363,6 +406,7 @@ export class Server {
                         task: this.toTaskRecord({
                             ...existingTask,
                             state: "acquired",
+                            version: newVersion,
                             pid: req.data.pid,
                             ttl: req.data.ttl,
                             resumes: new Set(),
@@ -407,8 +451,8 @@ export class Server {
                 createdAt: actionData.timeoutAt,
                 settledAt: actionData.timeoutAt,
                 timeoutAt: actionData.timeoutAt,
-                awaiters: new Set(),
-                subscribers: new Set(),
+                callbacks: new Set(),
+                listeners: new Set(),
             };
             changes.push(this.setPromise(promise));
             const task = {
@@ -439,8 +483,8 @@ export class Server {
             createdAt: now,
             settledAt: null,
             timeoutAt: actionData.timeoutAt,
-            awaiters: new Set(),
-            subscribers: new Set(),
+            callbacks: new Set(),
+            listeners: new Set(),
         };
         changes.push(this.setPromise(promise));
         changes.push(this.setPTimeout({ id: actionData.id, timeout: actionData.timeoutAt }));
@@ -448,7 +492,7 @@ export class Server {
         const task = {
             id: actionData.id,
             state: "acquired",
-            version: 0,
+            version: 1,
             pid: req.data.pid,
             ttl: req.data.ttl,
             resumes: new Set(),
@@ -473,18 +517,34 @@ export class Server {
         if (task.state !== "pending") {
             return { response: this.response("task.acquire", 409, "Task not in pending state"), changes: [] };
         }
+        // Logical-state check: if the task's promise is logically settled,
+        // the task is logically fulfilled and cannot be acquired. This catches
+        // the projection-mode case where the physical task state has not yet
+        // converged.
+        const promise = this.getPromiseOrThrow(req.data.id);
+        if (this.projectedPromise(now, promise).state !== "pending") {
+            return { response: this.response("task.acquire", 409, "Task logically fulfilled"), changes: [] };
+        }
         if (task.version !== req.data.version) {
             return { response: this.response("task.acquire", 409, "Version mismatch"), changes: [] };
         }
+        const newVersion = task.version + 1;
         const changes = [];
-        const promise = this.getPromiseOrThrow(req.data.id);
-        changes.push(this.setTask({ ...task, state: "acquired", pid: req.data.pid, ttl: req.data.ttl, resumes: new Set() }));
+        changes.push(this.setTask({
+            ...task,
+            state: "acquired",
+            version: newVersion,
+            pid: req.data.pid,
+            ttl: req.data.ttl,
+            resumes: new Set(),
+        }));
         changes.push(this.setTTimeout({ id: req.data.id, type: 1, timeout: now + req.data.ttl }));
         return {
             response: this.response("task.acquire", 200, {
                 task: this.toTaskRecord({
                     ...task,
                     state: "acquired",
+                    version: newVersion,
                     pid: req.data.pid,
                     ttl: req.data.ttl,
                     resumes: new Set(),
@@ -503,19 +563,24 @@ export class Server {
         if (task.state !== "acquired") {
             return { response: this.response("task.release", 409, "Task not acquired"), changes: [] };
         }
+        // Logical-state check: if the task's promise is logically settled,
+        // the task is logically fulfilled and cannot be released.
+        const taskPromise = this.getPromiseOrThrow(req.data.id);
+        if (this.projectedPromise(now, taskPromise).state !== "pending") {
+            return { response: this.response("task.release", 409, "Task not acquired"), changes: [] };
+        }
         if (task.version !== req.data.version) {
             return { response: this.response("task.release", 409, "Version mismatch"), changes: [] };
         }
         const changes = [];
-        const newVersion = task.version + 1;
-        changes.push(this.setTask({ ...task, state: "pending", version: newVersion, pid: undefined, ttl: undefined }));
+        changes.push(this.setTask({ ...task, state: "pending", pid: undefined, ttl: undefined }));
         changes.push(this.setTTimeout({ id: req.data.id, type: 0, timeout: now + PENDING_RETRY_TTL }));
         const promise = this.getPromiseOrThrow(req.data.id);
         const address = this.getAddressOrThrow(promise);
         changes.push(this.sendMessage(address, {
             kind: "execute",
             head: {},
-            data: { task: { id: req.data.id, version: newVersion } },
+            data: { task: { id: req.data.id, version: task.version } },
         }));
         return { response: this.response("task.release", 200, {}), changes };
     }
@@ -527,31 +592,34 @@ export class Server {
         if (task.state !== "acquired") {
             return { response: this.response("task.fulfill", 409, "Task not acquired"), changes: [] };
         }
+        // Logical-state check: if the task's promise is logically settled, the
+        // task is logically fulfilled and cannot be fulfilled again.
+        const taskPromise = this.getPromiseOrThrow(req.data.id);
+        if (this.projectedPromise(now, taskPromise).state !== "pending") {
+            return { response: this.response("task.fulfill", 409, "Task not acquired"), changes: [] };
+        }
         if (task.version !== req.data.version) {
             return { response: this.response("task.fulfill", 409, "Version mismatch"), changes: [] };
         }
-        const settle = req.data.action.data;
-        const promise = this.getPromiseOrThrow(settle.id);
+        const promise = this.getPromiseOrThrow(req.data.action.data.id);
         const changes = [];
         // Check if promise is already settled (possibly by auto-timeout above)
         if (promise.state !== "pending") {
             // Still fulfill the task but indicate the promise was already settled
-            changes.push(...this.enqueueSettle(req.data.id));
+            changes.push(...this.triggerFulfilled(req.data.id));
             return { response: this.response("task.fulfill", 200, { promise: this.toPromiseRecord(promise) }), changes };
         }
         // Settle the promise
-        const settled = {
+        const settledPromise = {
             ...promise,
-            state: settle.state,
-            value: settle.value ?? {},
+            state: req.data.action.data.state,
+            value: req.data.action.data.value ?? {},
             settledAt: now,
         };
-        changes.push(this.setPromise(settled));
-        changes.push(this.delPTimeout(settle.id));
-        changes.push(...this.enqueueSettle(req.data.id));
-        changes.push(...this.resumeAwaiters(settle.id, now));
-        changes.push(...this.notifySubscribers(settle.id));
-        return { response: this.response("task.fulfill", 200, { promise: this.toPromiseRecord(settled) }), changes };
+        changes.push(this.setPromise(settledPromise));
+        changes.push(this.delPTimeout(req.data.action.data.id));
+        changes.push(...this.triggerSettlement(req.data.id, now));
+        return { response: this.response("task.fulfill", 200, { promise: this.toPromiseRecord(settledPromise) }), changes };
     }
     taskSuspend(now, req) {
         const task = this.tasks.get(req.data.id);
@@ -561,36 +629,43 @@ export class Server {
         if (task.state !== "acquired") {
             return { response: this.response("task.suspend", 409, "Task not acquired"), changes: [] };
         }
+        // Logical-state check: if the task's promise is logically settled, the
+        // task is logically fulfilled and cannot be suspended.
+        const taskPromise = this.getPromiseOrThrow(req.data.id);
+        if (this.projectedPromise(now, taskPromise).state !== "pending") {
+            return { response: this.response("task.suspend", 409, "Task not acquired"), changes: [] };
+        }
         if (task.version !== req.data.version) {
             return { response: this.response("task.suspend", 409, "Version mismatch"), changes: [] };
         }
         const changes = [];
-        // Immediate resume — stay acquired, clear all resumes
-        if (task.resumes.size > 0) {
-            changes.push(this.setTask({ ...task, resumes: new Set() }));
-            return { response: this.response("task.suspend", 300, { preload: this.preload(req.data.id) }), changes };
-        }
-        // Register this task as an awaiter on each awaited promise.
-        // The awaiter is always req.data.id (validated above).
-        const triggers = [];
+        // First pass: validate all promises exist and classify as pending or settled.
+        // Callbacks are only registered when ALL promises are pending (spec transition #40).
+        // If any promise is already settled, return 300 immediately with no callbacks (spec transition #39).
+        const pendingPromises = [];
+        let hasSettled = false;
         for (const action of req.data.actions) {
             const awaitedPromise = this.promises.get(action.data.awaited);
             if (!awaitedPromise) {
                 return { response: this.response("task.suspend", 422, {}), changes: [] };
             }
             if (awaitedPromise.state === "pending") {
-                awaitedPromise.awaiters.add(req.data.id);
-                changes.push(this.setPromise(awaitedPromise));
+                pendingPromises.push(awaitedPromise);
             }
             else {
-                // Already settled → immediate trigger
-                triggers.push(action.data.awaited);
+                hasSettled = true;
             }
         }
-        if (triggers.length > 0) {
+        // Immediate resume — stay acquired, clear all resumes, no callbacks registered
+        if (hasSettled) {
+            changes.push(this.setTask({ ...task, resumes: new Set() }));
             return { response: this.response("task.suspend", 300, { preload: this.preload(req.data.id) }), changes };
         }
-        // Actually suspend
+        // All pending: register callbacks then suspend
+        for (const awaitedPromise of pendingPromises) {
+            awaitedPromise.callbacks.add(req.data.id);
+            changes.push(this.setPromise(awaitedPromise));
+        }
         changes.push(this.setTask({ ...task, state: "suspended", pid: undefined, ttl: undefined, resumes: new Set() }));
         changes.push(this.delTTimeout(req.data.id));
         return { response: this.response("task.suspend", 200, {}), changes };
@@ -619,15 +694,14 @@ export class Server {
             return { response: this.response("task.continue", 409, "Task is not halted"), changes: [] };
         }
         const changes = [];
-        const newVersion = task.version + 1;
-        changes.push(this.setTask({ ...task, state: "pending", version: newVersion }));
+        changes.push(this.setTask({ ...task, state: "pending" }));
         changes.push(this.setTTimeout({ id: req.data.id, type: 0, timeout: now + PENDING_RETRY_TTL }));
         const promise = this.getPromiseOrThrow(req.data.id);
         const address = this.getAddressOrThrow(promise);
         changes.push(this.sendMessage(address, {
             kind: "execute",
             head: {},
-            data: { task: { id: req.data.id, version: newVersion } },
+            data: { task: { id: req.data.id, version: task.version } },
         }));
         return { response: this.response("task.continue", 200, {}), changes };
     }
@@ -639,6 +713,12 @@ export class Server {
         if (task.state !== "acquired") {
             return { response: this.response("task.fence", 409, "Fence check failed"), changes: [] };
         }
+        // Logical-state check: if the task's promise is logically settled,
+        // the task is logically fulfilled and the fence fails.
+        const taskPromise = this.getPromiseOrThrow(req.data.id);
+        if (this.projectedPromise(now, taskPromise).state !== "pending") {
+            return { response: this.response("task.fence", 409, "Fence check failed"), changes: [] };
+        }
         if (task.version !== req.data.version) {
             return { response: this.response("task.fence", 409, "Fence check failed"), changes: [] };
         }
@@ -650,8 +730,12 @@ export class Server {
         else {
             inner = this.promiseSettle(now, action);
         }
+        const actionResponse = {
+            ...inner.response,
+            head: { corrId: action.head.corrId, status: inner.response.head.status, version: action.head.version },
+        };
         return {
-            response: this.response("task.fence", 200, { action: inner.response, preload: [] }),
+            response: this.response("task.fence", 200, { action: actionResponse, preload: [] }),
             changes: inner.changes,
         };
     }
@@ -662,6 +746,12 @@ export class Server {
             if (!task || task.state !== "acquired" || task.version !== ref.version || task.pid !== req.data.pid) {
                 continue;
             }
+            // Logical-state check: if the task's promise is logically settled,
+            // the task is logically fulfilled and its lease cannot be refreshed.
+            const promise = this.getPromiseOrThrow(ref.id);
+            if (this.projectedPromise(now, promise).state !== "pending") {
+                continue;
+            }
             const ttl = task.ttl ?? 30000;
             changes.push(this.setTTimeout({ id: ref.id, type: 1, timeout: now + ttl }));
         }
@@ -678,10 +768,10 @@ export class Server {
         return { response: this.response("schedule.get", 200, { schedule: this.toScheduleRecord(schedule) }), changes: [] };
     }
     scheduleCreate(now, req) {
-        const existing = this.schedules.get(req.data.id);
-        if (existing) {
+        const existingSchedule = this.schedules.get(req.data.id);
+        if (existingSchedule) {
             return {
-                response: this.response("schedule.create", 200, { schedule: this.toScheduleRecord(existing) }),
+                response: this.response("schedule.create", 200, { schedule: this.toScheduleRecord(existingSchedule) }),
                 changes: [],
             };
         }
@@ -738,8 +828,8 @@ export class Server {
             response: this.response("debug.snap", 200, {
                 promises: Array.from(this.promises.values()).map((p) => this.toPromiseRecord(p)),
                 promiseTimeouts: this.pTimeouts,
-                callbacks: Array.from(this.promises.values()).flatMap((p) => [...p.awaiters].map((awaiter) => ({ awaiter, awaited: p.id }))),
-                listeners: Array.from(this.promises.values()).flatMap((p) => [...p.subscribers].map((address) => ({ id: p.id, address }))),
+                callbacks: Array.from(this.promises.values()).flatMap((p) => [...p.callbacks].map((awaiter) => ({ awaiter, awaited: p.id }))),
+                listeners: Array.from(this.promises.values()).flatMap((p) => [...p.listeners].map((address) => ({ id: p.id, address }))),
                 tasks: Array.from(this.tasks.values()).map((t) => this.toTaskRecord(t)),
                 taskTimeouts: this.tTimeouts,
                 messages: this.outgoing,
@@ -792,11 +882,11 @@ export class Server {
         // order promises appear in pTimeouts.
         //
         //   Phase 1: Settle all expired promises (state change only).
-        //   Phase 2: Fulfill tasks whose own promise settled (enqueueSettle).
-        //   Phase 3: Resume suspended awaiters of settled promises (resumeAwaiters).
+        //   Phase 2: Fulfill tasks whose own promise settled (triggerFulfilled).
+        //   Phase 3: Resume suspended callbacks of settled promises (triggerCallbacks).
         //
         // Phase 2 before phase 3 ensures that a task whose own promise settled
-        // is fulfilled before resumeAwaiters runs. This prevents a spurious
+        // is fulfilled before triggerCallbacks runs. This prevents a spurious
         // suspended → pending (version++) → fulfilled path for tasks that
         // should go directly suspended → fulfilled.
         const settledIds = [];
@@ -818,26 +908,25 @@ export class Server {
         }
         // Phase 2: Fulfill tasks whose own promise settled
         for (const id of settledIds) {
-            changes.push(...this.enqueueSettle(id));
+            changes.push(...this.triggerFulfilled(id));
         }
-        // Phase 3: Resume suspended awaiters and notify subscribers
+        // Phase 3: Resume suspended callbacks and notify listeners
         for (const id of settledIds) {
-            changes.push(...this.resumeAwaiters(id, now));
-            changes.push(...this.notifySubscribers(id));
+            changes.push(...this.triggerCallbacks(id, now));
+            changes.push(...this.triggerListeners(id));
         }
         for (const action of actions) {
             if (action.kind === "task.release") {
                 const task = this.getTaskOrThrow(action.data.id);
                 if (task.state === "acquired" && task.version === action.data.version) {
-                    const newVersion = task.version + 1;
-                    changes.push(this.setTask({ ...task, state: "pending", version: newVersion, pid: undefined, ttl: undefined }));
+                    changes.push(this.setTask({ ...task, state: "pending", pid: undefined, ttl: undefined }));
                     changes.push(this.setTTimeout({ id: action.data.id, type: 0, timeout: now + PENDING_RETRY_TTL }));
                     const promise = this.getPromiseOrThrow(action.data.id);
                     const address = this.getAddressOrThrow(promise);
                     changes.push(this.sendMessage(address, {
                         kind: "execute",
                         head: {},
-                        data: { task: { id: action.data.id, version: newVersion } },
+                        data: { task: { id: action.data.id, version: task.version } },
                     }));
                 }
             }
@@ -865,12 +954,12 @@ export class Server {
                 .replaceAll("{{.timestamp}}", String(st.timeout));
             const { changes: createChanges } = this.promiseCreate(now, {
                 kind: "promise.create",
-                head: { corrId: randomUUID(), version: VERSION },
+                head: { corrId: "", version: "" },
                 data: {
                     id: promiseId,
                     timeoutAt: st.timeout + schedule.promiseTimeout,
                     param: schedule.promiseParam,
-                    tags: schedule.promiseTags,
+                    tags: { ...schedule.promiseTags, "resonate:schedule": schedule.id },
                 },
             });
             changes.push(...createChanges);
@@ -892,7 +981,7 @@ export class Server {
     // CONVERTERS
     // ===========================================================================
     toPromiseRecord(p) {
-        const { awaiters, subscribers, settledAt, ...rest } = p;
+        const { callbacks, listeners, settledAt, ...rest } = p;
         return settledAt != null ? { ...rest, settledAt } : rest;
     }
     toTaskRecord(t) {
@@ -923,7 +1012,9 @@ export class Server {
     // ===========================================================================
     // HELPERS
     // ===========================================================================
-    tryAutoTimeout(now, id) {
+    tryEagerTimeout(now, id) {
+        if (this.timeoutMode !== "eager")
+            return [];
         const promise = this.promises.get(id);
         if (!promise || promise.state !== "pending" || now < promise.timeoutAt) {
             return [];
@@ -932,50 +1023,37 @@ export class Server {
         const state = this.timeoutState(promise.tags);
         changes.push(this.setPromise({ ...promise, state, settledAt: promise.timeoutAt }));
         changes.push(this.delPTimeout(id));
-        changes.push(...this.enqueueSettle(id));
-        changes.push(...this.resumeAwaiters(id, now));
-        changes.push(...this.notifySubscribers(id));
+        changes.push(...this.triggerSettlement(id, now));
         return changes;
     }
-    enqueueSettle(promiseId) {
+    triggerSettlement(id, now) {
+        return [...this.triggerFulfilled(id), ...this.triggerCallbacks(id, now), ...this.triggerListeners(id)];
+    }
+    triggerFulfilled(promiseId) {
         const task = this.tasks.get(promiseId);
-        if (!task) {
-            const promise = this.promises.get(promiseId);
-            if (!promise?.tags["resonate:target"])
-                return [];
-            return [
-                this.setTask({
-                    id: promiseId,
-                    state: "fulfilled",
-                    version: 0,
-                    pid: undefined,
-                    ttl: undefined,
-                    resumes: new Set(),
-                }),
-            ];
-        }
+        if (!task)
+            return [];
         if (task.state === "fulfilled")
             return [];
         const changes = [];
         changes.push(this.setTask({ ...task, state: "fulfilled", pid: undefined, ttl: undefined, resumes: new Set() }));
         changes.push(this.delTTimeout(promiseId));
-        // Remove this task from all promise awaiters (delete callbacks where awaiter_id = task_id)
+        // Remove this task from all promise callbacks (delete callbacks where awaiter_id = task_id)
         for (const [, promise] of this.promises) {
-            if (promise.awaiters.delete(promiseId)) {
+            if (promise.callbacks.delete(promiseId)) {
                 changes.push(this.setPromise(promise));
             }
         }
         return changes;
     }
-    resumeAwaiters(promiseId, now) {
+    triggerCallbacks(promiseId, now) {
         const settledPromise = this.getPromiseOrThrow(promiseId);
         const changes = [];
         // Resume or buffer for all tasks that were awaiting this promise
-        for (const awaiterId of settledPromise.awaiters) {
+        for (const awaiterId of settledPromise.callbacks) {
             const task = this.getTaskOrThrow(awaiterId);
             if (task.state === "suspended") {
-                const newVersion = task.version + 1;
-                changes.push(this.setTask({ ...task, state: "pending", version: newVersion, resumes: new Set([promiseId]) }));
+                changes.push(this.setTask({ ...task, state: "pending", resumes: new Set([promiseId]) }));
                 // Add task timeout entry back (type=0 for pending retry)
                 changes.push(this.setTTimeout({
                     id: awaiterId,
@@ -987,7 +1065,7 @@ export class Server {
                 changes.push(this.sendMessage(address, {
                     kind: "execute",
                     head: {},
-                    data: { task: { id: awaiterId, version: newVersion } },
+                    data: { task: { id: awaiterId, version: task.version } },
                 }));
             }
             else if (task.state === "pending" || task.state === "acquired" || task.state === "halted") {
@@ -996,24 +1074,24 @@ export class Server {
                 changes.push(this.setTask(task));
             }
         }
-        // Clear awaiters after processing
-        settledPromise.awaiters.clear();
+        // Clear callbacks after processing
+        settledPromise.callbacks.clear();
         changes.push(this.setPromise(settledPromise));
         return changes;
     }
-    notifySubscribers(promiseId) {
+    triggerListeners(promiseId) {
         const promise = this.getPromiseOrThrow(promiseId);
-        if (promise.subscribers.size === 0)
+        if (promise.listeners.size === 0)
             return [];
         const changes = [];
-        for (const address of promise.subscribers) {
+        for (const address of promise.listeners) {
             changes.push(this.sendMessage(address, {
                 kind: "unblock",
                 head: {},
                 data: { promise: this.toPromiseRecord(promise) },
             }));
         }
-        promise.subscribers.clear();
+        promise.listeners.clear();
         changes.push(this.setPromise(promise));
         return changes;
     }
@@ -1035,6 +1113,42 @@ export class Server {
     timeoutState(tags) {
         return tags["resonate:timer"] === "true" ? "resolved" : "rejected_timedout";
     }
+    // Projection: return the LOGICAL view of a promise without mutating
+    // storage. When physical state is `pending` and `now >= timeoutAt`, the
+    // logical state is the terminal state implied by the timer tag. Used at
+    // response-construction sites in read paths so callers always observe
+    // logical state regardless of whether convergence has happened yet.
+    //
+    // Unguarded by timeoutMode: when timeoutMode === "eager", the physical
+    // state already matches the logical state by the time this runs (because
+    // tryEagerTimeout fired at the start of the action), so the projection
+    // condition is never met and this is a no-op.
+    projectedPromise(now, promise) {
+        if (promise.state !== "pending" || now < promise.timeoutAt) {
+            return promise;
+        }
+        return {
+            ...promise,
+            state: this.timeoutState(promise.tags),
+            settledAt: promise.timeoutAt,
+        };
+    }
+    // Projection: return the LOGICAL view of a task without mutating storage.
+    // A task's logical state is bound to its promise's logical state — when
+    // the promise is logically settled, the task is logically fulfilled.
+    //
+    // Unguarded for the same reason as projectedPromise.
+    projectedTask(now, task) {
+        const promise = this.promises.get(task.id);
+        if (!promise)
+            return task;
+        const projected = this.projectedPromise(now, promise);
+        if (projected.state === "pending")
+            return task;
+        if (task.state === "fulfilled")
+            return task;
+        return { ...task, state: "fulfilled", pid: undefined, ttl: undefined };
+    }
     getPromiseOrThrow(id) {
         const promise = this.promises.get(id);
         if (!promise) {
@@ -1180,6 +1294,9 @@ export class LocalNetwork {
         this.anycast = `local://any@${group}/${pid}`;
     }
     // -- Network ---------------------------------------------------------------
+    match(target) {
+        return `local://any@${target}`;
+    }
     async init() {
         if (this.started)
             return;