@voltro/runtime 0.85.0 → 0.87.0

package/dist/singleNodeOrchestrator.js

@@ -0,0 +1,91 @@
+import { pruneWakeups as e } from "./wakeRegistry.js";
+import { wakeDueOnce as t } from "./wakeOrchestrator.js";
+import { makeProcessAdapter as n } from "./wakeSupervisor.js";
+import { isIdleNow as r, makeIdleGate as i } from "./idleDetector.js";
+import { makeRouterActivity as a, makeWakeProxyServer as o } from "./wakeRouter.js";
+//#region src/singleNodeOrchestrator.ts
+var s = async (e) => {
+	try {
+		return (await e.query({
+			table: "_voltro_workflow_runs",
+			predicate: {
+				column: "status",
+				op: "eq",
+				value: "running"
+			},
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: ["id"]
+		})).length;
+	} catch {
+		return 0;
+	}
+}, c = async (e) => {
+	let i = n(e.supervisor), a = await t({
+		store: e.store,
+		adapter: i,
+		...e.now === void 0 ? {} : { now: e.now },
+		...e.log === void 0 ? {} : { log: e.log }
+	});
+	a > 0 && e.idleGate.reset();
+	let o = await r({
+		store: e.store,
+		signals: e.signals,
+		...e.wakeLookaheadMs === void 0 ? {} : { wakeLookaheadMs: e.wakeLookaheadMs },
+		...e.now === void 0 ? {} : { now: e.now }
+	}), s = !1;
+	return e.idleGate.update(o) && e.supervisor.isRunning() && (e.log?.info("orchestrator: idle grace elapsed — scaling app to zero"), await e.supervisor.stop(), e.idleGate.reset(), s = !0), {
+		woke: a,
+		stopped: s
+	};
+}, l = async (t) => {
+	let n = i(t.idleGraceMs ?? 6e4), r = t.tickMs ?? 1e3, l = a(), u = 0, d = t.signals === void 0, f = t.signals ?? {
+		connectedClients: () => l.openConnections(),
+		inFlightRequests: () => l.inFlightRequests(),
+		activeWorkflowExecutions: () => u
+	}, p = o({
+		supervisor: t.supervisor,
+		targetHost: t.targetHost,
+		targetPort: t.targetPort,
+		onActivity: () => {
+			n.reset();
+		},
+		activity: l,
+		...t.log === void 0 ? {} : { log: t.log }
+	}), m = await new Promise((e, n) => {
+		p.once("error", n), p.listen(t.publicPort, t.publicHost ?? "0.0.0.0", () => {
+			let n = p.address();
+			e(typeof n == "object" && n ? n.port : t.publicPort);
+		});
+	});
+	t.log?.info("orchestrator: router listening", { port: m });
+	let h = !1, g, _ = t.firedRetentionMs ?? 6e5, v = 0, y = async () => {
+		if (!h) {
+			try {
+				if (d && (u = await s(t.store)), await c({
+					store: t.store,
+					supervisor: t.supervisor,
+					signals: f,
+					idleGate: n,
+					...t.wakeLookaheadMs === void 0 ? {} : { wakeLookaheadMs: t.wakeLookaheadMs },
+					...t.log === void 0 ? {} : { log: t.log }
+				}), v++ % 60 == 0) {
+					let n = await e(t.store, { firedOlderThan: new Date(Date.now() - _) });
+					n > 0 && t.log?.info("orchestrator: pruned fired wakeups", { count: n });
+				}
+			} catch (e) {
+				t.log?.warn("orchestrator: tick failed", { reason: e instanceof Error ? e.message : String(e) });
+			}
+			h || (g = setTimeout(() => void y(), r));
+		}
+	};
+	return y(), {
+		port: m,
+		stop: async () => {
+			h = !0, g !== void 0 && clearTimeout(g), await new Promise((e) => p.close(() => e()));
+		}
+	};
+};
+//#endregion
+export { s as countRunningWorkflows, c as runOrchestratorTick, l as runSingleNodeOrchestrator };

package/dist/snapshotValueCodec.js

@@ -0,0 +1,46 @@
+//#region src/snapshotValueCodec.ts
+var e = "\0", t = `${e}d`, n = `${e}n`, r = `${e}b`, i = `${e}o`, a = 1, o = (e) => {
+	if (typeof e != "object" || !e) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
+}, s = (a) => {
+	if (typeof a != "object" || !a) return typeof a == "bigint" ? { [n]: a.toString() } : a;
+	if (a instanceof Date) return { [t]: Number.isNaN(a.getTime()) ? null : a.toISOString() };
+	if (a instanceof Uint8Array) return { [r]: Buffer.from(a.buffer, a.byteOffset, a.byteLength).toString("base64") };
+	if (Array.isArray(a)) return a.map(s);
+	if (o(a)) {
+		let t = {}, n = !1;
+		for (let [r, i] of Object.entries(a)) r.startsWith(e) && (n = !0), t[r] = s(i);
+		return n ? { [i]: t } : t;
+	}
+	throw TypeError("A snapshot value carries a non-plain object; it cannot be cached faithfully.");
+}, c = (e) => {
+	if (typeof e != "object" || !e) return e;
+	if (Array.isArray(e)) return e.map(c);
+	let a = e, o = Object.keys(a);
+	if (o.length === 1) {
+		let e = o[0], s = a[e];
+		if (e === t) return s === null ? /* @__PURE__ */ new Date(NaN) : new Date(s);
+		if (e === n) return BigInt(s);
+		if (e === r) return new Uint8Array(Buffer.from(s, "base64"));
+		if (e === i) {
+			let e = {};
+			for (let [t, n] of Object.entries(s)) e[t] = c(n);
+			return e;
+		}
+	}
+	let s = {};
+	for (let [e, t] of Object.entries(a)) s[e] = c(t);
+	return s;
+}, l = (e) => ({
+	v: a,
+	value: s(e)
+}), u = (e) => {
+	if (o(e) && e.v === a && "value" in e) try {
+		return { value: c(e.value) };
+	} catch {
+		return;
+	}
+};
+//#endregion
+export { u as decodeSnapshotValue, l as encodeSnapshotValue };

package/dist/sourceResolution.js

@@ -0,0 +1,52 @@
+import { captureOptionalQuerySources as e, declaredReactivityChannelKeys as t, isReactivityChannelKey as n, sourceKeys as r } from "@voltro/protocol";
+//#region src/sourceResolution.ts
+var i = (e, t) => {
+	let n, r = 0;
+	for (let i of t) {
+		let t = 0;
+		for (; t < e.length && t < i.length && e[t] === i[t];) t++;
+		let a = 0;
+		for (; a < e.length - t && a < i.length - t && e[e.length - 1 - a] === i[i.length - 1 - a];) a++;
+		let o = (t + a) / Math.max(e.length, i.length);
+		o > r && o >= .6 && (r = o, n = i);
+	}
+	return n;
+}, a = (a, o) => {
+	let s = t(), c = [], l = /* @__PURE__ */ new Map();
+	for (let t of a) {
+		let a = new Set(e(t.name, t.source, t.optionalSource));
+		for (let e of r(t.source)) if (n(e)) {
+			if (s.has(e)) continue;
+			c.push({
+				procedure: t.name,
+				source: e,
+				didYouMean: void 0,
+				channel: !0,
+				...a.has(e) ? { optional: !0 } : {}
+			});
+		} else o.size === 0 || o.has(e) || (l.has(e) || l.set(e, i(e, o)), c.push({
+			procedure: t.name,
+			source: e,
+			didYouMean: a.has(e) ? void 0 : l.get(e),
+			channel: !1,
+			...a.has(e) ? { optional: !0 } : {}
+		}));
+	}
+	return c;
+}, o = (e) => {
+	if (e.length === 0) return;
+	let t = e.filter((e) => e.optional === !0);
+	if (t.length > 0) {
+		let n = o(e.filter((e) => e.optional !== !0)), r = t.map((e) => `  ${e.procedure}: optional integration source '${e.source}' is unavailable`);
+		return [n, `${t.length} optional integration source(s) are unavailable:\n${r.join("\n")}\nTheir observers remain declared. Installed sources still trigger recomputation; executor authorization still applies.`].filter((e) => e !== void 0).join("\n\n");
+	}
+	let n = e.map((e) => e.channel ? `  ${e.procedure}: source '${e.source}' names a reactivity channel nobody declared` : `  ${e.procedure}: source '${e.source}' matches no declared table` + (e.didYouMean === void 0 ? "" : ` — did you mean '${e.didYouMean}'?`)), r = e.some((e) => e.channel) ? "\nFor the `channel:` entries: declare it with `reactivityChannel(<name>)` and pass the\nCHANNEL as `source:`, not its key as a string. Authoring against the object is what\nmakes a channel source impossible to leave stale — you cannot import a declaration\nthat does not exist." : "";
+	return `${e.length} reactive source(s) name a table that does not exist:\n${n.join("\n")}\n
+These queries are NOT broken. They serve their first snapshot and then never
+update again, which is indistinguishable from "nothing has changed" — so the
+symptom is silence, and silence is what this surface exists to eliminate.
+A \`source:\` is a STRING, so \`tsc\` cannot see a stale one and a rename leaves it
+behind quietly.` + r;
+};
+//#endregion
+export { o as formatUnresolvedSources, a as unresolvedSources };