@oomol-lab/open-flow 0.1.0-beta.76 → 0.1.0-beta.78

package/dist/common/runtime-contract.js

@@ -23,8 +23,8 @@ function dequal(foo, bar) {
 }
 //#endregion
 //#region src/runtime/common/engineContract.ts
-/** v9 is a single contract: the Node compatibility builtins, `context.fetch`, and no `context.egress`. */
-var currentEngineContract = "open-flow-engine/v9";
+/** v10 adds persistent Flow State to the published v9 Node compatibility and fetch contract. */
+var currentEngineContract = "open-flow-engine/v10";
 /** The published v8 Node compatibility contract, retained for existing Publications and Runs. */
 var nodejsEngineContract = "open-flow-engine/v8/nodejs-compat-v1";
 var platformSource = (contract) => `export const engineContract = ${JSON.stringify(contract)}
@@ -69,13 +69,19 @@ var nodejsContract = {
 	].flatMap((name) => [name, `node:${name}`])),
 	platformSource: platformSource(nodejsEngineContract)
 };
-var currentContract = {
+var v9Contract = {
 	...nodejsContract,
 	codeFetch: true,
+	platformSource: platformSource("open-flow-engine/v9")
+};
+var currentContract = {
+	...v9Contract,
+	flowState: true,
 	platformSource: platformSource(currentEngineContract)
 };
 function findEngineContract(contract) {
-	if (contract == "open-flow-engine/v9") return currentContract;
+	if (contract == "open-flow-engine/v10") return currentContract;
+	if (contract == "open-flow-engine/v9") return v9Contract;
 	if (contract == "open-flow-engine/v8") return v8Contract;
 	if (contract == "open-flow-engine/v8/nodejs-compat-v1") return nodejsContract;
 	if (contract == "open-flow-engine/v7" || contract == "open-flow-engine/v7/nodejs-compat-v1") return {
@@ -95,6 +101,60 @@ function findEngineContract(contract) {
 }
 //#endregion
 //#region src/runtime/common/runtime.ts
+/** Serialized into the guest; keep validation and helpers self-contained. */
+function createState(invoke) {
+	const invalid = (message) => Object.assign(new TypeError(message), { code: "capability.invalid" });
+	const keyOf = (key) => {
+		if (typeof key !== "string" || key.length === 0 || new TextEncoder().encode(key).length > 256) throw invalid("State keys require 1 to 256 UTF-8 bytes.");
+		return key;
+	};
+	const valueOf = (value) => {
+		if (value === void 0) throw invalid("State values must be JSON.");
+		try {
+			return snapshotRuntimeResult({ value }).value;
+		} catch {
+			throw invalid("State values must be JSON.");
+		}
+	};
+	const idsOf = (ids) => {
+		if (!Array.isArray(ids) || !Array.from(ids).every((id) => typeof id === "string" || typeof id === "number" && Number.isFinite(id))) throw invalid("Identities must be strings or finite numbers.");
+		return ids;
+	};
+	return {
+		state: Object.freeze({
+			async get(key) {
+				return (await invoke("state.get", { key: keyOf(key) })).body.value;
+			},
+			async set(key, value) {
+				await invoke("state.set", {
+					key: keyOf(key),
+					value: valueOf(value)
+				});
+			},
+			async insert(key, value) {
+				if (value === null) throw invalid("State insert does not accept null.");
+				return (await invoke("state.insert", {
+					key: keyOf(key),
+					value: valueOf(value)
+				})).body.inserted;
+			},
+			async delete(key) {
+				await invoke("state.delete", { key: keyOf(key) });
+			},
+			async list() {
+				return (await invoke("state.list", {})).body.keys;
+			}
+		}),
+		dedupe: Object.freeze({
+			async insert(ids) {
+				return (await invoke("dedupe.insert", { ids: idsOf(ids) })).body.inserted;
+			},
+			async has(ids) {
+				return (await invoke("dedupe.has", { ids: idsOf(ids) })).body.present;
+			}
+		})
+	};
+}
 /** Snapshot a Task result before JSON transport can discard or coerce invalid values. */
 function snapshotRuntimeResult(value) {
 	const parents = /* @__PURE__ */ new Set();
@@ -394,6 +454,59 @@ async function rejects(operation, pattern, message) {
 	throw new Error(`${message}: operation unexpectedly succeeded.`);
 }
 var runtimeConformanceCases = [
+	{
+		name: "cancels detached State work when its Task finishes",
+		async verify(harness) {
+			let aborted = false;
+			equal(await harness.invoke({
+				input: null,
+				invocationId: "state-detached",
+				capability: async ({ signal }) => await new Promise((resolve) => {
+					signal.addEventListener("abort", () => {
+						aborted = true;
+						resolve({
+							status: 200,
+							body: null
+						});
+					}, { once: true });
+				}),
+				program: program(harness, `export default async (_, context) => {
+          void context.state.set('detached', 1);
+          await new Promise(resolve => setTimeout(resolve, 20));
+          return null;
+        }`)
+			}), null, "Detached State Task result");
+			equal(aborted, true, "Detached State cancellation");
+		}
+	},
+	{
+		name: "rejects non-JSON State values and invalid identities before Host dispatch",
+		async verify(harness) {
+			let calls = 0;
+			equal(await harness.invoke({
+				input: null,
+				invocationId: "state-invalid",
+				capability: async () => {
+					calls += 1;
+					return {
+						status: 200,
+						body: null
+					};
+				},
+				program: program(harness, `export default async (_, context) => {
+          const cyclic = {}; cyclic.self = cyclic;
+          const invalid = [undefined, NaN, Infinity, new Date(), { x: undefined }, cyclic, [undefined], { x: () => 1 }];
+          const errors = [];
+          for (const value of invalid) { try { await context.state.set('key', value); errors.push('accepted'); } catch (e) { errors.push(e.code); } }
+          for (const call of [() => context.state.get(''), () => context.state.get('x'.repeat(257)), () => context.state.insert('x', null), () => context.dedupe.insert([NaN]), () => context.dedupe.has([null]), () => context.dedupe.insert(new Array(1))]) {
+            try { await call(); errors.push('accepted'); } catch (e) { errors.push(e.code); }
+          }
+          return errors;
+        }`)
+			}), Array.from({ length: 14 }, () => "capability.invalid"), "State boundary validation");
+			equal(calls, 0, "State invalid dispatch");
+		}
+	},
 	{
 		name: "rejects Task results that JSON transport would discard or coerce",
 		async verify(harness) {
@@ -923,19 +1036,13 @@ function createBase64() {
 			const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
 			const bytes = new Uint8Array(text.length / 4 * 3 - padding);
 			for (let index = 0, offset = 0; index < text.length; index += 4) {
-				const digits = [
-					0,
-					1,
-					2,
-					3
-				].map((position) => {
+				let value = 0;
+				for (let position = 0; position < 4; position++) {
 					const code = text.charCodeAt(index + position);
-					if (code == 61 && index + position >= text.length - padding) return 0;
-					const value = code < 128 ? values[code] : 255;
-					if (value == 255) throw new TypeError("Base64 content is invalid.");
-					return value;
-				});
-				const value = digits[0] << 18 | digits[1] << 12 | digits[2] << 6 | digits[3];
+					const digit = code == 61 && index + position >= text.length - padding ? 0 : code < 128 ? values[code] : 255;
+					if (digit == 255) throw new TypeError("Base64 content is invalid.");
+					value = value << 6 | digit;
+				}
 				if (offset < bytes.length) bytes[offset++] = value >> 16;
 				if (offset < bytes.length) bytes[offset++] = value >> 8 & 255;
 				if (offset < bytes.length) bytes[offset++] = value & 255;
@@ -1098,4 +1205,4 @@ function createWorkflows(invoke) {
 	} });
 }
 //#endregion
-export { createActions, createArtifacts, createBase64, createFetch, createWorkflows, currentEngineContract, findEngineContract, nodejsEngineContract, nodejsRuntimeConformanceCases, resolveAction, runtimeConformanceCases, snapshotRuntimeResult };
+export { createActions, createArtifacts, createBase64, createFetch, createState, createWorkflows, currentEngineContract, findEngineContract, nodejsEngineContract, nodejsRuntimeConformanceCases, resolveAction, runtimeConformanceCases, snapshotRuntimeResult };