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

package/dist/common/flow-encoding.js

@@ -8604,6 +8604,51 @@ var httpRequestExecutorSchema = strictObject({
 	]).default("auto"),
 	statusPolicy: _enum(["success", "all"]).default("success")
 }).extend({ kind: literal("http-request") });
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: boolean().optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	space: string().regex(/^(flow|node:.+)$/)
+});
+var dedupeExecutorSchema = strictObject({
+	field: string().default(""),
+	mode: _enum(["new", "increasing"]).default("new"),
+	space: _enum(["node", "flow"]).default("node")
+}).extend({ kind: literal("dedupe") });
+object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	limits: object({
+		maxValueBytes: number().positive(),
+		maxValues: number().int().positive(),
+		maxSpaces: number().int().positive(),
+		maxIdentities: number().positive(),
+		maxRunWrites: number().positive()
+	}),
+	values: array(object({
+		key: string(),
+		size: number().nonnegative(),
+		updatedAt: number(),
+		value: json$1().optional()
+	})),
+	spaces: array(object({
+		space: string(),
+		mode: _enum(["new", "increasing"]),
+		count: number().nonnegative(),
+		watermark: union([
+			string(),
+			number(),
+			_null()
+		]),
+		updatedAt: number()
+	}))
+});
 //#endregion
 //#region src/flow/common/json.ts
 var maxJsonDepth = 64;
@@ -8890,7 +8935,8 @@ var managedFields = object({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		dedupeExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9144,7 +9190,8 @@ var revision = object({
 		literal(9),
 		literal(10),
 		literal(11),
-		literal(12)
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9399,14 +9446,14 @@ function repairRevisionEnvelope(value) {
 	checkJsonDepth(value);
 	const envelopeSource = record(value);
 	if (envelopeSource.kind != "open-flow-flow-revision" || envelopeSource.version != 1) throw new TypeError("The value is not an Open Flow Revision envelope.");
-	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion > 12) throw new TypeError("The Flow model is newer than this package.");
+	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion > 13) throw new TypeError("The Flow model is newer than this package.");
 	let sourceDocument = record(envelopeSource.modelVersion == 1 || envelopeSource.modelVersion == 2 ? upgradeLegacyDocument(envelopeSource.document) : envelopeSource.document);
 	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion < 6) sourceDocument = upgradeTaskNodes(sourceDocument);
 	sourceDocument = record(normalizeDocument(sourceDocument));
 	const bindings = record(sourceDocument.bindings);
 	const sourceGraph = repairGraph(sourceDocument.graph, bindings);
 	return decodeRevisionContent({
-		modelVersion: 12,
+		modelVersion: 13,
 		document: {
 			bindings: repairedEntries(sourceDocument.bindings, binding),
 			graph: sourceGraph
@@ -9608,6 +9655,7 @@ array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, sha
 	...shape
 })])).values()])).min(1);
 function checkModelVersion(content) {
+	if (content.modelVersion < 13 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind === "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind === "dedupe")) throw new Error("Deduplication requires Flow model v13.");
 	if (content.modelVersion < 12 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "moduleId" in candidateNode.task && candidateNode.task.capabilities?.some((item) => item.kind == "http"))) throw new TypeError("Code HTTP access requires Flow model version 12.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind == "http-request")) throw new TypeError("HTTP Request requires Flow model version 11.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && ("moduleId" in candidateNode.task ? candidateNode.task.capabilities?.some((item) => item.kind == "workflow") : candidateNode.task.executor.kind == "agent" && candidateNode.task.executor.tools.some((item) => item.kind == "workflow")))) throw new TypeError("Workflow tools require Flow model version 11.");
@@ -9669,10 +9717,10 @@ function upgradeRevisionContent(content) {
 function upgradeDecodedRevisionContent(content) {
 	const graph = content.document.graph;
 	const hasManual = Object.values(graph.nodes).some((node) => node.kind == "manual");
-	if (!hasManual && content.modelVersion == 12) return content;
+	if (!hasManual && content.modelVersion == 13) return content;
 	return {
 		...content,
-		modelVersion: 12,
+		modelVersion: 13,
 		document: {
 			...content.document,
 			graph: hasManual ? {
@@ -10244,7 +10292,7 @@ function revisionRepairKind(bytes) {
 		return;
 	}
 	const source = value;
-	return typeof source.modelVersion == "number" && source.modelVersion < 12 ? "upgrade" : "repair";
+	return typeof source.modelVersion == "number" && source.modelVersion < 13 ? "upgrade" : "repair";
 }
 function repairRevision(bytes) {
 	return repairRevisionEnvelope(revisionValue(bytes));

package/dist/common/flow-semantics.js

@@ -10362,6 +10362,71 @@ function openApiFieldIssues(task) {
 function openApiIssues(task) {
 	return openApiFieldIssues(task).map((issue) => issue.message);
 }
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: boolean().optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	space: string().regex(/^(flow|node:.+)$/)
+});
+var dedupeConfigSchema = strictObject({
+	field: string().default(""),
+	mode: _enum(["new", "increasing"]).default("new"),
+	space: _enum(["node", "flow"]).default("node")
+});
+var dedupeExecutorSchema = dedupeConfigSchema.extend({ kind: literal("dedupe") });
+function dedupeTask(config = dedupeConfigSchema.parse({}), name = "Remove Duplicates") {
+	return {
+		name,
+		executor: {
+			...config,
+			kind: "dedupe"
+		},
+		inputs: [{
+			handle: "items",
+			jsonSchema: { type: "array" },
+			nullable: false
+		}],
+		outputs: ["items", "duplicates"].map((handle) => ({
+			handle,
+			jsonSchema: { type: "array" },
+			nullable: false
+		}))
+	};
+}
+object$1({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	limits: object$1({
+		maxValueBytes: number().positive(),
+		maxValues: number().int().positive(),
+		maxSpaces: number().int().positive(),
+		maxIdentities: number().positive(),
+		maxRunWrites: number().positive()
+	}),
+	values: array(object$1({
+		key: string(),
+		size: number().nonnegative(),
+		updatedAt: number(),
+		value: json$1().optional()
+	})),
+	spaces: array(object$1({
+		space: string(),
+		mode: _enum(["new", "increasing"]),
+		count: number().nonnegative(),
+		watermark: union([
+			string(),
+			number(),
+			_null()
+		]),
+		updatedAt: number()
+	}))
+});
 //#endregion
 //#region src/flow/common/inputValue.ts
 /** An explicit clear suppresses the default; absent mappings still inherit it. */
@@ -10736,7 +10801,8 @@ var managedFields = object$1({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		dedupeExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -11006,7 +11072,8 @@ object$1({
 		literal(9),
 		literal(10),
 		literal(11),
-		literal(12)
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -11352,7 +11419,7 @@ var nodeErrorSchema = {
 	}
 };
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node);
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe";
 }
 function nodeSystemOutputPorts(node) {
 	return supportsNodeErrorHandling(node) && node.onError == "error" ? { error: {
@@ -11880,8 +11947,8 @@ function normalizeTriggerOutputs(trigger, outputs) {
 }
 //#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)}
@@ -11926,13 +11993,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 {
@@ -24934,6 +25007,16 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
+		if (task.executor.kind === "dedupe") {
+			const expected = dedupeTask(task.executor);
+			if (!dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) || !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))) checked.diagnostics.push({
+				code: "dedupe.ports-invalid",
+				column: 0,
+				line: 1,
+				message: "Deduplication ports must match the fixed contract.",
+				path: `/document/graph/nodes/${nodeId}/task`
+			});
+		}
 		if (task.executor.kind == "http-request") {
 			for (const issue of httpRequestIssues(task.executor)) checked.diagnostics.push({
 				code: "http-request.config-invalid",
@@ -25068,6 +25151,7 @@ var httpPortContracts = (ports) => ports.filter((port) => "handle" in port).map(
 async function prepareFlow(revision, engineContract, triggerId) {
 	const engine = findEngineContract(engineContract);
 	if (engine == null) return { kind: "engine-unsupported" };
+	if (!engine.flowState && Object.values(revision.document.graph.nodes).some((node) => node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe")) return { kind: "engine-unsupported" };
 	if (!engine.httpRequests && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "executor" in node.task && node.task.executor.kind == "http-request")) return { kind: "engine-unsupported" };
 	if (!engine.codeFetch && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "moduleId" in node.task && node.task.capabilities?.some((item) => item.kind == "http"))) return { kind: "engine-unsupported" };
 	if (!engine.workflowTools && Object.values(revision.document.graph.nodes).some((node) => nodeWorkflowReferences(node).some((ref) => ref.tool != null))) return { kind: "engine-unsupported" };

package/dist/common/flow-state.d.ts

@@ -0,0 +1,123 @@
+import type { JsonValue, ManagedTaskDefinitionOf } from './flow-model.js';
+import { z } from 'zod';
+export { stateConformanceCases, type StateConformanceHarness } from './state-conformance.js';
+export type StateScope = 'draft' | 'live';
+export declare const stateQuerySchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    values: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const stateClearSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    key: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const dedupeClearSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    space: z.ZodString;
+}, z.core.$strict>;
+export type DedupeIdentity = string | number;
+export declare const dedupeConfigSchema: z.ZodObject<{
+    field: z.ZodDefault<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        increasing: "increasing";
+        new: "new";
+    }>>;
+    space: z.ZodDefault<z.ZodEnum<{
+        flow: "flow";
+        node: "node";
+    }>>;
+}, z.core.$strict>;
+export type DedupeConfig = z.infer<typeof dedupeConfigSchema>;
+export interface DedupeExecutor extends DedupeConfig {
+    readonly kind: 'dedupe';
+}
+export declare const dedupeExecutorSchema: z.ZodObject<{
+    field: z.ZodDefault<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        increasing: "increasing";
+        new: "new";
+    }>>;
+    space: z.ZodDefault<z.ZodEnum<{
+        flow: "flow";
+        node: "node";
+    }>>;
+    kind: z.ZodLiteral<"dedupe">;
+}, z.core.$strict>;
+export declare function dedupeTask(config?: DedupeConfig, name?: string): ManagedTaskDefinitionOf<DedupeExecutor>;
+export declare class StateError extends Error {
+    readonly retryable = false;
+    readonly catchable: boolean;
+    readonly code: 'capability.invalid' | 'capability.denied' | 'dedupe.full' | 'limit-exceeded';
+    constructor(code: StateError['code'], message: string);
+}
+export declare function stateKey(key: unknown): string;
+export declare function dedupeIdentities(value: unknown): DedupeIdentity[];
+export declare function hashIdentities(ids: readonly DedupeIdentity[]): Promise<Uint8Array[]>;
+export declare function watermarkValue(id: DedupeIdentity): number;
+export declare function increasingIdentities(ids: readonly DedupeIdentity[], watermark: DedupeIdentity | null): {
+    inserted: boolean[];
+    watermark: DedupeIdentity | null;
+};
+export declare function itemIdentities(items: JsonValue, field: string): DedupeIdentity[];
+export interface FlowStateView {
+    readonly version: 1;
+    readonly scope: StateScope;
+    readonly limits: {
+        readonly maxValueBytes: number;
+        readonly maxValues: number;
+        readonly maxSpaces: number;
+        readonly maxIdentities: number;
+        readonly maxRunWrites: number;
+    };
+    readonly values: readonly {
+        readonly key: string;
+        readonly size: number;
+        readonly updatedAt: number;
+        readonly value?: JsonValue;
+    }[];
+    readonly spaces: readonly {
+        readonly space: string;
+        readonly mode: 'new' | 'increasing';
+        readonly count: number;
+        readonly watermark: DedupeIdentity | null;
+        readonly updatedAt: number;
+    }[];
+}
+export declare const flowStateViewSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    limits: z.ZodObject<{
+        maxValueBytes: z.ZodNumber;
+        maxValues: z.ZodNumber;
+        maxSpaces: z.ZodNumber;
+        maxIdentities: z.ZodNumber;
+        maxRunWrites: z.ZodNumber;
+    }, z.core.$strip>;
+    values: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        size: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strip>>;
+    spaces: z.ZodArray<z.ZodObject<{
+        space: z.ZodString;
+        mode: z.ZodEnum<{
+            increasing: "increasing";
+            new: "new";
+        }>;
+        count: z.ZodNumber;
+        watermark: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;