@justscale/core 0.1.0

package/dist/cluster/coordinator/cluster-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-signals.d.ts","sourceRoot":"","sources":["../../../src/cluster/coordinator/cluster-signals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;;IAKxE,oCAAoC;;gBAGxB,MAAM;iBAAW,MAAM;sBAAgB,MAAM,EAAE;mBAAa,MAAM;;IAG9E,8CAA8C;;gBAGlC,MAAM;;IAGlB,sDAAsD;;gBAG1C,MAAM;oBAAc,MAAM;;IAGtC,oDAAoD;;mBAGrC,MAAM;oBAAc,MAAM;cAAQ,MAAM;;IAGvD,6CAA6C;;gBAGjC,MAAM;;IAGlB,mEAAmE;;gBAGvD,MAAM;cAAQ,MAAM;YAAM,MAAM;gBAAU,MAAM;;;;;AApChE,qBAAa,cAAe,SAAQ,mBAuClC;CAAG"}

package/dist/cluster/coordinator/cluster-signals.js

@@ -0,0 +1,24 @@
+/**
+ * Signals emitted by NodeLifecycleService and consumed by the cluster coordinator process.
+ */
+import { defineService } from '../../core/index.js';
+import { AbstractProcessExecutor } from '../../runtime/process/executor.js';
+export class ClusterSignals extends defineService({
+    inject: { executor: AbstractProcessExecutor },
+    factory: ({ executor }) => ({
+        /** A new node joined the cluster */
+        nodeJoin: executor.createSignal('cluster.node.join'),
+        /** A node is leaving gracefully (draining) */
+        nodeLeave: executor.createSignal('cluster.node.leave'),
+        /** A node was detected as dead (missed heartbeats) */
+        nodeDeath: executor.createSignal('cluster.node.death'),
+        /** A new process was created and needs placement */
+        processCreated: executor.createSignal('cluster.process.created'),
+        /** Request to rebalance work across nodes */
+        rebalanceRequested: executor.createSignal('cluster.rebalance'),
+        /** Coordinator acknowledged a node state change (observability) */
+        nodeStateChanged: executor.createSignal('cluster.node.state_changed'),
+    }),
+}) {
+}
+//# sourceMappingURL=cluster-signals.js.map

package/dist/cluster/coordinator/cluster-signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-signals.js","sourceRoot":"","sources":["../../../src/cluster/coordinator/cluster-signals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAE5E,MAAM,OAAO,cAAe,SAAQ,aAAa,CAAC;IAChD,MAAM,EAAE,EAAE,QAAQ,EAAE,uBAAuB,EAAE;IAC7C,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;QAC1B,oCAAoC;QACpC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAG7B,mBAAmB,CAAC;QAEtB,8CAA8C;QAC9C,SAAS,EAAE,QAAQ,CAAC,YAAY,CAG9B,oBAAoB,CAAC;QAEvB,sDAAsD;QACtD,SAAS,EAAE,QAAQ,CAAC,YAAY,CAG9B,oBAAoB,CAAC;QAEvB,oDAAoD;QACpD,cAAc,EAAE,QAAQ,CAAC,YAAY,CAGnC,yBAAyB,CAAC;QAE5B,6CAA6C;QAC7C,kBAAkB,EAAE,QAAQ,CAAC,YAAY,CAGvC,mBAAmB,CAAC;QAEtB,mEAAmE;QACnE,gBAAgB,EAAE,QAAQ,CAAC,YAAY,CAGrC,4BAA4B,CAAC;KAChC,CAAC;CACH,CAAC;CAAG"}

package/dist/cluster/coordinator/coordinator.process.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Durable cluster coordinator process.
+ *
+ * Maintains a live node registry (`using exports`) readable via handle.data.
+ * The DB is the source of truth for crash recovery - the registry is hydrated
+ * on startup. Runs on exactly one node via the process runtime's advisory lock.
+ */
+export declare const COORDINATOR_PATH = "/cluster/coordinator";
+export interface NodeInfo {
+    address: string;
+    capabilities: string[];
+    status: string;
+}
+export declare const clusterCoordinator: import("../../process/types.js").ProcessDefinition<"/cluster/coordinator", readonly [], never, {
+    nodeCount: number;
+    registry: Map<string, NodeInfo>;
+    getNode(id: string): NodeInfo | undefined;
+    getNodesByCapability(cap: string): Array<NodeInfo>;
+    [Symbol.dispose](): void;
+}>;
+//# sourceMappingURL=coordinator.process.d.ts.map

package/dist/cluster/coordinator/coordinator.process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.process.d.ts","sourceRoot":"","sources":["../../../src/cluster/coordinator/coordinator.process.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,eAAO,MAAM,gBAAgB,yBAAyB,CAAC;AAEvD,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;CACf;AAID,eAAO,MAAM,kBAAkB;eA6HmB,MAAM;cAAY,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC;gBAAc,MAAM,GAAG,QAAQ,GAAG,SAAS;8BAA4B,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC;wBAAsB,IAAI;EAAK,CAAC"}

package/dist/cluster/coordinator/coordinator.process.js

@@ -0,0 +1,221 @@
+import { __createProcess } from "@justscale/core/process";
+/**
+ * Durable cluster coordinator process.
+ *
+ * Maintains a live node registry (`using exports`) readable via handle.data.
+ * The DB is the source of truth for crash recovery - the registry is hydrated
+ * on startup. Runs on exactly one node via the process runtime's advisory lock.
+ */
+import { createProcess, race, signal, delay } from '../../process/index.js';
+import { ClusterSignals } from './cluster-signals.js';
+import { ModelRepository } from '../../models/index.js';
+import { ClusterNode } from './cluster-node.model.js';
+export const COORDINATOR_PATH = '/cluster/coordinator';
+const RECONCILIATION_INTERVAL_SECONDS = 30;
+export const clusterCoordinator = __createProcess({
+    id: "cluster_coordinator",
+    path: "/cluster/coordinator",
+    version: "v_e97ef760",
+    inject: {
+        signals: ClusterSignals,
+        nodes: ModelRepository.of(ClusterNode),
+    },
+    stepMap: {
+        "entry_4311c3e9": 0,
+        "block_37d08b11": 1,
+        "branch_d7b816bd": 2,
+        "branch_dec66f24": 3,
+        "branch_c70fdf2f": 4,
+        "branch_1ae40275": 5,
+        "branch_1a727714": 6,
+        "branch_08cf0637": 7,
+        "block_f70ad7eb": 8,
+        "block_df3497ba": 9
+    },
+    sourceMap: {
+        0: [37, 49],
+        1: [62, 147],
+        2: [66, 66],
+        3: [98, 98],
+        4: [115, 115],
+        5: [130, 130],
+        6: [134, 134],
+        7: [143, 143],
+        8: [62, 147],
+        9: [62, 147]
+    },
+    signals: {
+        "signals.nodeJoin": { identity: [], payloadType: "Signal<[], { nodeId: string; address: string; capabilities: string[]; timestamp: number; }, string>" },
+        "signals.nodeDeath": { identity: [], payloadType: "Signal<[], { nodeId: string; lastSeenMs: number; }, string>" },
+        "signals.nodeLeave": { identity: [], payloadType: "Signal<[], { nodeId: string; }, string>" },
+        "signals.processCreated": { identity: [], payloadType: "Signal<[], { processId: string; instanceId: string; path: string; }, string>" },
+        "signals.rebalanceRequested": { identity: [], payloadType: "Signal<[], { reason: string; }, string>" }
+    },
+    execute: async (ctx) => {
+        const { state, services } = ctx;
+        let existing, dead, leaving;
+        let step = state.step | 0;
+        const __r = [0, undefined];
+        let __blockResult;
+        let __raceResult;
+        const __dispose = [undefined, undefined, undefined];
+        let __dispose_i = 0;
+        main_loop: while (true) {
+            switch (step) {
+                case 0: {
+                    // [Symbol.dispose] is a no-op required by the ES2023 Explicit Resource
+                    // Management spec so plain tsc accepts the `using` declaration. ptsc
+                    // rewrites `using exports = ...` into durable-process state wiring and
+                    // ignores this field at runtime.
+                    state.vars.exports = {
+                        nodeCount: 0,
+                        registry: new Map(),
+                        getNode(id) {
+                            return this.registry.get(id);
+                        },
+                        getNodesByCapability(cap) {
+                            return [...this.registry.values()].filter(n => n.capabilities.includes(cap));
+                        },
+                        [Symbol.dispose]() { },
+                    };
+                    for (const node of await services.nodes.find({})) {
+                        if (node.status === "active") {
+                            state.vars.exports.registry.set(node.nodeId, {
+                                address: node.address,
+                                capabilities: node.capabilities,
+                                status: node.status,
+                            });
+                        }
+                    }
+                    state.vars.exports.nodeCount = state.vars.exports.registry.size;
+                    step = 1;
+                    continue main_loop;
+                }
+                case 1: {
+                    const r = race();
+                    state.vars.__raceBranches = [
+                        { id: "signals.nodeJoin", signal: services.signals.nodeJoin.signalName, resumeStep: 2 },
+                        { id: "signals.nodeDeath", signal: services.signals.nodeDeath.signalName, resumeStep: 3 },
+                        { id: "signals.nodeLeave", signal: services.signals.nodeLeave.signalName, resumeStep: 4 },
+                        { id: "signals.processCreated", signal: services.signals.processCreated.signalName, resumeStep: 5 },
+                        { id: "signals.rebalanceRequested", signal: services.signals.rebalanceRequested.signalName, resumeStep: 6 },
+                        { id: "__timer__", timer: { seconds: RECONCILIATION_INTERVAL_SECONDS }, resumeStep: 7 }
+                    ];
+                    __r[0] = 1;
+                    __r[1] = { race: state.vars.__raceBranches };
+                    break main_loop;
+                }
+                case 2: {
+                    __raceResult = state.vars.__raceResult;
+                    existing = await services.nodes.lock(services.nodes.findOne(ClusterNode.fields.nodeId.eq(nodeId)));
+                    __dispose[__dispose_i++] = existing;
+                    if (existing) {
+                        await services.nodes.update(existing, {
+                            status: "active",
+                            lastSeen: new Date(timestamp),
+                            address,
+                            capabilities,
+                        });
+                        await services.signals.nodeStateChanged({
+                            nodeId, from: existing.status, to: "active", reason: "rejoin",
+                        });
+                    }
+                    else {
+                        await services.nodes.insert({
+                            nodeId,
+                            address,
+                            status: "active",
+                            lastSeen: new Date(timestamp),
+                            capabilities,
+                        });
+                        await services.signals.nodeStateChanged({
+                            nodeId, from: "none", to: "active", reason: "join",
+                        });
+                    }
+                    state.vars.exports.registry.set(nodeId, { address, capabilities, status: "active" });
+                    state.vars.exports.nodeCount = state.vars.exports.registry.size;
+                    step = 8;
+                    continue main_loop;
+                }
+                case 3: {
+                    __raceResult = state.vars.__raceResult;
+                    dead = await services.nodes.lock(services.nodes.findOne(ClusterNode.fields.nodeId.eq(nodeId)));
+                    __dispose[__dispose_i++] = dead;
+                    if (dead && dead.status !== "dead") {
+                        const previousStatus = dead.status;
+                        await services.nodes.update(dead, { status: "dead" });
+                        await services.signals.nodeStateChanged({
+                            nodeId, from: previousStatus, to: "dead",
+                            reason: `heartbeat timeout (last seen: ${new Date(lastSeenMs).toISOString()})`,
+                        });
+                    }
+                    state.vars.exports.registry.delete(nodeId);
+                    state.vars.exports.nodeCount = state.vars.exports.registry.size;
+                    step = 8;
+                    continue main_loop;
+                }
+                case 4: {
+                    __raceResult = state.vars.__raceResult;
+                    leaving = await services.nodes.lock(services.nodes.findOne(ClusterNode.fields.nodeId.eq(nodeId)));
+                    __dispose[__dispose_i++] = leaving;
+                    if (leaving && leaving.status !== "dead") {
+                        await services.nodes.update(leaving, { status: "draining" });
+                        await services.signals.nodeStateChanged({
+                            nodeId, from: leaving.status, to: "draining", reason: "graceful leave",
+                        });
+                    }
+                    state.vars.exports.registry.delete(nodeId);
+                    state.vars.exports.nodeCount = state.vars.exports.registry.size;
+                    step = 8;
+                    continue main_loop;
+                }
+                case 5: {
+                    __raceResult = state.vars.__raceResult;
+                    step = 8;
+                    continue main_loop;
+                }
+                case 6: {
+                    __raceResult = state.vars.__raceResult;
+                    await services.signals.nodeStateChanged({
+                        nodeId: "coordinator", from: "active", to: "active",
+                        reason: `rebalance requested: ${reason}`,
+                    });
+                    step = 8;
+                    continue main_loop;
+                }
+                case 7: {
+                    __raceResult = state.vars.__raceResult;
+                    step = 8;
+                    continue main_loop;
+                }
+                case 8: {
+                    step = 1;
+                    continue main_loop;
+                }
+                case 9: {
+                }
+                default: throw new Error(`Invalid step: ${step}`);
+            }
+        }
+        while (__dispose_i > 0) {
+            __dispose?.[--__dispose_i]?.[Symbol.dispose]?.();
+        }
+        if (__r[0] !== 0) {
+            state.step = step;
+        }
+        return __r;
+    },
+    exports: {
+        fields: ["nodeCount", "registry"],
+        methods: {
+            "getNode": function (id) {
+                return this.registry.get(id);
+            },
+            "getNodesByCapability": function (cap) {
+                return [...this.registry.values()].filter(n => n.capabilities.includes(cap));
+            }
+        }
+    },
+    __exportsType: void 0
+});
+//# sourceMappingURL=coordinator.process.js.map

package/dist/cluster/coordinator/coordinator.process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.process.js","sourceRoot":"","sources":["../../../src/cluster/coordinator/coordinator.process.ts"],"names":[],"mappings":"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"}

package/dist/cluster/coordinator/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cluster Coordinator
+ *
+ * Three-layer architecture for cluster coordination:
+ * - Layer 0: Postgres (advisory locks, LISTEN/NOTIFY, SKIP LOCKED)
+ * - Layer 1: NodeLifecycleService (heartbeat, stale detection, signals)
+ * - Layer 2: clusterCoordinator process (placement, drain, rebalance)
+ */
+export { ClusterNode, ClusterNodeStatus } from './cluster-node.model.js';
+export { ClusterSignals } from './cluster-signals.js';
+export { clusterCoordinator, COORDINATOR_PATH } from './coordinator.process.js';
+export { NodeLifecycleService, type NodeLifecycleOptions, } from './node-lifecycle.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cluster/coordinator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cluster/coordinator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EACL,oBAAoB,EACpB,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC"}

package/dist/cluster/coordinator/index.js

@@ -0,0 +1,13 @@
+/**
+ * Cluster Coordinator
+ *
+ * Three-layer architecture for cluster coordination:
+ * - Layer 0: Postgres (advisory locks, LISTEN/NOTIFY, SKIP LOCKED)
+ * - Layer 1: NodeLifecycleService (heartbeat, stale detection, signals)
+ * - Layer 2: clusterCoordinator process (placement, drain, rebalance)
+ */
+export { ClusterNode, ClusterNodeStatus } from './cluster-node.model.js';
+export { ClusterSignals } from './cluster-signals.js';
+export { clusterCoordinator, COORDINATOR_PATH } from './coordinator.process.js';
+export { NodeLifecycleService, } from './node-lifecycle.js';
+//# sourceMappingURL=index.js.map

package/dist/cluster/coordinator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cluster/coordinator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EACL,oBAAoB,GAErB,MAAM,qBAAqB,CAAC"}

package/dist/cluster/coordinator/node-lifecycle.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Service that manages this node's participation in the cluster:
+ * registers on start, sends heartbeats, detects stale nodes, and drains on stop.
+ * The coordinator process is started idempotently - the runtime lock ensures only
+ * one node executes it at a time.
+ */
+import { ClusterNode } from './cluster-node.model.js';
+import { ClusterSignals } from './cluster-signals.js';
+import { Lifecycle } from '../../core/lifecycle.js';
+export interface NodeLifecycleOptions {
+    /** This node's address (host:port for inter-node communication) */
+    address?: string;
+    /** Capabilities this node advertises */
+    capabilities?: string[];
+    /** Heartbeat interval in milliseconds (default: 5000) */
+    heartbeatMs?: number;
+    /** Stale node threshold in milliseconds (default: 15000) */
+    staleThresholdMs?: number;
+}
+declare const NodeLifecycleService_base: import("../../core/service.js").Service<{
+    readonly nodeId: `${string}-${string}-${string}-${string}-${string}`;
+    readonly address: string;
+}, {
+    readonly nodes: import("../../models/model.repository.js").ModelRepositoryToken<ClusterNode, {}>;
+    readonly signals: typeof ClusterSignals;
+    readonly lifecycle: typeof Lifecycle;
+}>;
+export declare class NodeLifecycleService extends NodeLifecycleService_base {
+}
+export {};
+//# sourceMappingURL=node-lifecycle.d.ts.map

package/dist/cluster/coordinator/node-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/cluster/coordinator/node-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AASpD,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;;;;;;;;;AAED,qBAAa,oBAAqB,SAAQ,yBAwFxC;CAAG"}

package/dist/cluster/coordinator/node-lifecycle.js

@@ -0,0 +1,178 @@
+/**
+ * Service that manages this node's participation in the cluster:
+ * registers on start, sends heartbeats, detects stale nodes, and drains on stop.
+ * The coordinator process is started idempotently - the runtime lock ensures only
+ * one node executes it at a time.
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { defineService } from '../../core/index.js';
+import { ModelRepository } from '../../models/index.js';
+import { ClusterNode } from './cluster-node.model.js';
+import { ClusterSignals } from './cluster-signals.js';
+import { clusterCoordinator } from './coordinator.process.js';
+import { Lifecycle } from '../../core/lifecycle.js';
+import { randomUUID } from 'node:crypto';
+/** Default heartbeat interval in milliseconds */
+const DEFAULT_HEARTBEAT_MS = 5_000;
+/** Stale threshold: nodes not seen for this long are considered dead */
+const DEFAULT_STALE_THRESHOLD_MS = 15_000;
+export class NodeLifecycleService extends defineService({
+    inject: {
+        nodes: ModelRepository.of(ClusterNode),
+        signals: ClusterSignals,
+        lifecycle: Lifecycle,
+    },
+    factory: ({ nodes, signals, lifecycle }, _resolve, options) => {
+        const nodeId = randomUUID();
+        const address = options?.address ?? `local:${process.pid}`;
+        const capabilities = options?.capabilities ?? [];
+        const heartbeatMs = options?.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+        const staleThresholdMs = options?.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+        let heartbeatTimer = null;
+        const start = async () => {
+            await clusterCoordinator([]);
+            await nodes.insert({
+                nodeId,
+                address,
+                status: 'active',
+                lastSeen: new Date(),
+                capabilities,
+            });
+            await signals.nodeJoin({ nodeId, address, capabilities, timestamp: Date.now() });
+            heartbeatTimer = setInterval(async () => {
+                try {
+                    const env_1 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const self = __addDisposableResource(env_1, await nodes.lock(nodes.findOne(ClusterNode.fields.nodeId.eq(nodeId))), false);
+                        if (self) {
+                            await nodes.update(self, { lastSeen: new Date() });
+                        }
+                        const staleThreshold = new Date(Date.now() - staleThresholdMs);
+                        const staleNodes = await nodes.find({
+                            where: ClusterNode.fields.lastSeen.lt(staleThreshold),
+                        });
+                        for (const stale of staleNodes) {
+                            if (stale.status === 'active') {
+                                await signals.nodeDeath({
+                                    nodeId: stale.nodeId,
+                                    lastSeenMs: stale.lastSeen.getTime(),
+                                });
+                            }
+                        }
+                        const cleanupThreshold = new Date(Date.now() - staleThresholdMs * 2);
+                        const cleanupNodes = await nodes.find({
+                            where: ClusterNode.fields.lastSeen.lt(cleanupThreshold),
+                        });
+                        for (const node of cleanupNodes) {
+                            if (node.status === 'dead' || node.status === 'draining') {
+                                const env_2 = { stack: [], error: void 0, hasError: false };
+                                try {
+                                    const locked = __addDisposableResource(env_2, await nodes.lock(node), false);
+                                    if (locked)
+                                        await nodes.delete(locked);
+                                }
+                                catch (e_1) {
+                                    env_2.error = e_1;
+                                    env_2.hasError = true;
+                                }
+                                finally {
+                                    __disposeResources(env_2);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_2) {
+                        env_1.error = e_2;
+                        env_1.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_1);
+                    }
+                }
+                catch {
+                    // swallow heartbeat errors - next interval will retry
+                }
+            }, heartbeatMs);
+        };
+        const stop = async () => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+                await signals.nodeLeave({ nodeId });
+                const self = __addDisposableResource(env_3, await nodes.lock(nodes.findOne(ClusterNode.fields.nodeId.eq(nodeId))), false);
+                if (self) {
+                    await nodes.update(self, { status: 'draining' });
+                }
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        };
+        lifecycle.register('stop', stop);
+        start().catch(() => { });
+        return {
+            get nodeId() { return nodeId; },
+            get address() { return address; },
+        };
+    },
+}) {
+}
+//# sourceMappingURL=node-lifecycle.js.map

package/dist/cluster/coordinator/node-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-lifecycle.js","sourceRoot":"","sources":["../../../src/cluster/coordinator/node-lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/cluster/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @justscale/cluster
+ *
+ * Cluster capabilities for JustScale applications.
+ *
+ * The main entry point is now JustScale() from '@justscale/core':
+ *
+ * @example Creating an app
+ * ```typescript
+ * import JustScale from '@justscale/core'
+ * import '@justscale/http'
+ *
+ * const app = JustScale()
+ *   .add(UserService)
+ *   .add(UserController)
+ *   .build()
+ *
+ * await app.serve({ http: 3000 })
+ * ```
+ *
+ * @example Using the CLI client directly
+ * ```typescript
+ * import { connectToCluster } from "@justscale/cluster"
+ *
+ * const client = await connectToCluster()
+ * const result = await client.invoke("auth create-user", {
+ *   email: "test@example.com",
+ *   password: "secret",
+ * })
+ * ```
+ *
+ * @module @justscale/cluster
+ */
+export { PROTOCOL_VERSION, PROTOCOL_V1_CBOR, PROTOCOL_V2_PROTO, WIRE_FORMAT_CBOR, WIRE_FORMAT_PROTO, type WireFormat, type ProtoCodec, setProtoCodec, getProtoCodec, encodeFrameV2, type MessageType, type AuthLevel, type AuthInfo, type AuthNone, type AuthSocket, type AuthSharedSecret, type AuthPubkey, type Message, type RequestMessage, type ResponseMessage, type SuccessResponse, type ErrorResponse, type StreamMessage, type EventMessage, type PromptType, type PromptRequest, type PromptResponseData, ErrorCodes, type ErrorCode, Methods, encodeFrame, FrameDecoder, createRequest, createResponse, createErrorResponse, createStream, createEvent, isRequest, isResponse, isSuccessResponse, isErrorResponse, isStream, isEvent, } from './protocol.js';
+export { type Transport, type TransportEvents, SocketTransport, type SocketTransportOptions, getSocketDir, getSocketPath, cleanupSocket, getPeerCredentials, } from './transport.js';
+export { ClusterServer, createClusterServer, type ServerOptions, type ServerEvents, type MethodHandler, type HandlerContext, type PromptOptions, } from './server.js';
+export { ClusterClient, createClusterClient, connectToCluster, type ClientOptions, type ClientEvents, type CallOptions, type PromptHandler, } from './client.js';
+export { ClusterNode, ClusterNodeStatus, ClusterSignals, clusterCoordinator, COORDINATOR_PATH, NodeLifecycleService, type NodeLifecycleOptions, } from './coordinator/index.js';
+export { type Cluster, type TransportPlugin, type ServeOptions, registerTransport, getRegisteredTransports, } from './cluster.js';
+export { default as JustScale } from '../justscale.js';
+export type { BuiltApp } from '../justscale.js';
+export { bindRepository, bindService, bindInstance, } from '../index.js';
+export type { Token, AnyToken, Component, Builder, RepositoryBinding, ServiceBinding, InstanceBinding, FeatureToken, FeatureMetadata, BuilderCallback, StartHook, StopHook, ProvidesOf, RequiresOf, } from '../index.js';
+export { isServiceDef, isControllerDef, isRepositoryBinding, isServiceBinding, isInstanceBinding, isFeatureToken, isBuilderCallback, isComponentArray, FEATURE_TOKEN, FEATURE_META, REPO_BINDING, SERVICE_BINDING, INSTANCE_BINDING, } from '../index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cluster/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cluster/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,aAAa,EACb,aAAa,EACb,aAAa,EACb,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,UAAU,EACV,KAAK,SAAS,EACd,OAAO,EACP,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,WAAW,EACX,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,eAAe,EACf,QAAQ,EACR,OAAO,GACR,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,eAAe,EACf,KAAK,sBAAsB,EAC3B,YAAY,EACZ,aAAa,EACb,aAAa,EACb,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AAMrB,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,oBAAoB,GAC1B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AAOtB,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EACL,cAAc,EACd,WAAW,EACX,YAAY,GACb,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,KAAK,EACL,QAAQ,EACR,SAAS,EACT,OAAO,EACP,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,eAAe,EACf,eAAe,EACf,SAAS,EACT,QAAQ,EACR,UAAU,EACV,UAAU,GACX,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,aAAa,CAAC"}