@resonatehq/sdk 0.9.5 → 0.10.0

package/dist/network/local.js

@@ -0,0 +1,1232 @@
+import { randomUUID } from "node:crypto";
+import { CronExpressionParser } from "cron-parser";
+import { assert, VERSION } from "../util.js";
+import { isResponse } from "./types.js";
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+const PENDING_RETRY_TTL = 30000;
+// =============================================================================
+// SERVER
+// =============================================================================
+export class Server {
+    promises = new Map();
+    tasks = new Map();
+    schedules = new Map();
+    pTimeouts = [];
+    tTimeouts = [];
+    sTimeouts = [];
+    outgoing = [];
+    apply(now, req) {
+        const changes = [];
+        const error = this.validate(req);
+        if (error !== null) {
+            return { response: { kind: req.kind, head: { status: 400 }, data: error }, changes };
+        }
+        let result;
+        switch (req.kind) {
+            case "promise.get": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.promiseGet(now, req);
+                break;
+            }
+            case "promise.create": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.promiseCreate(now, req);
+                break;
+            }
+            case "promise.settle": {
+                changes.push(...this.tryAutoTimeout(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));
+                result = this.promiseRegisterCallback(now, req);
+                break;
+            }
+            case "promise.register_listener": {
+                changes.push(...this.tryAutoTimeout(now, req.data.awaited));
+                result = this.promiseRegisterListener(now, req);
+                break;
+            }
+            case "promise.search": {
+                result = { response: this.response("promise.search", 501, "Not implemented"), changes: [] };
+                break;
+            }
+            case "task.get": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.taskGet(now, req);
+                break;
+            }
+            case "task.create": {
+                changes.push(...this.tryAutoTimeout(now, req.data.action.data.id));
+                result = this.taskCreate(now, req);
+                break;
+            }
+            case "task.acquire": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.taskAcquire(now, req);
+                break;
+            }
+            case "task.release": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.taskRelease(now, req);
+                break;
+            }
+            case "task.fulfill": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.taskFulfill(now, req);
+                break;
+            }
+            case "task.suspend": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                for (const action of req.data.actions) {
+                    changes.push(...this.tryAutoTimeout(now, action.data.awaited));
+                }
+                result = this.taskSuspend(now, req);
+                break;
+            }
+            case "task.halt": {
+                changes.push(...this.tryAutoTimeout(now, req.data.id));
+                result = this.taskHalt(now, req);
+                break;
+            }
+            case "task.continue": {
+                changes.push(...this.tryAutoTimeout(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));
+                result = this.taskFence(now, req);
+                break;
+            }
+            case "task.heartbeat": {
+                result = this.taskHeartbeat(now, req);
+                break;
+            }
+            case "task.search": {
+                result = { response: this.response("task.search", 501, "Not implemented"), changes: [] };
+                break;
+            }
+            case "debug.start": {
+                result = this.debugStart();
+                break;
+            }
+            case "debug.reset": {
+                result = this.debugReset();
+                break;
+            }
+            case "debug.snap": {
+                result = this.debugSnap();
+                break;
+            }
+            case "debug.tick": {
+                result = this.debugTick(req);
+                break;
+            }
+            case "debug.stop": {
+                result = this.debugStop();
+                break;
+            }
+            case "schedule.get": {
+                result = this.scheduleGet(req);
+                break;
+            }
+            case "schedule.create": {
+                result = this.scheduleCreate(now, req);
+                break;
+            }
+            case "schedule.delete": {
+                result = this.scheduleDelete(req);
+                break;
+            }
+            case "schedule.search": {
+                result = { response: this.response("schedule.search", 501, "Not implemented"), changes: [] };
+                break;
+            }
+        }
+        changes.push(...result.changes);
+        return { response: result.response, changes };
+    }
+    validate(req) {
+        switch (req.kind) {
+            case "promise.register_callback":
+                if (req.data.awaited === req.data.awaiter) {
+                    return "Awaited and awaiter must be different";
+                }
+                return null;
+            case "task.suspend":
+                if (req.data.actions.length === 0) {
+                    return "Actions list must not be empty";
+                }
+                if (req.data.actions.some((a) => a.data.awaiter !== req.data.id)) {
+                    return "Awaiter must be the suspending task";
+                }
+                if (req.data.actions.some((a) => a.data.awaited === req.data.id)) {
+                    return "Task cannot await its own promise";
+                }
+                return null;
+            case "task.create":
+                if (!req.data.action.data.tags?.["resonate:target"]) {
+                    return "Action must have a resonate:target tag";
+                }
+                return null;
+            case "task.fulfill":
+                if (req.data.action.data.id !== req.data.id) {
+                    return "Promise ID must match task ID";
+                }
+                return null;
+            default:
+                return null;
+        }
+    }
+    // ===========================================================================
+    // PROMISE OPERATIONS
+    // ===========================================================================
+    promiseGet(now, req) {
+        const promise = this.promises.get(req.data.id);
+        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: [] };
+    }
+    promiseCreate(now, req) {
+        const existing = this.promises.get(req.data.id);
+        if (existing) {
+            return {
+                response: this.response("promise.create", 200, { promise: this.toPromiseRecord(existing) }),
+                changes: [],
+            };
+        }
+        const changes = [];
+        // Check if the promise is already timed out at creation
+        if (now >= req.data.timeoutAt) {
+            const promise = {
+                id: req.data.id,
+                state: this.timeoutState(req.data.tags),
+                param: req.data.param ?? { data: undefined, headers: undefined },
+                value: {},
+                tags: req.data.tags,
+                createdAt: req.data.timeoutAt,
+                settledAt: req.data.timeoutAt,
+                timeoutAt: req.data.timeoutAt,
+                awaiters: new Set(),
+                subscribers: 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));
+            return {
+                response: this.response("promise.create", 200, { promise: this.toPromiseRecord(promise) }),
+                changes,
+            };
+        }
+        const promise = {
+            id: req.data.id,
+            state: "pending",
+            param: req.data.param ?? { data: undefined, headers: undefined },
+            value: {},
+            tags: req.data.tags,
+            createdAt: now,
+            settledAt: null,
+            timeoutAt: req.data.timeoutAt,
+            awaiters: new Set(),
+            subscribers: 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) {
+            const delay = Number(req.data.tags["resonate:delay"]);
+            const deferred = Number.isFinite(delay) && now < delay;
+            const task = {
+                id: req.data.id,
+                state: "pending",
+                version: 0,
+                resumes: new Set(),
+            };
+            changes.push(this.setTask(task));
+            changes.push(this.setTTimeout({
+                id: req.data.id,
+                type: 0,
+                timeout: deferred ? delay : now + PENDING_RETRY_TTL,
+            }));
+            if (!deferred) {
+                changes.push(this.sendMessage(address, { kind: "execute", head: {}, data: { task: { id: req.data.id, version: 0 } } }));
+            }
+        }
+        return {
+            response: this.response("promise.create", 200, { promise: this.toPromiseRecord(promise) }),
+            changes,
+        };
+    }
+    promiseSettle(now, req) {
+        const promise = this.promises.get(req.data.id);
+        if (!promise) {
+            return { response: this.response("promise.settle", 404, "Promise not found"), changes: [] };
+        }
+        if (promise.state !== "pending") {
+            return {
+                response: this.response("promise.settle", 200, { promise: this.toPromiseRecord(promise) }),
+                changes: [],
+            };
+        }
+        const changes = [];
+        const settled = {
+            ...promise,
+            state: req.data.state,
+            value: req.data.value,
+            settledAt: now,
+        };
+        changes.push(this.setPromise(settled));
+        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));
+        return {
+            response: this.response("promise.settle", 200, { promise: this.toPromiseRecord(settled) }),
+            changes,
+        };
+    }
+    promiseRegisterCallback(now, req) {
+        const awaitedPromise = this.promises.get(req.data.awaited);
+        if (!awaitedPromise) {
+            return { response: this.response("promise.register_callback", 404, "Awaited promise not found"), changes: [] };
+        }
+        const awaiterPromise = this.promises.get(req.data.awaiter);
+        if (!awaiterPromise) {
+            return { response: this.response("promise.register_callback", 422, "Awaiter promise not found"), changes: [] };
+        }
+        // HasAddress check: awaiter must have a resonate:target tag
+        if (!awaiterPromise.tags["resonate:target"]) {
+            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);
+            changes.push(this.setPromise(awaitedPromise));
+        }
+        return {
+            response: this.response("promise.register_callback", 200, { promise: this.toPromiseRecord(awaitedPromise) }),
+            changes,
+        };
+    }
+    promiseRegisterListener(now, req) {
+        const promise = this.promises.get(req.data.awaited);
+        if (!promise) {
+            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);
+            changes.push(this.setPromise(promise));
+        }
+        return {
+            response: this.response("promise.register_listener", 200, { promise: this.toPromiseRecord(promise) }),
+            changes,
+        };
+    }
+    // ===========================================================================
+    // TASK OPERATIONS
+    // ===========================================================================
+    taskGet(now, req) {
+        const task = this.tasks.get(req.data.id);
+        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: [] };
+    }
+    taskCreate(now, req) {
+        const existingTask = this.tasks.get(req.data.action.data.id);
+        if (existingTask) {
+            const promise = this.getPromiseOrThrow(existingTask.id);
+            // Pending → Acquired (acquire and return 200)
+            if (existingTask.state === "pending") {
+                const changes = [];
+                changes.push(this.setTask({
+                    ...existingTask,
+                    state: "acquired",
+                    pid: req.data.pid,
+                    ttl: req.data.ttl,
+                    resumes: new Set(),
+                }));
+                changes.push(this.setTTimeout({ id: existingTask.id, type: 1, timeout: now + req.data.ttl }));
+                return {
+                    response: this.response("task.create", 200, {
+                        task: this.toTaskRecord({
+                            ...existingTask,
+                            state: "acquired",
+                            pid: req.data.pid,
+                            ttl: req.data.ttl,
+                            resumes: new Set(),
+                        }),
+                        promise: this.toPromiseRecord(promise),
+                        preload: this.preload(existingTask.id),
+                    }),
+                    changes,
+                };
+            }
+            // Fulfilled → Fulfilled (idempotent, return 200)
+            if (existingTask.state === "fulfilled") {
+                return {
+                    response: this.response("task.create", 200, {
+                        task: this.toTaskRecord(existingTask),
+                        promise: this.toPromiseRecord(promise),
+                        preload: this.preload(existingTask.id),
+                    }),
+                    changes: [],
+                };
+            }
+            return { response: this.response("task.create", 409, "Task already exists"), changes: [] };
+        }
+        const changes = [];
+        const actionData = req.data.action.data;
+        // Guard: promise already exists
+        const existingPromise = this.promises.get(actionData.id);
+        if (existingPromise) {
+            if (!existingPromise.tags["resonate:target"]) {
+                return { response: this.response("task.create", 422, "Promise has no address"), changes: [] };
+            }
+            return { response: this.response("task.create", 409, "Promise already exists"), changes: [] };
+        }
+        // Guard: promise already timed out
+        if (now >= actionData.timeoutAt) {
+            const promise = {
+                id: actionData.id,
+                state: this.timeoutState(actionData.tags),
+                param: actionData.param,
+                value: {},
+                tags: actionData.tags,
+                createdAt: actionData.timeoutAt,
+                settledAt: actionData.timeoutAt,
+                timeoutAt: actionData.timeoutAt,
+                awaiters: new Set(),
+                subscribers: new Set(),
+            };
+            changes.push(this.setPromise(promise));
+            const task = {
+                id: actionData.id,
+                state: "fulfilled",
+                version: 0,
+                pid: undefined,
+                ttl: undefined,
+                resumes: new Set(),
+            };
+            changes.push(this.setTask(task));
+            return {
+                response: this.response("task.create", 200, {
+                    task: this.toTaskRecord(task),
+                    promise: this.toPromiseRecord(promise),
+                    preload: [],
+                }),
+                changes,
+            };
+        }
+        // Create promise in pending state
+        const promise = {
+            id: actionData.id,
+            state: "pending",
+            param: actionData.param,
+            value: {},
+            tags: actionData.tags,
+            createdAt: now,
+            settledAt: null,
+            timeoutAt: actionData.timeoutAt,
+            awaiters: new Set(),
+            subscribers: new Set(),
+        };
+        changes.push(this.setPromise(promise));
+        changes.push(this.setPTimeout({ id: actionData.id, timeout: actionData.timeoutAt }));
+        // Step 2: Create task in acquired state
+        const task = {
+            id: actionData.id,
+            state: "acquired",
+            version: 0,
+            pid: req.data.pid,
+            ttl: req.data.ttl,
+            resumes: new Set(),
+        };
+        changes.push(this.setTask(task));
+        // Step 3: Set type=1 (lease) timeout
+        changes.push(this.setTTimeout({ id: actionData.id, type: 1, timeout: now + req.data.ttl }));
+        return {
+            response: this.response("task.create", 200, {
+                task: this.toTaskRecord(task),
+                promise: this.toPromiseRecord(promise),
+                preload: this.preload(actionData.id),
+            }),
+            changes,
+        };
+    }
+    taskAcquire(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.acquire", 404, "Task not found"), changes: [] };
+        }
+        if (task.state !== "pending") {
+            return { response: this.response("task.acquire", 409, "Task not in pending state"), changes: [] };
+        }
+        if (task.version !== req.data.version) {
+            return { response: this.response("task.acquire", 409, "Version mismatch"), changes: [] };
+        }
+        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.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",
+                    pid: req.data.pid,
+                    ttl: req.data.ttl,
+                    resumes: new Set(),
+                }),
+                promise: this.toPromiseRecord(promise),
+                preload: this.preload(req.data.id),
+            }),
+            changes,
+        };
+    }
+    taskRelease(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.release", 404, "Task not found"), changes: [] };
+        }
+        if (task.state !== "acquired") {
+            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.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 } },
+        }));
+        return { response: this.response("task.release", 200, {}), changes };
+    }
+    taskFulfill(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.fulfill", 404, "Task not found"), changes: [] };
+        }
+        if (task.state !== "acquired") {
+            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 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));
+            return { response: this.response("task.fulfill", 200, { promise: this.toPromiseRecord(promise) }), changes };
+        }
+        // Settle the promise
+        const settled = {
+            ...promise,
+            state: settle.state,
+            value: settle.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 };
+    }
+    taskSuspend(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.suspend", 404, "Task not found"), changes: [] };
+        }
+        if (task.state !== "acquired") {
+            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 = [];
+        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));
+            }
+            else {
+                // Already settled → immediate trigger
+                triggers.push(action.data.awaited);
+            }
+        }
+        if (triggers.length > 0) {
+            return { response: this.response("task.suspend", 300, { preload: this.preload(req.data.id) }), changes };
+        }
+        // Actually suspend
+        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 };
+    }
+    taskHalt(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.halt", 404, "Task not found"), changes: [] };
+        }
+        if (task.state === "fulfilled") {
+            return { response: this.response("task.halt", 409, "Task is fulfilled"), changes: [] };
+        }
+        const changes = [];
+        if (task.state !== "halted") {
+            changes.push(this.setTask({ ...task, state: "halted", pid: undefined, ttl: undefined }));
+            changes.push(this.delTTimeout(req.data.id));
+        }
+        return { response: this.response("task.halt", 200, {}), changes };
+    }
+    taskContinue(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.continue", 404, "Task not found"), changes: [] };
+        }
+        if (task.state !== "halted") {
+            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.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 } },
+        }));
+        return { response: this.response("task.continue", 200, {}), changes };
+    }
+    taskFence(now, req) {
+        const task = this.tasks.get(req.data.id);
+        if (!task) {
+            return { response: this.response("task.fence", 404, "Task not found"), changes: [] };
+        }
+        if (task.state !== "acquired") {
+            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: [] };
+        }
+        const action = req.data.action;
+        let inner;
+        if (action.kind === "promise.create") {
+            inner = this.promiseCreate(now, action);
+        }
+        else {
+            inner = this.promiseSettle(now, action);
+        }
+        return {
+            response: this.response("task.fence", 200, { action: inner.response, preload: [] }),
+            changes: inner.changes,
+        };
+    }
+    taskHeartbeat(now, req) {
+        const changes = [];
+        for (const ref of req.data.tasks) {
+            const task = this.tasks.get(ref.id);
+            if (!task || task.state !== "acquired" || task.version !== ref.version || task.pid !== req.data.pid) {
+                continue;
+            }
+            const ttl = task.ttl ?? 30000;
+            changes.push(this.setTTimeout({ id: ref.id, type: 1, timeout: now + ttl }));
+        }
+        return { response: this.response("task.heartbeat", 200, {}), changes };
+    }
+    // ===========================================================================
+    // SCHEDULE OPERATIONS
+    // ===========================================================================
+    scheduleGet(req) {
+        const schedule = this.schedules.get(req.data.id);
+        if (!schedule) {
+            return { response: this.response("schedule.get", 404, "Schedule not found"), changes: [] };
+        }
+        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) {
+            return {
+                response: this.response("schedule.create", 200, { schedule: this.toScheduleRecord(existing) }),
+                changes: [],
+            };
+        }
+        let nextRunAt;
+        try {
+            const interval = CronExpressionParser.parse(req.data.cron, { currentDate: new Date(now) });
+            nextRunAt = interval.next().getTime();
+        }
+        catch {
+            return { response: this.response("schedule.create", 400, "Invalid cron expression"), changes: [] };
+        }
+        const changes = [];
+        const schedule = {
+            id: req.data.id,
+            cron: req.data.cron,
+            promiseId: req.data.promiseId,
+            promiseTimeout: req.data.promiseTimeout,
+            promiseParam: req.data.promiseParam,
+            promiseTags: req.data.promiseTags,
+            createdAt: now,
+        };
+        changes.push(this.setSTimeout({ id: schedule.id, timeout: nextRunAt }));
+        changes.push(this.setSchedule(schedule));
+        return { response: this.response("schedule.create", 200, { schedule: this.toScheduleRecord(schedule) }), changes };
+    }
+    scheduleDelete(req) {
+        const schedule = this.schedules.get(req.data.id);
+        if (!schedule) {
+            return { response: this.response("schedule.delete", 404, "Schedule not found"), changes: [] };
+        }
+        const changes = [];
+        changes.push(this.delSTimeout(req.data.id));
+        changes.push(this.delSchedule(req.data.id));
+        return { response: this.response("schedule.delete", 200, {}), changes };
+    }
+    // ===========================================================================
+    // DEBUG OPERATIONS
+    // ===========================================================================
+    debugStart() {
+        return { response: this.response("debug.start", 200, {}), changes: [] };
+    }
+    debugReset() {
+        this.promises.clear();
+        this.tasks.clear();
+        this.schedules.clear();
+        this.outgoing = [];
+        this.pTimeouts = [];
+        this.tTimeouts = [];
+        this.sTimeouts = [];
+        return { response: this.response("debug.reset", 200, {}), changes: [] };
+    }
+    debugSnap() {
+        return {
+            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 }))),
+                tasks: Array.from(this.tasks.values()).map((t) => this.toTaskRecord(t)),
+                taskTimeouts: this.tTimeouts,
+                messages: this.outgoing,
+            }),
+            changes: [],
+        };
+    }
+    debugTick(req) {
+        const now = req.data.time;
+        const changes = [];
+        const actions = [];
+        // Promise timeouts -> settle as rejected_timedout (or resolved for timer promises)
+        for (const pt of this.pTimeouts) {
+            if (now >= pt.timeout) {
+                const promise = this.getPromiseOrThrow(pt.id);
+                if (promise.state === "pending") {
+                    const state = this.timeoutState(promise.tags);
+                    actions.push({
+                        kind: "promise.settle",
+                        data: { id: pt.id, state },
+                    });
+                }
+            }
+        }
+        // Task timeouts -> release (lease) or retry (pending)
+        for (const tt of this.tTimeouts) {
+            if (now < tt.timeout)
+                continue;
+            if (tt.type === 1) {
+                const task = this.getTaskOrThrow(tt.id);
+                if (task.state === "acquired") {
+                    actions.push({
+                        kind: "task.release",
+                        data: { id: tt.id, version: task.version },
+                    });
+                }
+            }
+            else if (tt.type === 0) {
+                const task = this.getTaskOrThrow(tt.id);
+                if (task.state === "pending") {
+                    actions.push({
+                        kind: "task.retry",
+                        data: { id: tt.id, version: task.version },
+                    });
+                }
+            }
+        }
+        // Apply actions to own state. Promise settlements are split into three
+        // phases to make the tick atomic — the result must not depend on the
+        // 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 before phase 3 ensures that a task whose own promise settled
+        // is fulfilled before resumeAwaiters runs. This prevents a spurious
+        // suspended → pending (version++) → fulfilled path for tasks that
+        // should go directly suspended → fulfilled.
+        const settledIds = [];
+        // Phase 1: Settle promises
+        for (const action of actions) {
+            if (action.kind === "promise.settle") {
+                const promise = this.getPromiseOrThrow(action.data.id);
+                if (promise.state !== "pending")
+                    continue;
+                changes.push(this.setPromise({
+                    ...promise,
+                    state: action.data.state,
+                    value: {},
+                    settledAt: promise.timeoutAt,
+                }));
+                changes.push(this.delPTimeout(action.data.id));
+                settledIds.push(action.data.id);
+            }
+        }
+        // Phase 2: Fulfill tasks whose own promise settled
+        for (const id of settledIds) {
+            changes.push(...this.enqueueSettle(id));
+        }
+        // Phase 3: Resume suspended awaiters and notify subscribers
+        for (const id of settledIds) {
+            changes.push(...this.resumeAwaiters(id, now));
+            changes.push(...this.notifySubscribers(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.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 } },
+                    }));
+                }
+            }
+            else if (action.kind === "task.retry") {
+                const task = this.getTaskOrThrow(action.data.id);
+                if (task.state === "pending") {
+                    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: task.version } },
+                    }));
+                }
+            }
+        }
+        // Schedule timeouts -> create promises for due schedules
+        for (const st of this.sTimeouts) {
+            if (now < st.timeout)
+                continue;
+            const schedule = this.getScheduleOrThrow(st.id);
+            const promiseId = schedule.promiseId
+                .replaceAll("{{.id}}", schedule.id)
+                .replaceAll("{{.timestamp}}", String(st.timeout));
+            const { changes: createChanges } = this.promiseCreate(now, {
+                kind: "promise.create",
+                head: { corrId: randomUUID(), version: VERSION },
+                data: {
+                    id: promiseId,
+                    timeoutAt: st.timeout + schedule.promiseTimeout,
+                    param: schedule.promiseParam,
+                    tags: schedule.promiseTags,
+                },
+            });
+            changes.push(...createChanges);
+            // Advance to next run
+            const interval = CronExpressionParser.parse(schedule.cron, {
+                currentDate: new Date(st.timeout),
+            });
+            const nextRunAt = interval.next().getTime();
+            schedule.lastRunAt = st.timeout;
+            changes.push(this.setSTimeout({ id: schedule.id, timeout: nextRunAt }));
+            changes.push(this.setSchedule(schedule));
+        }
+        return { response: this.response("debug.tick", 200, []), changes };
+    }
+    debugStop() {
+        return { response: this.response("debug.stop", 200, {}), changes: [] };
+    }
+    // ===========================================================================
+    // CONVERTERS
+    // ===========================================================================
+    toPromiseRecord(p) {
+        const { awaiters, subscribers, settledAt, ...rest } = p;
+        return settledAt != null ? { ...rest, settledAt } : rest;
+    }
+    toTaskRecord(t) {
+        const record = { id: t.id, version: t.version, state: t.state, resumes: Array.from(t.resumes) };
+        if (t.pid !== undefined)
+            record.pid = t.pid;
+        if (t.ttl !== undefined)
+            record.ttl = t.ttl;
+        return record;
+    }
+    toScheduleRecord(s) {
+        const st = this.sTimeouts.find((e) => e.id === s.id);
+        const record = {
+            id: s.id,
+            cron: s.cron,
+            promiseId: s.promiseId,
+            promiseTimeout: s.promiseTimeout,
+            promiseParam: s.promiseParam,
+            promiseTags: s.promiseTags,
+            createdAt: s.createdAt,
+            nextRunAt: st.timeout,
+        };
+        if (s.lastRunAt != null) {
+            record.lastRunAt = s.lastRunAt;
+        }
+        return record;
+    }
+    // ===========================================================================
+    // HELPERS
+    // ===========================================================================
+    tryAutoTimeout(now, id) {
+        const promise = this.promises.get(id);
+        if (!promise || promise.state !== "pending" || now < promise.timeoutAt) {
+            return [];
+        }
+        const changes = [];
+        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));
+        return changes;
+    }
+    enqueueSettle(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.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)
+        for (const [, promise] of this.promises) {
+            if (promise.awaiters.delete(promiseId)) {
+                changes.push(this.setPromise(promise));
+            }
+        }
+        return changes;
+    }
+    resumeAwaiters(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) {
+            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]) }));
+                // Add task timeout entry back (type=0 for pending retry)
+                changes.push(this.setTTimeout({
+                    id: awaiterId,
+                    type: 0,
+                    timeout: now + PENDING_RETRY_TTL,
+                }));
+                const awaiterPromise = this.getPromiseOrThrow(awaiterId);
+                const address = this.getAddressOrThrow(awaiterPromise);
+                changes.push(this.sendMessage(address, {
+                    kind: "execute",
+                    head: {},
+                    data: { task: { id: awaiterId, version: newVersion } },
+                }));
+            }
+            else if (task.state === "pending" || task.state === "acquired" || task.state === "halted") {
+                // Buffer the resume — will be checked when task suspends or continues
+                task.resumes.add(promiseId);
+                changes.push(this.setTask(task));
+            }
+        }
+        // Clear awaiters after processing
+        settledPromise.awaiters.clear();
+        changes.push(this.setPromise(settledPromise));
+        return changes;
+    }
+    notifySubscribers(promiseId) {
+        const promise = this.getPromiseOrThrow(promiseId);
+        if (promise.subscribers.size === 0)
+            return [];
+        const changes = [];
+        for (const address of promise.subscribers) {
+            changes.push(this.sendMessage(address, {
+                kind: "unblock",
+                head: {},
+                data: { promise: this.toPromiseRecord(promise) },
+            }));
+        }
+        promise.subscribers.clear();
+        changes.push(this.setPromise(promise));
+        return changes;
+    }
+    preload(promiseId) {
+        const promise = this.promises.get(promiseId);
+        if (!promise)
+            return [];
+        const branch = promise.tags["resonate:branch"];
+        if (!branch)
+            return [];
+        const results = [];
+        for (const [, p] of this.promises) {
+            if (p.id !== promiseId && p.tags["resonate:branch"] === branch) {
+                results.push(this.toPromiseRecord(p));
+            }
+        }
+        return results;
+    }
+    timeoutState(tags) {
+        return tags["resonate:timer"] === "true" ? "resolved" : "rejected_timedout";
+    }
+    getPromiseOrThrow(id) {
+        const promise = this.promises.get(id);
+        if (!promise) {
+            throw new Error(`Invariant violation: promise ${id} not found`);
+        }
+        return promise;
+    }
+    getAddressOrThrow(promise) {
+        const address = promise.tags["resonate:target"];
+        if (!address) {
+            throw new Error(`Invariant violation: promise ${promise.id} has no resonate:target tag`);
+        }
+        return address;
+    }
+    getTaskOrThrow(id) {
+        const task = this.tasks.get(id);
+        if (!task) {
+            throw new Error(`Invariant violation: task ${id} not found`);
+        }
+        return task;
+    }
+    getScheduleOrThrow(id) {
+        const schedule = this.schedules.get(id);
+        if (!schedule) {
+            throw new Error(`Invariant violation: schedule ${id} not found`);
+        }
+        return schedule;
+    }
+    // ===========================================================================
+    // ACCESSORS (change-tracking)
+    // ===========================================================================
+    setPromise(p) {
+        this.promises.set(p.id, p);
+        return { kind: "promise.set", promise: this.toPromiseRecord(p) };
+    }
+    setTask(t) {
+        this.tasks.set(t.id, t);
+        return { kind: "task.set", task: this.toTaskRecord(t) };
+    }
+    setSchedule(s) {
+        this.schedules.set(s.id, s);
+        return { kind: "schedule.set", schedule: this.toScheduleRecord(s) };
+    }
+    delSchedule(id) {
+        this.schedules.delete(id);
+        return { kind: "schedule.del", id };
+    }
+    setPTimeout(pt) {
+        const idx = this.pTimeouts.findIndex((e) => e.id === pt.id);
+        if (idx !== -1) {
+            this.pTimeouts[idx] = pt;
+        }
+        else {
+            this.pTimeouts.push(pt);
+        }
+        return { kind: "ptimeout.set", timeout: { id: pt.id, timeout: pt.timeout } };
+    }
+    delPTimeout(id) {
+        const idx = this.pTimeouts.findIndex((e) => e.id === id);
+        if (idx !== -1) {
+            this.pTimeouts.splice(idx, 1);
+        }
+        return { kind: "ptimeout.del", id };
+    }
+    setTTimeout(tt) {
+        const idx = this.tTimeouts.findIndex((e) => e.id === tt.id);
+        if (idx !== -1) {
+            this.tTimeouts[idx] = tt;
+        }
+        else {
+            this.tTimeouts.push(tt);
+        }
+        return { kind: "ttimeout.set", timeout: { id: tt.id, type: tt.type, timeout: tt.timeout } };
+    }
+    delTTimeout(id) {
+        const idx = this.tTimeouts.findIndex((e) => e.id === id);
+        if (idx !== -1) {
+            this.tTimeouts.splice(idx, 1);
+        }
+        return { kind: "ttimeout.del", id };
+    }
+    setSTimeout(st) {
+        const idx = this.sTimeouts.findIndex((e) => e.id === st.id);
+        if (idx !== -1) {
+            this.sTimeouts[idx] = st;
+        }
+        else {
+            this.sTimeouts.push(st);
+        }
+        return { kind: "stimeout.set", timeout: { id: st.id, timeout: st.timeout } };
+    }
+    delSTimeout(id) {
+        const idx = this.sTimeouts.findIndex((e) => e.id === id);
+        if (idx !== -1) {
+            this.sTimeouts.splice(idx, 1);
+        }
+        return { kind: "stimeout.del", id };
+    }
+    // FIX: Change from accumulate (push) to upsert by task ID.
+    // A task can only be claimed by one worker at one version, so when a task
+    // is resumed (version incremented), the previous message is obsolete.
+    // Upsert keeps only the latest message per task ID, matching the HTTP's
+    // outgoing table behavior (ON CONFLICT (id) DO UPDATE).
+    sendMessage(address, msg) {
+        if (msg.kind === "execute") {
+            const taskId = msg.data.task.id;
+            const idx = this.outgoing.findIndex((m) => m.message.kind === "execute" && m.message.data.task.id === taskId);
+            if (idx >= 0) {
+                this.outgoing[idx] = { address, message: msg };
+            }
+            else {
+                this.outgoing.push({ address, message: msg });
+            }
+        }
+        else {
+            this.outgoing.push({ address, message: msg });
+        }
+        return { kind: "message.send", address, message: msg };
+    }
+    // OLD: accumulate (push) — causes divergence with HTTP snapshots
+    // private sendMessage(address: string, msg: Message): Change {
+    //   this.outgoing.push({ address, message: msg });
+    //   return { kind: "message.send", address, message: msg };
+    // }
+    response(kind, status, data) {
+        return { kind, head: { status }, data };
+    }
+}
+// =============================================================================
+// LOCAL NETWORK
+// =============================================================================
+export class LocalNetwork {
+    unicast;
+    anycast;
+    started;
+    server;
+    subscribers = [];
+    tickInterval;
+    constructor({ pid = crypto.randomUUID().replace(/-/g, ""), group = "default", } = {}) {
+        this.started = false;
+        this.server = new Server();
+        this.unicast = `local://uni@${group}/${pid}`;
+        this.anycast = `local://any@${group}/${pid}`;
+    }
+    // -- Network ---------------------------------------------------------------
+    async init() {
+        if (this.started)
+            return;
+        this.tickInterval = setInterval(() => {
+            const now = Date.now();
+            const result = this.server.apply(now, {
+                kind: "debug.tick",
+                head: { corrId: randomUUID(), version: VERSION },
+                data: { time: now },
+            });
+            this.dispatchMessages(result);
+        }, 1000);
+        this.started = true;
+    }
+    async stop() {
+        if (this.tickInterval) {
+            clearInterval(this.tickInterval);
+        }
+        this.subscribers = [];
+        this.started = false;
+    }
+    send = (req) => {
+        const { corrId, version } = req.head;
+        const now = Date.now();
+        const result = this.server.apply(now, req);
+        const response = result.response;
+        const res = {
+            kind: response.kind,
+            head: { corrId, status: response.head.status, version },
+            data: response.data,
+        };
+        assert(isResponse(res));
+        setTimeout(() => this.dispatchMessages(result), 0);
+        return Promise.resolve(res);
+    };
+    recv(callback) {
+        this.subscribers.push(callback);
+    }
+    // -- internal: message dispatch --------------------------------------------
+    dispatchMessages(result) {
+        for (const change of result.changes) {
+            if (change.kind !== "message.send")
+                continue;
+            for (const cb of this.subscribers) {
+                cb(change.message);
+            }
+        }
+    }
+}
+//# sourceMappingURL=local.js.map