@ankhorage/flow 0.0.0-stage → 0.4.1

package/dist/types/security.d.ts

@@ -0,0 +1,123 @@
+import type { SecretMetadata, SecretPayload, SecretRef } from '@ankhorage/contracts/secrets';
+/** Trusted execution identity supplied by the host authentication boundary. */
+export interface FlowSecurityActor {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly projectId: string;
+    readonly environment: string;
+}
+/** An exact capability grant; omitted dimensions never imply access. */
+export interface FlowSecurityGrant {
+    readonly actorId: string;
+    readonly capability: string;
+    readonly tenantId: string;
+    readonly projectId: string;
+    readonly environment: string;
+}
+/** A protected external operation presented to the security boundary. */
+export interface FlowSecurityOperation {
+    readonly actor: FlowSecurityActor;
+    readonly capability: string;
+    readonly idempotencyKey: string;
+    readonly operationId: string;
+    readonly secretRefs?: readonly SecretRef[];
+    readonly target?: FlowSecurityTarget;
+}
+/** An outbound destination and its exact host authority. */
+export interface FlowSecurityTarget {
+    readonly allowedHosts: readonly string[];
+    readonly url: string;
+}
+/** The complete immutable identity that grants, claims, and consumes one operation. */
+export interface FlowSecurityOperationIdentity {
+    readonly actor: FlowSecurityActor;
+    readonly capability: string;
+    readonly idempotencyKey: string;
+    readonly operationId: string;
+    readonly secretRefs: readonly SecretRef[];
+    readonly target?: FlowSecurityTarget;
+}
+/** A durable human decision bound to exactly one complete operation identity. */
+export interface FlowSecurityApproval {
+    readonly operation: FlowSecurityOperationIdentity;
+    readonly status: 'approved' | 'pending' | 'rejected';
+}
+/** Host-owned persistence boundary for approval-gate state. */
+export interface FlowApprovalStorePort {
+    getAsync(operation: FlowSecurityOperationIdentity): Promise<FlowSecurityApproval | undefined>;
+}
+/**
+ * Host-owned durable exactly-once boundary. Every transition must be atomic across workers and
+ * restarts. `releaseAsync` may only release an unconsumed claim for this exact identity.
+ */
+export interface FlowOperationStorePort {
+    claimAsync(operation: FlowSecurityOperationIdentity): Promise<boolean>;
+    consumeAsync(operation: FlowSecurityOperationIdentity): Promise<boolean>;
+    releaseAsync(operation: FlowSecurityOperationIdentity): Promise<void>;
+}
+/**
+ * Host-owned network boundary that verifies every actual peer before opening a connection.
+ * It must enforce the supplied host allowlist, resolve immediately before every connection,
+ * reject private or special-use resolved addresses, and reapply that policy to redirects.
+ */
+export interface FlowOutboundTransportPort {
+    fetchAsync(input: {
+        readonly allowedHosts: readonly string[];
+        readonly init?: RequestInit;
+        readonly url: string;
+    }): Promise<Response>;
+}
+/** Host-owned rate limiter. A denied acquisition must have no external side effect. */
+export interface FlowRateLimitPort {
+    acquireAsync(input: {
+        readonly actor: FlowSecurityActor;
+        readonly capability: string;
+        readonly operationId: string;
+    }): Promise<boolean>;
+}
+/** Redaction-safe audit edge. Secret values and payloads are intentionally absent. */
+export interface FlowSecurityAuditPort {
+    writeAsync(event: FlowSecurityAuditEvent): Promise<void>;
+}
+/** Immutable audit metadata for one permit or denial. */
+export interface FlowSecurityAuditEvent {
+    readonly actorId: string;
+    readonly capability: string;
+    readonly decision: 'denied' | 'permitted';
+    readonly operationId: string;
+    readonly reason: 'approval_pending' | 'approval_rejected' | 'credential_create' | 'credential_revoke' | 'idempotency_conflict' | 'invalid_target' | 'permission_denied' | 'rate_limited' | 'secret_unavailable';
+    readonly secretRefs: readonly SecretRef[];
+    readonly targetHost?: string;
+}
+/** Metadata-only credential view safe for administrative or graph-facing callers. */
+export type FlowSecretMetadata = SecretMetadata;
+export type FlowResolvedSecrets = Readonly<Record<SecretRef, Readonly<Record<string, string>>>>;
+/** Protected server-side credential creation input. Its scope is always derived from the actor. */
+export interface FlowSecretCreateInput {
+    readonly actor: FlowSecurityActor;
+    readonly kind: string;
+    readonly payload: SecretPayload;
+    readonly provider?: string;
+    readonly ref: SecretRef;
+}
+/** Protected server-side credential revocation input. Its scope is always derived from the actor. */
+export interface FlowSecretRevokeInput {
+    readonly actor: FlowSecurityActor;
+    readonly ref: SecretRef;
+}
+/** One-use authorization result. Raw secrets stay private to the returned server closure. */
+export interface FlowSecurityPermit {
+    readonly operation: FlowSecurityOperationIdentity;
+    executeAsync<T>(operation: (secrets: FlowResolvedSecrets) => Promise<T>): Promise<T>;
+}
+/** Public server-side boundary consumed by provider, AI, MCP, and social adapters. */
+export interface FlowSecurityPort {
+    authorizeAsync(operation: FlowSecurityOperation): Promise<FlowSecurityPermit>;
+    createSecretAsync(input: FlowSecretCreateInput): Promise<FlowSecretMetadata>;
+    getSecretMetadataAsync(input: {
+        readonly actor: FlowSecurityActor;
+        readonly ref: SecretRef;
+    }): Promise<FlowSecretMetadata>;
+    revokeSecretAsync(input: FlowSecretRevokeInput): Promise<void>;
+}
+//# sourceMappingURL=security.d.ts.map

package/dist/types/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/types/security.ts"],"names":[],"mappings":"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"}

package/dist/types/security.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=security.js.map

package/dist/types/security.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.js","sourceRoot":"","sources":["../../src/types/security.ts"],"names":[],"mappings":"","sourcesContent":["import type { SecretMetadata, SecretPayload, SecretRef } from '@ankhorage/contracts/secrets';\n\n/** Trusted execution identity supplied by the host authentication boundary. */\nexport interface FlowSecurityActor {\n  readonly id: string;\n  readonly tenantId: string;\n  readonly projectId: string;\n  readonly environment: string;\n}\n\n/** An exact capability grant; omitted dimensions never imply access. */\nexport interface FlowSecurityGrant {\n  readonly actorId: string;\n  readonly capability: string;\n  readonly tenantId: string;\n  readonly projectId: string;\n  readonly environment: string;\n}\n\n/** A protected external operation presented to the security boundary. */\nexport interface FlowSecurityOperation {\n  readonly actor: FlowSecurityActor;\n  readonly capability: string;\n  readonly idempotencyKey: string;\n  readonly operationId: string;\n  readonly secretRefs?: readonly SecretRef[];\n  readonly target?: FlowSecurityTarget;\n}\n\n/** An outbound destination and its exact host authority. */\nexport interface FlowSecurityTarget {\n  readonly allowedHosts: readonly string[];\n  readonly url: string;\n}\n\n/** The complete immutable identity that grants, claims, and consumes one operation. */\nexport interface FlowSecurityOperationIdentity {\n  readonly actor: FlowSecurityActor;\n  readonly capability: string;\n  readonly idempotencyKey: string;\n  readonly operationId: string;\n  readonly secretRefs: readonly SecretRef[];\n  readonly target?: FlowSecurityTarget;\n}\n\n/** A durable human decision bound to exactly one complete operation identity. */\nexport interface FlowSecurityApproval {\n  readonly operation: FlowSecurityOperationIdentity;\n  readonly status: 'approved' | 'pending' | 'rejected';\n}\n\n/** Host-owned persistence boundary for approval-gate state. */\nexport interface FlowApprovalStorePort {\n  getAsync(operation: FlowSecurityOperationIdentity): Promise<FlowSecurityApproval | undefined>;\n}\n\n/**\n * Host-owned durable exactly-once boundary. Every transition must be atomic across workers and\n * restarts. `releaseAsync` may only release an unconsumed claim for this exact identity.\n */\nexport interface FlowOperationStorePort {\n  claimAsync(operation: FlowSecurityOperationIdentity): Promise<boolean>;\n  consumeAsync(operation: FlowSecurityOperationIdentity): Promise<boolean>;\n  releaseAsync(operation: FlowSecurityOperationIdentity): Promise<void>;\n}\n\n/**\n * Host-owned network boundary that verifies every actual peer before opening a connection.\n * It must enforce the supplied host allowlist, resolve immediately before every connection,\n * reject private or special-use resolved addresses, and reapply that policy to redirects.\n */\nexport interface FlowOutboundTransportPort {\n  fetchAsync(input: {\n    readonly allowedHosts: readonly string[];\n    readonly init?: RequestInit;\n    readonly url: string;\n  }): Promise<Response>;\n}\n\n/** Host-owned rate limiter. A denied acquisition must have no external side effect. */\nexport interface FlowRateLimitPort {\n  acquireAsync(input: {\n    readonly actor: FlowSecurityActor;\n    readonly capability: string;\n    readonly operationId: string;\n  }): Promise<boolean>;\n}\n\n/** Redaction-safe audit edge. Secret values and payloads are intentionally absent. */\nexport interface FlowSecurityAuditPort {\n  writeAsync(event: FlowSecurityAuditEvent): Promise<void>;\n}\n\n/** Immutable audit metadata for one permit or denial. */\nexport interface FlowSecurityAuditEvent {\n  readonly actorId: string;\n  readonly capability: string;\n  readonly decision: 'denied' | 'permitted';\n  readonly operationId: string;\n  readonly reason:\n    | 'approval_pending'\n    | 'approval_rejected'\n    | 'credential_create'\n    | 'credential_revoke'\n    | 'idempotency_conflict'\n    | 'invalid_target'\n    | 'permission_denied'\n    | 'rate_limited'\n    | 'secret_unavailable';\n  readonly secretRefs: readonly SecretRef[];\n  readonly targetHost?: string;\n}\n\n/** Metadata-only credential view safe for administrative or graph-facing callers. */\nexport type FlowSecretMetadata = SecretMetadata;\nexport type FlowResolvedSecrets = Readonly<Record<SecretRef, Readonly<Record<string, string>>>>;\n\n/** Protected server-side credential creation input. Its scope is always derived from the actor. */\nexport interface FlowSecretCreateInput {\n  readonly actor: FlowSecurityActor;\n  readonly kind: string;\n  readonly payload: SecretPayload;\n  readonly provider?: string;\n  readonly ref: SecretRef;\n}\n\n/** Protected server-side credential revocation input. Its scope is always derived from the actor. */\nexport interface FlowSecretRevokeInput {\n  readonly actor: FlowSecurityActor;\n  readonly ref: SecretRef;\n}\n\n/** One-use authorization result. Raw secrets stay private to the returned server closure. */\nexport interface FlowSecurityPermit {\n  readonly operation: FlowSecurityOperationIdentity;\n  executeAsync<T>(operation: (secrets: FlowResolvedSecrets) => Promise<T>): Promise<T>;\n}\n\n/** Public server-side boundary consumed by provider, AI, MCP, and social adapters. */\nexport interface FlowSecurityPort {\n  authorizeAsync(operation: FlowSecurityOperation): Promise<FlowSecurityPermit>;\n  createSecretAsync(input: FlowSecretCreateInput): Promise<FlowSecretMetadata>;\n  getSecretMetadataAsync(input: {\n    readonly actor: FlowSecurityActor;\n    readonly ref: SecretRef;\n  }): Promise<FlowSecretMetadata>;\n  revokeSecretAsync(input: FlowSecretRevokeInput): Promise<void>;\n}\n"]}

package/package.json

@@ -1,6 +1,88 @@
 {
   "name": "@ankhorage/flow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.1",
+  "description": "Standalone workflow engine foundation for Ankhorage.",
+  "keywords": [
+    "ankhorage",
+    "flow",
+    "workflow",
+    "automation"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai.d.ts",
+      "default": "./dist/ai.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "default": "./dist/mcp.js"
+    },
+    "./social": {
+      "types": "./dist/social.d.ts",
+      "default": "./dist/social.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ankhorage/flow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ankhorage/flow/issues"
+  },
+  "homepage": "https://github.com/ankhorage/flow#readme",
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf dist tsconfig.tsbuildinfo && bun x tsc -p tsconfig.json",
+    "changeset": "ankhorage-changeset",
+    "changeset:status": "ankhorage-changeset status --since=origin/main",
+    "docs": "paradox",
+    "lint": "ankhorage-eslint . --max-warnings=0",
+    "lint:fix": "ankhorage-eslint . --fix --max-warnings=0",
+    "format": "ankhorage-prettier --write .",
+    "format:check": "ankhorage-prettier --check .",
+    "knip:check": "ankhorage-knip",
+    "test": "bun test src test",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.node-esm.json && tsc --noEmit -p tsconfig.test.json",
+    "version-packages": "ankhorage-changeset version"
+  },
+  "devDependencies": {
+    "@ankhorage/devtools": "^2.4.3",
+    "@ankhorage/paradox": "^0.3.6",
+    "@ankhorage/secrets-supabase-vault": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@types/bun": "^1.4.2",
+    "@types/node": "^26.6.6",
+    "typescript": "^6.0.3"
+  },
+  "packageManager": "bun@1.4.2",
+  "dependencies": {
+    "@ankhorage/contracts": "^26.7.0"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    }
+  }
+}

package/src/ai.ts

@@ -0,0 +1,6 @@
+/***
+ * Reserved public subpath for future AI-provider adapters.
+ *
+ * This bootstrap intentionally provides no AI execution, configuration, or dependencies.
+ */
+export {};

package/src/features/execution/application/executeFlowAsync.ts

@@ -0,0 +1,338 @@
+import type { DataContractValue } from '@ankhorage/contracts/data';
+import type {
+  FlowDataRef,
+  FlowEdge,
+  FlowError,
+  FlowNode,
+  FlowPortId,
+  FlowRunSnapshot,
+  FlowStepSnapshot,
+} from '@ankhorage/contracts/flow';
+
+import type {
+  FlowClock,
+  FlowCompiledGraph,
+  FlowExecutionResult,
+  FlowNodeRegistry,
+  FlowRunRequest,
+} from '../../../types/execution.js';
+import { assertFlowGraphSchemasSupported } from '../domain/assertFlowGraphSchemasSupported.js';
+import { validateFlowDataSchema } from '../domain/validateFlowDataSchema.js';
+
+/*** Execute a compiled graph in deterministic order within one process. */
+export const executeFlowAsync = async (
+  graph: FlowCompiledGraph,
+  registry: FlowNodeRegistry,
+  request: FlowRunRequest,
+  clock: FlowClock = { now: () => new Date() },
+): Promise<FlowExecutionResult> => {
+  const trigger = graph.definition.triggers.find(({ id }) => id === request.triggerId);
+  if (trigger?.kind !== 'manual') throw new Error('FLOW_TRIGGER_NOT_MANUAL');
+  assertFlowGraphSchemasSupported(graph.definition.nodes, request.schemaRegistry);
+  const startedAt = clock.now().toISOString();
+  const state = await executeNodesAsync(graph, registry, request, clock);
+  return {
+    run: createRun(
+      graph,
+      request,
+      state.steps,
+      startedAt,
+      clock.now().toISOString(),
+      state.status ?? 'succeeded',
+      state.error,
+    ),
+  };
+};
+
+/*** Iterate compiled nodes in deterministic order until completion or cancellation. */
+const executeNodesAsync = async (
+  graph: FlowCompiledGraph,
+  registry: FlowNodeRegistry,
+  request: FlowRunRequest,
+  clock: FlowClock,
+): Promise<ExecutionState> => {
+  const state: ExecutionState = {
+    activatedNodeIds: new Set(
+      graph.topologicalNodeIds.filter(
+        (nodeId) => !graph.definition.edges.some((edge) => edge.target.nodeId === nodeId),
+      ),
+    ),
+    inputs: {},
+    steps: [],
+  };
+  for (const nodeId of graph.topologicalNodeIds) {
+    if (request.signal?.aborted) return { ...state, status: 'cancelled' };
+    const node = graph.definition.nodes.find((candidate) => candidate.id === nodeId);
+    if (!node) throw new Error(`FLOW_GRAPH_UNKNOWN_NODE:${nodeId}`);
+    const result = await executeAvailableNodeAsync(node, state, registry, request, clock);
+    if (!result) continue;
+    state.steps.push(result.step);
+    if (result.step.status === 'cancelled') return { ...state, status: 'cancelled' };
+    propagateOutput(
+      graph.edgesBySourceNodeId[node.id] ?? [],
+      result.output,
+      result.step.status === 'failed' ? 'failure' : 'success',
+      state,
+    );
+  }
+  const failedStep = state.steps.find((step) => step.status === 'failed');
+  return { ...state, status: failedStep ? 'failed' : 'succeeded', error: failedStep?.error };
+};
+
+interface ExecutionState {
+  readonly activatedNodeIds: Set<string>;
+  readonly error?: FlowError;
+  readonly inputs: Record<string, Record<FlowPortId, FlowDataRef>>;
+  readonly status?: FlowRunSnapshot['status'];
+  readonly steps: FlowStepSnapshot[];
+}
+
+/*** Execute one node only when all of its required inputs were propagated. */
+const executeAvailableNodeAsync = async (
+  node: FlowNode,
+  state: ExecutionState,
+  registry: FlowNodeRegistry,
+  request: FlowRunRequest,
+  clock: FlowClock,
+): Promise<
+  | { readonly output: Readonly<Record<FlowPortId, FlowDataRef>>; readonly step: FlowStepSnapshot }
+  | undefined
+> => {
+  if (!state.activatedNodeIds.has(node.id)) return undefined;
+  const input = state.inputs[node.id] ?? request.input ?? {};
+  if (!hasRequiredInput(node, input)) return undefined;
+  return executeNodeAsync(node, input, registry, request.signal, clock, request.schemaRegistry);
+};
+
+/*** Determine whether every required input port has a propagated value. */
+const hasRequiredInput = (
+  node: FlowNode,
+  input: Readonly<Record<FlowPortId, FlowDataRef>>,
+): boolean =>
+  node.ports
+    .filter((port) => port.direction === 'input' && port.required)
+    .every((port) => input[port.id] !== undefined);
+
+/*** Execute one node and convert failures to redaction-safe contract errors. */
+const executeNodeAsync = async (
+  node: FlowNode,
+  input: Readonly<Record<FlowPortId, FlowDataRef>>,
+  registry: FlowNodeRegistry,
+  signal: AbortSignal | undefined,
+  clock: FlowClock,
+  schemas: FlowRunRequest['schemaRegistry'],
+): Promise<{
+  readonly output: Readonly<Record<FlowPortId, FlowDataRef>>;
+  readonly step: FlowStepSnapshot;
+}> => {
+  const startedAt = clock.now().toISOString();
+  try {
+    assertPortSchemas(node, input, 'input', schemas);
+    const operationId = `${node.capability.providerId}:${node.capability.capabilityId}`;
+    const operation = Object.entries(registry).find(([id]) => id === operationId)?.[1];
+    if (!operation) throw new Error(`FLOW_OPERATION_UNREGISTERED:${operationId}`);
+    const output =
+      (
+        await operation.executeAsync({
+          config: node.config,
+          input,
+          node,
+          signal: signal ?? new AbortController().signal,
+        })
+      ).output ?? {};
+    if (signal?.aborted)
+      return { output: {}, step: createCancelledStep(node, input, startedAt, clock) };
+    assertOutputPorts(node, output);
+    assertPortSchemas(node, output, 'output', schemas);
+    return { output, step: createSucceededStep(node, input, output, startedAt, clock) };
+  } catch (reason) {
+    const error = asFlowError(reason);
+    return {
+      output: {},
+      step: {
+        id: `${node.id}:1`,
+        nodeId: node.id,
+        status: 'failed',
+        attempt: 1,
+        startedAt,
+        completedAt: clock.now().toISOString(),
+        input,
+        error,
+      },
+    };
+  }
+};
+
+/*** Create an immutable successful step snapshot. */
+const createSucceededStep = (
+  node: FlowNode,
+  input: Readonly<Record<FlowPortId, FlowDataRef>>,
+  output: Readonly<Record<FlowPortId, FlowDataRef>>,
+  startedAt: string,
+  clock: FlowClock,
+): FlowStepSnapshot => ({
+  id: `${node.id}:1`,
+  nodeId: node.id,
+  status: 'succeeded',
+  attempt: 1,
+  startedAt,
+  completedAt: clock.now().toISOString(),
+  input,
+  output,
+});
+
+/*** Create a terminal snapshot when cancellation occurs during asynchronous node execution. */
+const createCancelledStep = (
+  node: FlowNode,
+  input: Readonly<Record<FlowPortId, FlowDataRef>>,
+  startedAt: string,
+  clock: FlowClock,
+): FlowStepSnapshot => ({
+  id: `${node.id}:1`,
+  nodeId: node.id,
+  status: 'cancelled',
+  attempt: 1,
+  startedAt,
+  completedAt: clock.now().toISOString(),
+  input,
+});
+
+/*** Reject operation outputs that do not correspond to declared output ports. */
+const assertOutputPorts = (
+  node: FlowNode,
+  output: Readonly<Record<FlowPortId, FlowDataRef>>,
+): void => {
+  const outputIds = new Set(
+    node.ports.filter((port) => port.direction === 'output').map(({ id }) => id),
+  );
+  if (Object.keys(output).some((portId) => !outputIds.has(portId)))
+    throw new Error(`FLOW_OUTPUT_UNDECLARED_PORT:${node.id}`);
+  const missingRequired = node.ports.some(
+    (port) => port.direction === 'output' && port.required && output[port.id] === undefined,
+  );
+  if (missingRequired) throw new Error(`FLOW_OUTPUT_REQUIRED_PORT_MISSING:${node.id}`);
+};
+
+/*** Validate inline port values against their declared portable schemas. */
+const assertPortSchemas = (
+  node: FlowNode,
+  values: Readonly<Record<FlowPortId, FlowDataRef>>,
+  direction: 'input' | 'output',
+  schemas: FlowRunRequest['schemaRegistry'],
+): void => {
+  for (const port of node.ports.filter((candidate) => candidate.direction === direction)) {
+    const value = values[port.id];
+    const schema =
+      port.data?.schema ?? (port.data?.schemaRef ? { ref: port.data.schemaRef } : undefined);
+    if (value?.kind === 'inline' && schema && !validateFlowDataSchema(value.value, schema, schemas))
+      throw new Error(`FLOW_PORT_SCHEMA_MISMATCH:${node.id}:${port.id}`);
+  }
+};
+
+/*** Propagate outputs only over edges whose declared condition matches the output value. */
+const propagateOutput = (
+  edges: readonly FlowEdge[],
+  output: Readonly<Record<FlowPortId, FlowDataRef>>,
+  outcome: 'failure' | 'success',
+  state: ExecutionState,
+): void => {
+  for (const edge of edges) {
+    const value = output[edge.source.portId];
+    if (!matchesEdge(edge, value, outcome)) continue;
+    state.activatedNodeIds.add(edge.target.nodeId);
+    if (value)
+      state.inputs[edge.target.nodeId] = {
+        ...state.inputs[edge.target.nodeId],
+        [edge.target.portId]: value,
+      };
+  }
+};
+
+/*** Evaluate an edge condition without executing arbitrary expressions. */
+const matchesEdge = (
+  edge: FlowEdge,
+  value: FlowDataRef | undefined,
+  outcome: 'failure' | 'success',
+): boolean => {
+  const condition = edge.condition ?? { kind: 'always' as const };
+  if (condition.kind === 'always') return outcome === 'success';
+  if (condition.kind === 'outcome') return condition.outcome === outcome;
+  if (value?.kind !== 'inline') return false;
+  const selected = resolvePointer(value.value, condition.path);
+  return selected !== undefined && structurallyEqual(selected, condition.equals);
+};
+
+/*** Resolve an RFC 6901 pointer against serializable inline data. */
+const resolvePointer = (
+  value: DataContractValue,
+  pointer: string,
+): DataContractValue | undefined => {
+  if (pointer === '') return value;
+  if (!pointer.startsWith('/')) return undefined;
+  return pointer
+    .slice(1)
+    .split('/')
+    .reduce<DataContractValue | undefined>((current, segment) => {
+      if (current === undefined || current === null || typeof current !== 'object')
+        return undefined;
+      const key = segment.replaceAll('~1', '/').replaceAll('~0', '~');
+      if (isDataArray(current)) return current.find((_item, index) => index === Number(key));
+      return isDataRecord(current)
+        ? Object.entries(current).find(([candidateKey]) => candidateKey === key)?.[1]
+        : undefined;
+    }, value);
+};
+
+/*** Compare JSON-compatible values with object-key-order independence. */
+const structurallyEqual = (left: DataContractValue, right: DataContractValue): boolean =>
+  JSON.stringify(normalizeValue(left)) === JSON.stringify(normalizeValue(right));
+
+/*** Canonicalize object member ordering for structural equality. */
+const normalizeValue = (value: DataContractValue): DataContractValue => {
+  if (Array.isArray(value)) return value.map(normalizeValue);
+  if (value !== null && typeof value === 'object')
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, normalizeValue(item)]),
+    );
+  return value;
+};
+
+/*** Narrow a serializable non-array object to an indexable data record. */
+const isDataRecord = (value: object): value is Readonly<Record<string, DataContractValue>> =>
+  !Array.isArray(value);
+
+/*** Narrow a serializable array without losing its element type. */
+const isDataArray = (value: object): value is readonly DataContractValue[] => Array.isArray(value);
+
+/*** Translate host failures to structured contract errors without exposing arbitrary objects. */
+const asFlowError = (reason: unknown): FlowError => ({
+  code:
+    reason instanceof Error && /^FLOW_[A-Z0-9_]+(?::|$)/.test(reason.message)
+      ? (reason.message.split(':')[0] ?? 'FLOW_OPERATION_FAILED')
+      : 'FLOW_OPERATION_FAILED',
+  message: 'The operation failed.',
+  retryable: false,
+});
+
+/*** Build the immutable run result emitted by the single-process executor. */
+const createRun = (
+  graph: FlowCompiledGraph,
+  request: FlowRunRequest,
+  steps: readonly FlowStepSnapshot[],
+  startedAt: string,
+  completedAt: string,
+  status: FlowRunSnapshot['status'],
+  error?: FlowError,
+): FlowRunSnapshot => ({
+  id: request.runId,
+  flow: { id: graph.definition.id, version: graph.definition.version },
+  status,
+  trigger: { triggerId: request.triggerId, kind: 'manual' },
+  createdAt: startedAt,
+  startedAt,
+  completedAt,
+  steps,
+  error,
+});

package/src/features/execution/domain/assertFlowGraphSchemasSupported.ts

@@ -0,0 +1,17 @@
+import type { DataSchemaRegistry } from '@ankhorage/contracts/data';
+import type { FlowNode } from '@ankhorage/contracts/flow';
+
+import { assertFlowDataSchemaSupported } from './validateFlowDataSchema.js';
+
+/*** Validate every declared graph port schema before any operation can perform a side effect. */
+export const assertFlowGraphSchemasSupported = (
+  nodes: readonly FlowNode[],
+  schemas: DataSchemaRegistry | undefined,
+): void => {
+  for (const node of nodes)
+    for (const port of node.ports) {
+      const schema =
+        port.data?.schema ?? (port.data?.schemaRef ? { ref: port.data.schemaRef } : undefined);
+      if (schema) assertFlowDataSchemaSupported(schema, schemas);
+    }
+};