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

package/dist/common/flow-encoding.js

@@ -8604,6 +8604,43 @@ 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 skipDuplicatesExecutorSchema = strictObject({ fields: array(string().refine((field) => field.length > 0 && field.split(".").every((part) => part.length > 0), "Use a nonempty dot-separated field path.")).refine((fields) => new Set(fields).size === fields.length, "Identity fields must be distinct.").default([]) }).extend({ kind: literal("skip-duplicates") });
+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(),
+		count: number().nonnegative(),
+		pendingCount: number().nonnegative(),
+		reservedCount: number().nonnegative(),
+		updatedAt: number()
+	}))
+});
 //#endregion
 //#region src/flow/common/json.ts
 var maxJsonDepth = 64;
@@ -8890,7 +8927,8 @@ var managedFields = object({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		skipDuplicatesExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9144,7 +9182,8 @@ var revision = object({
 		literal(9),
 		literal(10),
 		literal(11),
-		literal(12)
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9399,14 +9438,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 +9647,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 === "skip-duplicates")) throw new Error("Skip Duplicates 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 +9709,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 +10284,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,63 @@ 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 skipDuplicatesConfigSchema = strictObject({ fields: array(string().refine((field) => field.length > 0 && field.split(".").every((part) => part.length > 0), "Use a nonempty dot-separated field path.")).refine((fields) => new Set(fields).size === fields.length, "Identity fields must be distinct.").default([]) });
+var skipDuplicatesExecutorSchema = skipDuplicatesConfigSchema.extend({ kind: literal("skip-duplicates") });
+function skipDuplicatesTask(config = skipDuplicatesConfigSchema.parse({}), name = "Skip Duplicates") {
+	return {
+		name,
+		executor: {
+			...config,
+			kind: "skip-duplicates"
+		},
+		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(),
+		count: number().nonnegative(),
+		pendingCount: number().nonnegative(),
+		reservedCount: number().nonnegative(),
+		updatedAt: number()
+	}))
+});
 //#endregion
 //#region src/flow/common/inputValue.ts
 /** An explicit clear suppresses the default; absent mappings still inherit it. */
@@ -10736,7 +10793,8 @@ var managedFields = object$1({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		skipDuplicatesExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -11006,7 +11064,8 @@ object$1({
 		literal(9),
 		literal(10),
 		literal(11),
-		literal(12)
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -11352,7 +11411,7 @@ var nodeErrorSchema = {
 	}
 };
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node);
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "skip-duplicates";
 }
 function nodeSystemOutputPorts(node) {
 	return supportsNodeErrorHandling(node) && node.onError == "error" ? { error: {
@@ -11880,8 +11939,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 +11985,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 +24999,16 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
+		if (task.executor.kind === "skip-duplicates") {
+			const expected = skipDuplicatesTask(task.executor);
+			if (!dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) || !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))) checked.diagnostics.push({
+				code: "skip-duplicates.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 +25143,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 === "skip-duplicates")) 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" };
@@ -25116,11 +25192,13 @@ async function prepareFlow(revision, engineContract, triggerId) {
 }
 function createRuntimeProgram(prepared, entryModuleId, engineDigest) {
 	if (!Object.hasOwn(prepared.modules, entryModuleId)) return;
+	const modules = /* @__PURE__ */ new Set([entryModuleId]);
+	for (const id of modules) for (const imported of prepared.modules[id].imports) modules.add(imported);
 	return {
 		engineContract: prepared.engineContract,
 		engineDigest,
 		entryModuleId,
-		modules: prepared.modules
+		modules: Object.fromEntries([...modules].map((id) => [id, prepared.modules[id]]))
 	};
 }
 function agentActions(flow) {

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

@@ -0,0 +1,100 @@
+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 skipDuplicatesConfigSchema: z.ZodObject<{
+    fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SkipDuplicatesConfig = z.infer<typeof skipDuplicatesConfigSchema>;
+export interface SkipDuplicatesExecutor extends SkipDuplicatesConfig {
+    readonly kind: 'skip-duplicates';
+}
+export declare const skipDuplicatesExecutorSchema: z.ZodObject<{
+    fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kind: z.ZodLiteral<"skip-duplicates">;
+}, z.core.$strict>;
+export declare function skipDuplicatesTask(config?: SkipDuplicatesConfig, name?: string): ManagedTaskDefinitionOf<SkipDuplicatesExecutor>;
+export declare class StateError extends Error {
+    readonly retryable = false;
+    readonly catchable: boolean;
+    readonly code: 'capability.invalid' | 'capability.denied' | 'dedupe.full' | 'limit-exceeded' | 'node.input-invalid';
+    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[]>;
+/** Canonical identities include the field definition and preserve scalar types. */
+export declare function skipDuplicatesIdentities(items: JsonValue, fields: readonly string[]): string[];
+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 count: number;
+        readonly pendingCount: number;
+        readonly reservedCount: number;
+        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;
+        count: z.ZodNumber;
+        pendingCount: z.ZodNumber;
+        reservedCount: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;