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

package/dist/common/scheduler-checkpoint.d.ts

@@ -1,7 +1,7 @@
 import type { Graph, JsonValue } from './flow-change.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
 import type { DependenciesCheckpoint } from './scheduler-dependencies.js';
 import type { ExecutableNode } from './scheduler-node-execution.js';
-import type { AgentCheckpoint } from './runtime-contract.js';
 export interface PendingWait {
     readonly jobId: string;
     readonly nodeId: string;

package/dist/common/scheduler-node-execution.d.ts

@@ -1,9 +1,9 @@
 import type { AgentConfig } from './flow-agent.js';
 import type { Graph, GraphNode, JsonValue, TriggerNode } from './flow-change.js';
 import type { WebhookResponseSnapshot } from './webhook-response.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
 import type { FlowRunCheckpoint } from './scheduler-checkpoint.js';
 import type { Dependencies } from './scheduler-dependencies.js';
-import type { AgentCheckpoint } from './runtime-contract.js';
 import type { FlowRunOptions, SchedulerEvent, SchedulerFailure } from './scheduler.js';
 import * as Effect from 'effect/Effect';
 import { z } from 'zod';
@@ -63,6 +63,7 @@ export declare function executeNode(context: NodeExecutionContext, input: {
     readonly node: ExecutableNode;
     readonly jobId: string;
     readonly nodeInputs: Readonly<Record<string, JsonValue>>;
+    readonly launchInputs?: Readonly<Record<string, JsonValue>>;
     readonly flowId: string;
     readonly runId: string;
     readonly graph: Graph;

package/dist/common/scheduler.d.ts

@@ -1,9 +1,9 @@
 import type { TaskCapability, JsonValue, WaitAction, WaitAutoContinue } from './flow-change.js';
 import type { PreparedFlow } from './flow-semantics.js';
 import type { WebhookResponseSnapshot } from './webhook-response.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
 import type { PreviousNode } from '../index.js';
 import type { FlowRunCheckpoint } from './scheduler-checkpoint.js';
-import type { AgentCheckpoint } from './runtime-contract.js';
 import * as Effect from 'effect/Effect';
 export type { DependenciesCheckpoint } from './scheduler-dependencies.js';
 export type { FlowRunCheckpoint, PendingWait, PendingWorkflowCall } from './scheduler-checkpoint.js';
@@ -33,7 +33,7 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'http-request' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
+    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'http-request' | 'dedupe' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';

package/dist/common/scheduler.js

@@ -9383,6 +9383,9 @@ function schemaValidationErrors(value, schema) {
 }
 //#endregion
 //#region src/decision/common/decision.ts
+function isDecisionExecutor(executor) {
+	return executor.kind === "decision";
+}
 var decisionLimits = {
 	choice: 255,
 	score: 10
@@ -9405,7 +9408,7 @@ function limitDecisionQuestions(questions) {
 }
 /** Loading an oversized task also updates its previously generated output schemas. */
 function limitDecisionTask(task) {
-	if (task.executor.kind !== "decision") return task;
+	if (!isDecisionExecutor(task.executor)) return task;
 	const original = task.executor.questions;
 	const questions = limitDecisionQuestions(original);
 	if (questions === original) return task;
@@ -9472,6 +9475,14 @@ function answerSchema(question) {
 	};
 }
 //#endregion
+//#region src/http/common/hosts.ts
+/** Hosts of a Code `http` Capability: lowercase DNS names or IPv4 addresses; `*.example.com` matches subdomains only. */
+var httpHostPattern = /^(?:\*\.)?(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/** Wildcards must name a registrable suffix, so `*.com` is rejected. */
+function isHttpHost(value) {
+	return httpHostPattern.test(value) && (!value.startsWith("*.") || value.slice(2).includes("."));
+}
+//#endregion
 //#region src/http/common/headers.ts
 /** Header names are case-insensitive; never silently combine duplicate business fields. */
 function httpHeaderNameIssue(name, names) {
@@ -9524,6 +9535,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$1().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	space: string$1().regex(/^(flow|node:.+)$/)
+});
+var dedupeExecutorSchema = strictObject({
+	field: string$1().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$1(),
+		size: number().nonnegative(),
+		updatedAt: number(),
+		value: json$1().optional()
+	})),
+	spaces: array(object({
+		space: string$1(),
+		mode: _enum(["new", "increasing"]),
+		count: number().nonnegative(),
+		watermark: union([
+			string$1(),
+			number(),
+			_null()
+		]),
+		updatedAt: number()
+	}))
+});
 //#endregion
 //#region src/flow/common/retry.ts
 var retryNodeTypes = [
@@ -9760,7 +9816,14 @@ var workflowCapabilitySchema = strictObject({
 	inputs: array(port),
 	outputs: array(port).nullable()
 });
-var capability = union([connectorCapabilitySchema, workflowCapabilitySchema]);
+var capability = union([
+	connectorCapabilitySchema,
+	workflowCapabilitySchema,
+	strictObject({
+		kind: literal("http"),
+		hosts: array(text.refine(isHttpHost, "Use a lowercase host name or IPv4 address, optionally prefixed by \"*.\" for subdomains.")).min(1).max(20).describe("Hosts Code may call with context.fetch. \"*.example.com\" matches subdomains only.")
+	})
+]);
 var inline = object({
 	...ports,
 	name: text,
@@ -9871,7 +9934,8 @@ var managedFields = object({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		dedupeExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -10124,7 +10188,9 @@ object({
 		literal(8),
 		literal(9),
 		literal(10),
-		literal(11)
+		literal(11),
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -10532,7 +10598,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: {
@@ -10541,10 +10607,12 @@ function nodeSystemOutputPorts(node) {
 	} } : {};
 }
 //#endregion
-//#region src/flow/common/change.ts
+//#region src/flow/common/model.ts
 function portsByHandle(ports) {
 	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
 }
+//#endregion
+//#region src/flow/common/change.ts
 function isTriggerNode(node) {
 	return [
 		"manual",
@@ -11559,6 +11627,7 @@ function executeNode(context, input) {
 						if (additional.has(handle)) return false;
 						const task = "executor" in node.task ? node.task : void 0;
 						if (task == null || !["openapi", "http-request"].includes(task.executor.kind)) return true;
+						if (Object.hasOwn(input.launchInputs ?? {}, handle)) return true;
 						const mapping = node.inputs[handle];
 						return mapping?.kind != "unset" && (mapping != null || task.inputs.some((port) => "handle" in port && port.handle == handle && port.value !== void 0));
 					})),
@@ -11973,6 +12042,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			node,
 			jobId,
 			nodeInputs,
+			launchInputs: launch[nodeId],
 			resolution,
 			flowId: target.flowId,
 			runId,

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

@@ -0,0 +1,16 @@
+import type { JsonValue } from './flow-model.js';
+import type { DedupeConfig } from './flow-state.js';
+export interface StateConformanceHarness {
+    readonly maxIdentities: number;
+    /** Executes Code on the same initially empty Flow and scope on every call; returns its `result` output. */
+    run(source: string): Promise<JsonValue>;
+    /** Executes the same dedupe node across Runs, updating its business config and items. */
+    dedupe(config: DedupeConfig, items: JsonValue[]): Promise<{
+        items: JsonValue[];
+        duplicates: JsonValue[];
+    }>;
+}
+export declare const stateConformanceCases: readonly {
+    name: string;
+    verify(harness: StateConformanceHarness): Promise<void>;
+}[];

package/dist/common/tags.d.ts

@@ -0,0 +1,4 @@
+import type { FlowQuery, Tag, TagListItem } from './control-api.js';
+export declare function normalizeFlowQuery(query?: FlowQuery): Required<FlowQuery>;
+export declare function decodeTag(value: unknown): Tag;
+export declare function decodeTagListItem(value: unknown): TagListItem;

package/dist/common/trigger-catalog.d.ts

@@ -1,13 +1,7 @@
 import type { TriggerKeySnapshot } from './flow-change.js';
 import type { UiLanguage } from './localization.js';
+import type { TriggerDisplay } from './trigger-localization.js';
 import type { TriggerKeySummary } from './control-api.js';
-export interface TriggerDisplay {
-    readonly configInputs: Readonly<Record<string, string>>;
-    readonly configInputLabels: Readonly<Record<string, string>>;
-    readonly displayName: string;
-    readonly description: string;
-    readonly outputs: Readonly<Record<string, string>>;
-}
 export interface TriggerCatalog {
     readonly version: 3;
     readonly locale: UiLanguage;

package/dist/common/trigger-config-options.d.ts

@@ -1,5 +1,5 @@
 import type { ConnectorProxy } from './connector-proxy.js';
-import type { JsonValue } from './flow-change.js';
+import type { JsonValue } from './flow-model.js';
 export interface TriggerConfigOption {
     readonly value: string;
     readonly label: string;

package/dist/common/trigger-config.d.ts

@@ -1,4 +1,4 @@
-import type { Group, InputPort, InputValues, JsonValue } from './flow-change.js';
+import type { Group, InputPort, InputValues, JsonValue } from './flow-model.js';
 /** Deployment-bound selections owned by the Trigger configuration contract. */
 export declare function clearTriggerExternalConfig(key: string, config: InputValues): InputValues;
 export declare function triggerConfigValue(input: InputPort, config: InputValues): JsonValue | undefined;

package/dist/common/trigger-contract.d.ts

@@ -1,4 +1,5 @@
-import type { JsonValue, Port, PortDefinition, TriggerNode } from './flow-change.js';
+import type { JsonValue, Port, PortDefinition } from './flow-model.js';
+import type { TriggerNode } from './trigger-model.js';
 import { webhookMethods, webhookSupportsBody } from './webhook-method.js';
 export { webhookMethods, webhookSupportsBody };
 export declare const errorOutputs: readonly Port[];

package/dist/common/trigger-localization.d.ts

@@ -1,6 +1,12 @@
-import type { TriggerDisplay } from './trigger-catalog.js';
-import type { TriggerKeySnapshot } from './flow-change.js';
 import type { UiLanguage } from './localization.js';
+import type { TriggerKeySnapshot } from './trigger-model.js';
+export interface TriggerDisplay {
+    readonly configInputs: Readonly<Record<string, string>>;
+    readonly configInputLabels: Readonly<Record<string, string>>;
+    readonly displayName: string;
+    readonly description: string;
+    readonly outputs: Readonly<Record<string, string>>;
+}
 type Translations = Readonly<Record<string, Partial<TriggerDisplay>>>;
 export declare function loadTriggerTranslations(locale: UiLanguage): Promise<Translations>;
 export declare function localizeTrigger(definition: TriggerKeySnapshot, locale: UiLanguage): Promise<TriggerDisplay>;

package/dist/common/trigger-model.d.ts

@@ -0,0 +1,101 @@
+import type { Group, InputPort, InputValues, Port } from './flow-model.js';
+import type { WebhookMethod } from './webhook-method.js';
+/** Trigger node shapes. The graph node union and its operations belong to flow/common/change.ts. */
+export type TriggerSchedule = {
+    readonly expression: string;
+    readonly timezone: string;
+    readonly type: 'cron';
+} | {
+    readonly type: 'every';
+    readonly unit: 'day' | 'hour' | 'minute' | 'month' | 'week';
+    readonly value: number;
+};
+interface TriggerKeySnapshotBase {
+    readonly configInputs: readonly (InputPort | Group)[];
+    readonly definitionVersion: number;
+    readonly description: string;
+    readonly displayName: string;
+    readonly key: string;
+    readonly name: string;
+    readonly outputs: readonly Port[];
+    readonly provider: string;
+}
+export type IntegrationEndpointMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
+export type IntegrationBodyFormat = 'form' | 'json' | 'multipart' | 'text';
+export interface IntegrationEndpointDeclaration {
+    readonly body: {
+        readonly allowArray: boolean;
+        readonly allowEmpty: boolean;
+        readonly formats: readonly IntegrationBodyFormat[];
+    };
+    readonly methods: readonly IntegrationEndpointMethod[];
+    readonly successStatus: number;
+}
+export type TriggerKeySnapshot = (TriggerKeySnapshotBase & {
+    readonly type: 'poll';
+}) | (TriggerKeySnapshotBase & {
+    readonly endpoint: IntegrationEndpointDeclaration;
+    readonly type: 'integration';
+});
+export interface WebhookBodyField extends InputPort {
+}
+export interface WebhookOptions {
+    readonly allowedOrigins?: readonly string[];
+    readonly responseBody?: {
+        readonly kind: 'workflow-outputs';
+        readonly output?: string;
+        readonly timeoutMs?: number;
+    } | {
+        readonly kind: 'webhook-response';
+        readonly nodeId?: string;
+        readonly timeoutMs?: number;
+    };
+    readonly responseData?: string;
+    readonly responseHeaders?: Readonly<Record<string, string>>;
+    readonly responseHeadersSource?: {
+        readonly kind: 'workflow-outputs';
+        readonly output?: string;
+    };
+    readonly responseHeaderOutputs?: Readonly<Record<string, string>>;
+    readonly responseStatusCode?: number;
+    readonly responseStatusCodeOutput?: string;
+}
+interface TriggerNodeBase {
+    readonly onError?: never;
+    readonly description?: string;
+    readonly icon?: string;
+    readonly name: string;
+}
+export type TriggerNode = (TriggerNodeBase & {
+    readonly kind: 'manual';
+}) | (TriggerNodeBase & {
+    readonly kind: 'start';
+    readonly inputDefs: readonly Port[];
+}) | (TriggerNodeBase & {
+    readonly kind: 'error';
+    readonly sourceFlowIds?: readonly string[];
+}) | (TriggerNodeBase & {
+    readonly bodyFields: readonly WebhookBodyField[];
+    readonly kind: 'webhook';
+    readonly method: WebhookMethod;
+    readonly options?: WebhookOptions;
+}) | (TriggerNodeBase & {
+    readonly cronTimes: readonly TriggerSchedule[];
+    readonly kind: 'cron';
+}) | (TriggerNodeBase & {
+    readonly connectionId?: string;
+    readonly config: InputValues;
+    readonly definition: TriggerKeySnapshot & {
+        readonly type: 'poll';
+    };
+    readonly kind: 'poll';
+    readonly pollTimes: readonly TriggerSchedule[];
+}) | (TriggerNodeBase & {
+    readonly connectionId?: string;
+    readonly config: InputValues;
+    readonly definition: TriggerKeySnapshot & {
+        readonly type: 'integration';
+    };
+    readonly kind: 'integration';
+});
+export {};

package/dist/common/webhook-response.d.ts

@@ -1,4 +1,4 @@
-import type { InputPort, JsonValue, Port, PortDefinition } from './flow-change.js';
+import type { InputPort, JsonValue, Port, PortDefinition } from './flow-model.js';
 export declare const webhookResponseTimeout: {
     readonly defaultMs: 30000;
     readonly minMs: 1000;

package/dist/common/webhook-trigger.d.ts

@@ -1,4 +1,6 @@
-import type { JsonValue, WebhookBodyField, WebhookMethod, WebhookOptions } from './flow-change.js';
+import type { JsonValue } from './flow-model.js';
+import type { WebhookMethod } from './webhook-method.js';
+import type { WebhookBodyField, WebhookOptions } from './trigger-model.js';
 export { webhookSupportsBody } from './trigger-contract.js';
 export { webhookResponseAllowsBody, webhookResponseTimeout } from './webhook-response.js';
 export type { WebhookResponseSnapshot } from './webhook-response.js';

package/dist/common/workflow.d.ts

@@ -1,10 +1,7 @@
-import type { TaskNode, ManagedTaskDefinition, Port, JsonValue, RevisionContent, GraphNode, WorkflowCapability, AgentWorkflowTool } from './flow-change.js';
+import type { TaskNode, ManagedTaskDefinition, Port, JsonValue, RevisionContent, WorkflowCapability, AgentWorkflowTool } from './flow-change.js';
 import { z } from 'zod';
-export interface WorkflowExecutor {
-    readonly kind: 'workflow';
-    readonly flowId: string;
-    readonly revisionId: string;
-}
+export type { WorkflowExecutor } from './flow-model.js';
+export { nodeWorkflowReferences } from './flow-workflowReferences.js';
 export declare const publishedWorkflowInterfaceSchema: z.ZodObject<{
     inputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
         handle: z.ZodString;
@@ -91,12 +88,6 @@ export declare const workflowReferencesSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WorkflowReferences = z.infer<typeof workflowReferencesSchema>;
-/** Workflow declarations share discovery across authoring, admission and resource indexing. */
-export declare function nodeWorkflowReferences(node: GraphNode): readonly {
-    readonly target: Omit<WorkflowCapability, 'kind' | 'name'>;
-    readonly path: string;
-    readonly tool?: string;
-}[];
 export declare function workflowCapability(name: string, target: WorkflowContract | WorkflowCandidate): WorkflowCapability;
 export declare function workflowAgentTool(id: string, name: string, target: WorkflowContract | WorkflowCandidate, previous?: AgentWorkflowTool): AgentWorkflowTool;
 export declare function workflowInterfaceIssues(target: {

package/dist/common/workflow.js

@@ -9531,6 +9531,31 @@ function comparePorts(source, target) {
 	} : result;
 }
 //#endregion
+//#region src/flow/common/workflowReferences.ts
+/** Workflow declarations share discovery across authoring, admission and resource indexing. */
+function nodeWorkflowReferences(node) {
+	if (node.kind != "task") return [];
+	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/capabilities/${index}`,
+		tool: item.name
+	}] : []);
+	if (node.task.executor.kind == "workflow") return [{
+		target: {
+			...node.task.executor,
+			inputs: node.task.inputs.filter((port) => "handle" in port),
+			outputs: node.task.outputs.filter((port) => "handle" in port)
+		},
+		path: "task/executor"
+	}];
+	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/executor/tools/${index}`,
+		tool: item.name
+	}] : []);
+	return [];
+}
+//#endregion
 //#region src/workflow/common/workflow.ts
 var portSchema = object({
 	handle: string().min(1),
@@ -9686,29 +9711,6 @@ var workflowReferencesSchema = object({
 		}).nullable()
 	}))
 });
-/** Workflow declarations share discovery across authoring, admission and resource indexing. */
-function nodeWorkflowReferences(node) {
-	if (node.kind != "task") return [];
-	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
-		target: item,
-		path: `task/capabilities/${index}`,
-		tool: item.name
-	}] : []);
-	if (node.task.executor.kind == "workflow") return [{
-		target: {
-			...node.task.executor,
-			inputs: node.task.inputs.filter((port) => "handle" in port),
-			outputs: node.task.outputs.filter((port) => "handle" in port)
-		},
-		path: "task/executor"
-	}];
-	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
-		target: item,
-		path: `task/executor/tools/${index}`,
-		tool: item.name
-	}] : []);
-	return [];
-}
 function workflowCapability(name, target) {
 	return {
 		kind: "workflow",

package/dist/index.d.ts

@@ -20,18 +20,50 @@ export interface ArtifactRef {
     readonly kind: 'artifact';
     readonly id: string;
     readonly name: string;
-    readonly mediaType: string | undefined;
+    readonly mediaType?: string;
     readonly size: number;
     readonly digest: string;
 }
 export interface ArtifactPutOptions {
     readonly name: string;
-    readonly mediaType?: string | undefined;
+    readonly mediaType?: string;
 }
-export type ArtifactData = Uint8Array | Blob | ReadableStream<Uint8Array>;
+/** Strings are stored as UTF-8. */
+export type ArtifactData = string | Uint8Array;
+/** Artifacts belong to the current Run; an ArtifactRef is JSON and can be passed to downstream nodes. */
 export interface ArtifactCapability {
     put(data: ArtifactData, options: ArtifactPutOptions): Promise<ArtifactRef>;
-    open(ref: ArtifactRef): Promise<ReadableStream<Uint8Array>>;
+    open(ref: ArtifactRef): Promise<Uint8Array>;
+}
+export interface TaskFetchInit {
+    /** GET, HEAD, POST, PUT, PATCH, DELETE or OPTIONS. */
+    readonly method?: string;
+    readonly headers?: Readonly<Record<string, string>> | Iterable<readonly [string, string]>;
+    /** At most 1 MiB; strings are sent as UTF-8 text/plain unless a content-type header is supplied. */
+    readonly body?: string | Uint8Array | ArrayBuffer;
+    readonly signal?: AbortSignal;
+}
+export interface TaskFetchHeaders extends Iterable<[string, string]> {
+    get(name: string): string | null;
+    has(name: string): boolean;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    forEach(callback: (value: string, name: string) => void): void;
+}
+/** A read-only subset of the Fetch Response; the body is buffered, at most 1 MiB, and readable once. */
+export interface TaskFetchResponse {
+    readonly status: number;
+    readonly statusText: string;
+    readonly ok: boolean;
+    readonly redirected: false;
+    readonly url: string;
+    readonly headers: TaskFetchHeaders;
+    readonly bodyUsed: boolean;
+    bytes(): Promise<Uint8Array>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
 }
 export interface MediaPreviewPayload {
     readonly type: 'video' | 'audio' | 'markdown' | 'iframe' | 'html';
@@ -60,12 +92,6 @@ export interface CsvPreviewPayload {
 }
 export type PreviewPayload = MediaPreviewPayload | TextPreviewPayload | ImagePreviewPayload | TablePreviewPayload | CsvPreviewPayload;
 export type PreviewType = PreviewPayload['type'];
-export interface TaskLogger {
-    debug(message: string, data?: unknown): void;
-    info(message: string, data?: unknown): void;
-    warn(message: string, data?: unknown): void;
-    error(message: string, data?: unknown): void;
-}
 export interface TaskContext<Actions extends object = Record<string, never>, Workflows extends object = {
     call: (name: never, input?: never) => Promise<never>;
 }> {
@@ -76,13 +102,25 @@ export interface TaskContext<Actions extends object = Record<string, never>, Wor
     readonly inputs: Readonly<Record<string, unknown>>;
     readonly runId: string;
     readonly blockId: string;
+    readonly state: {
+        get(key: string): Promise<JsonValue | null>;
+        set(key: string, value: JsonValue): Promise<void>;
+        insert(key: string, value: Exclude<JsonValue, null>): Promise<boolean>;
+        delete(key: string): Promise<void>;
+        list(): Promise<string[]>;
+    };
+    readonly dedupe: {
+        insert(ids: readonly (string | number)[]): Promise<boolean[]>;
+        has(ids: readonly (string | number)[]): Promise<boolean[]>;
+    };
     readonly artifact: ArtifactCapability;
-    readonly fetch: typeof fetch;
-    readonly logger: TaskLogger;
     /** Reads the selected direct predecessors, sorted by node ID; empty for a graph root. */
     getPrevious(): Promise<readonly PreviousNode[]>;
-    preview(payload: PreviewPayload, id?: string): Promise<void>;
-    reportProgress(progress: number): Promise<void>;
+    /**
+     * Calls an HTTP(S) URL whose host the node declares in its `http` Capability. Redirects are returned, not followed,
+     * and no platform credentials are added. Network failures reject with a TypeError.
+     */
+    fetch(input: string | URL, init?: TaskFetchInit): Promise<TaskFetchResponse>;
 }
 export type TaskResult<Outputs extends object> = keyof Outputs extends never ? Outputs | void : Outputs;
 export interface Task<Inputs extends object = Record<string, unknown>, Outputs extends object = Record<string, unknown>, Actions extends object = Record<string, never>, Workflows extends object = TaskContext['workflows']> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oomol-lab/open-flow",
-  "version": "0.1.0-beta.75",
+  "version": "0.1.0-beta.77",
   "description": "TypeScript contracts and Browser runtime for Open Flow.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
@@ -25,6 +25,10 @@
       "types": "./dist/common/decision.d.ts",
       "import": "./dist/common/decision.js"
     },
+    "./flow-state": {
+      "types": "./dist/common/flow-state.d.ts",
+      "import": "./dist/common/flow-state.js"
+    },
     "./http-request": {
       "types": "./dist/common/http-request.d.ts",
       "import": "./dist/common/http-request.js"
@@ -113,6 +117,10 @@
       "types": "./dist/common/runtime-contract.d.ts",
       "import": "./dist/common/runtime-contract.js"
     },
+    "./runtime-nodejs-compat": {
+      "types": "./dist/common/runtime-nodejs-compat.d.ts",
+      "import": "./dist/common/runtime-nodejs-compat.js"
+    },
     "./scheduler": {
       "types": "./dist/common/scheduler.d.ts",
       "import": "./dist/common/scheduler.js"

package/src/base/common/json.ts

@@ -1,4 +1,4 @@
-export type JsonValue = null | boolean | number | string | readonly JsonValue[] | JsonObject
+import type { JsonValue } from '../../types/index.ts'
 
 export type JsonObject = { readonly [key: string]: JsonValue }
 

package/src/connector/common/proxy.ts

@@ -1,5 +1,5 @@
 import type { SourceOperation, SourceReferenceOperation } from '../../event-source/common/definition.ts'
-import type { JsonValue } from '../../flow/common/change.ts'
+import type { JsonValue } from '../../types/index.ts'
 export type TriggerOperationRequest =
   | { readonly operation: 'sourceReference'; readonly request: SourceReferenceOperation }
   | { readonly operation: 'source'; readonly request: SourceOperation }