@ixo/editor 6.21.0 → 6.23.0

package/dist/core/index.d.ts

@@ -1,10 +1,10 @@
-import { a5 as ActionDefinition, a6 as ActionEventDefinition, a7 as OutputSchemaField, a8 as ActionServices, a9 as ActionProofDeclaration, aa as RunRecordDetails, ab as CompiledBlock, v as CompiledFlow, ac as CompiledEdge, Z as FlowAgentCommand, $ as FlowAgentContext, ad as ActionHandlers, _ as FlowAgentCommandResult, a0 as FlowAgentExecutor, a2 as FlowAgentNodeSnapshot, ae as FlowAgentBlockerCause, a3 as FlowAgentPublicNodeState } from '../store-Ba-HGtSG.js';
-export { aP as AcquireFlowAgentLeaseParams, ag as ActionContext, at as ActionResult, b1 as ActorConstraint, A as AuthorizationResult, B as BaseUcanFlow, ak as BidService, X as BuildFlowAgentContextParams, ar as CarbonService, al as ClaimService, am as CollectionService, an as CollectionUsersService, b4 as CompiledFlowNode, C as CompilerRegistry, b0 as ConditionRef, aQ as CreateAgentCommandParams, ai as EmailService, as as EntityService, aR as EvaluateFlowAgentPolicyParams, E as ExecuteNodeParams, f as ExecutionContext, d as ExecutionOutcome, aH as FailedListenerRun, Y as FlowAgentActor, aU as FlowAgentCommandBase, aV as FlowAgentCommandStatus, aW as FlowAgentCommandType, a1 as FlowAgentLease, aX as FlowAgentLedgerEvent, aY as FlowAgentLedgerEventType, aZ as FlowAgentMaps, aS as FlowAgentOrchestratorOptions, a_ as FlowAgentPolicyDecision, a$ as FlowAgentRunPhase, x as FlowAgentService, aT as FlowAgentServiceOptions, a4 as FlowAgentTickResult, u as FlowCapability, F as FlowRuntimeStateManager, w as FlowStrategy, ah as HttpService, ap as IntegrationsService, ao as MatrixCredentialService, M as MergeResult, N as NodeActionResult, aj as NotifyService, aq as OracleService, aG as PendingInvocation, aF as RUN_RECORD_AUDIT_TYPE, R as ReadFlowOptions, q as ReadFlowResult, b3 as RuntimeRef, S as SetupFlowOptions, p as SetupFlowResult, b2 as TTLConstraint, b5 as TriggerSpec, y as acquireFlowAgentLease, z as appendAgentLedgerEvent, au as appendRunRecord, a as buildAuthzFromProps, D as buildFlowAgentContext, b as buildFlowNodeFromBlock, aI as canMatches, G as cleanupExpiredFlowAgentLeases, af as clearRuntimeForTemplateClone, l as compileBaseUcanFlow, aJ as computeAgentCommandId, aE as computePendingInvocationId, H as createAgentCommand, c as createRuntimeStateManager, o as decompileToBaseUcanFlow, I as evaluateFlowAgentPolicy, e as executeNode, J as executeQueuedAgentCommands, aB as findFailedListenersForSourceRun, k as getActiveEditor, K as getFlowAgentMaps, ax as getOrCreateBlockPendingMap, aw as getPendingInvocationsMap, i as isAuthorized, aK as isCapabilityMatch, aL as isExternalMutation, b6 as isRuntimeRef, n as mergeCompiledFlows, L as planRalphLoopCommands, O as queueAgentCommand, az as queuePendingInvocation, P as readAgentLedgerEvents, m as readCompiledFlowFromYDoc, h as readFlow, r as readFlowAsBaseUcan, g as readFlowFromEditor, ay as readPendingInvocations, Q as readQueuedAgentCommands, av as readRunRecords, T as releaseFlowAgentLease, aA as removePendingInvocation, aC as replayFailedListenerRun, aM as requiredCapabilityForCommand, aN as resourceMatches, j as setActiveEditor, s as setupFlowFromBaseUcan, aD as snapshotInputRefs, U as tickFlowAgent, aO as updateAgentCommand, V as validateAgentCommand, W as validateFlowAgentLease } from '../store-Ba-HGtSG.js';
-import { a4 as FlowNodeRuntimeState, j as StoredInvocation, a5 as IxoEditorType, f as UcanService, U as UcanDelegationStore, S as StoredDelegation, I as InvocationStore, a6 as FlowMetadata, a7 as FlowNode } from '../index-BC4ycOwH.js';
-export { ag as ActionReadBackMetadata, a9 as ClaimCollectionURI, an as CreateDelegationParams, ao as CreateInvocationParams, am as CreateRootDelegationParams, a8 as DID, D as DelegationChainValidationResult, k as DelegationGrant, aa as EvaluationStatus, ak as ExecutionWithInvocationResult, al as FindProofsResult, ac as FlowNodeAuthzExtension, ah as FlowNodeBase, ai as InvocationRequest, aj as InvocationResult, ab as LinkedClaim, ad as NodeServiceReport, ae as NodeState, af as ReadBackTerminalState, i as UcanCapability, g as UcanServiceConfig, h as UcanServiceHandlers, b as createInvocationStore, d as createMemoryInvocationStore, a as createMemoryUcanDelegationStore, c as createUcanDelegationStore, e as createUcanService } from '../index-BC4ycOwH.js';
-export { b as NODE_CONTEXT_MAP_NAME, c as NODE_CONTEXT_OVERRIDES_MAP_NAME, a as NodeContextFieldProvenance, N as NodeContextRecord, i as isNodeContextRecord } from '../nodeContext-C-BsYuYi.js';
+import { an as CompiledBlock, W as CompiledFlow, ao as CompiledEdge, af as FlowAgentCommand, ah as FlowAgentContext, ag as FlowAgentCommandResult, ai as FlowAgentExecutor, ak as FlowAgentNodeSnapshot, ap as FlowAgentBlockerCause, al as FlowAgentPublicNodeState, Q as FlowConnectionBinding } from '../store-B60v3oba.js';
+export { aH as AcquireFlowAgentLeaseParams, as as ActionBlockLike, at as ActionExecutionCompletionState, aX as ActorConstraint, A as AuthorizationResult, U as BaseUcanFlow, au as BuildActionRunInputsParams, av as BuildActionRunInputsResult, ad as BuildFlowAgentContextParams, a_ as CompiledFlowNode, L as CompilerRegistry, aW as ConditionRef, aI as CreateAgentCommandParams, aJ as EvaluateFlowAgentPolicyParams, aw as ExecuteActionBlockParams, ax as ExecuteActionBlockResult, E as ExecuteNodeParams, d as ExecutionContext, c as ExecutionOutcome, G as FLOW_CONNECTIONS_MAP_KEY, H as FLOW_CONNECTION_BINDINGS_MAP_KEY, F as FLOW_PARTICIPANTS_MAP_KEY, ae as FlowAgentActor, aM as FlowAgentCommandBase, aN as FlowAgentCommandStatus, aO as FlowAgentCommandType, aj as FlowAgentLease, aP as FlowAgentLedgerEvent, aQ as FlowAgentLedgerEventType, aR as FlowAgentMaps, aK as FlowAgentOrchestratorOptions, aS as FlowAgentPolicyDecision, aT as FlowAgentRunPhase, Y as FlowAgentService, aL as FlowAgentServiceOptions, am as FlowAgentTickResult, V as FlowCapability, P as FlowConnection, T as FlowConnectionRequirementKey, O as FlowParticipant, X as FlowStrategy, M as MergeResult, N as NodeActionResult, R as ReadFlowOptions, J as ReadFlowResult, aZ as RuntimeRef, S as SetupFlowOptions, I as SetupFlowResult, aY as TTLConstraint, aV as TriggerResolutionContext, a$ as TriggerSpec, Z as acquireFlowAgentLease, _ as appendAgentLedgerEvent, aq as buildActionRunInputs, a as buildAuthzFromProps, $ as buildFlowAgentContext, b as buildFlowNodeFromBlock, ay as canMatches, a0 as cleanupExpiredFlowAgentLeases, k as compileBaseUcanFlow, az as computeAgentCommandId, a1 as createAgentCommand, n as decompileToBaseUcanFlow, a2 as evaluateFlowAgentPolicy, ar as executeActionBlock, e as executeNode, a3 as executeQueuedAgentCommands, j as getActiveEditor, a4 as getFlowAgentMaps, i as isAuthorized, aA as isCapabilityMatch, aB as isExternalMutation, b0 as isRuntimeRef, m as mergeCompiledFlows, a5 as planRalphLoopCommands, a6 as queueAgentCommand, aC as readAgentCommands, a7 as readAgentLedgerEvents, l as readCompiledFlowFromYDoc, g as readFlow, aD as readFlowAgentLeases, r as readFlowAsBaseUcan, B as readFlowConnectionBindings, v as readFlowConnections, f as readFlowFromEditor, o as readFlowParticipants, a8 as readQueuedAgentCommands, a9 as releaseFlowAgentLease, x as removeFlowConnection, D as removeFlowConnectionBinding, p as removeFlowParticipant, aE as requiredCapabilityForCommand, aU as resolveRuntimeRefs, aF as resourceMatches, h as setActiveEditor, y as setFlowConnectionOptional, z as setFlowConnectionRequires, q as setFlowParticipantPowerLevel, t as setFlowParticipantRequirements, s as setupFlowFromBaseUcan, aa as tickFlowAgent, aG as updateAgentCommand, w as upsertFlowConnection, C as upsertFlowConnectionBinding, u as upsertFlowParticipant, ab as validateAgentCommand, ac as validateFlowAgentLease } from '../store-B60v3oba.js';
+import { af as ActionDefinition, ap as ActionDoneContract, aq as ActionEventDefinition, ar as OutputSchemaField, ab as ActionServices, ag as FlowNodeRuntimeState, ad as RunEventAppender, as as RunEventInput, F as FlowRuntimeStateManager, at as RunJsonValue, au as ActionRunContext, av as CompletionCheck, k as StoredInvocation, aa as PendingInvocation, aw as ActionReadBackMetadata, a9 as IxoEditorType, ax as ReadBackTerminalState, ae as ActionResult, ay as ActionProofDeclaration, az as RunRecordDetails, g as UcanService, ac as ActionHandlers, U as UcanDelegationStore, S as StoredDelegation, I as InvocationStore, aA as FlowMetadata, a6 as FlowNode } from '../index-x1R0c9P_.js';
+export { bV as ActionContext, bD as ActionRunEventInput, bZ as BidService, bB as CancelRunParams, c4 as CarbonService, cm as ClaimCollectionURI, b_ as ClaimService, bC as CloseRunParams, b$ as CollectionService, c0 as CollectionUsersService, cw as CreateDelegationParams, cx as CreateInvocationParams, cv as CreateRootDelegationParams, cl as DID, D as DelegationChainValidationResult, l as DelegationGrant, bX as EmailService, c5 as EntityService, a8 as EvaluationStatus, ct as ExecutionWithInvocationResult, ba as ExplicitRunRequiredError, ck as FailedListenerRun, cu as FindProofsResult, bE as FinishRunResult, a7 as FlowNodeAuthzExtension, cq as FlowNodeBase, bx as FlowNotMigratedError, c6 as FlowRunLifecycleService, bW as HttpService, c2 as IntegrationsService, cr as InvocationRequest, cs as InvocationResult, aD as LEGACY_RUN_STORAGE_VERSION, bH as LifecycleRunEventInput, cn as LinkedClaim, aE as MULTI_RUN_STORAGE_VERSION, c1 as MatrixCredentialService, bF as MigrateFlowParams, bG as MigrateFlowResult, be as MultiRunMigrationResult, co as NodeServiceReport, cp as NodeState, bY as NotifyService, c3 as OracleService, aF as RUNS_TERMINAL_MAP_KEY, cj as RUN_RECORD_AUDIT_TYPE, aG as RUN_STORAGE_VERSION_KEY, bI as RunDefinitionBlock, bJ as RunDefinitionDrift, bK as RunDefinitionSnapshot, bL as RunJsonObject, bN as RunLifecycleAuthorizationDecision, by as RunLifecycleAuthorizationError, bO as RunLifecycleAuthorizationRequest, bP as RunLifecycleAuthorizer, bQ as RunLifecycleCapability, bM as RunLogEventInput, bR as RunManifest, bd as RunMeta, bz as RunNotMigratedError, bA as RunNotReadyError, bS as RunSnapshot, bf as RunStorageVersion, bg as RunTerminalRecord, bT as StartRunParams, bU as StartRunResult, bb as TerminalRunExecutionError, j as UcanCapability, h as UcanServiceConfig, i as UcanServiceHandlers, bc as UnknownRunError, aH as adoptLegacyRuntime, c7 as appendRunRecord, a$ as assertRunActionExecutionAllowed, bh as buildRunDefinitionSnapshot, bi as cancelRun, aI as clearAllActionState, aC as clearRuntimeForTemplateClone, bj as closeRun, aJ as collectPhantomLegacyRun, ci as computePendingInvocationId, bk as computeRunDefinitionHash, bl as computeRunSummary, ca as countPendingInvocations, d as createInvocationStore, e as createMemoryInvocationStore, b as createMemoryUcanDelegationStore, bm as createRunId, aK as createRunRuntimeReader, aL as createRunRuntimeReaderWithDoc, aM as createRunScopedRuntimeManager, bn as createRunUlid, c as createRuntimeStateManager, a as createUcanDelegationStore, f as createUcanService, aB as createYDocRuntimeManager, aN as deleteActionState, bo as detectRunDefinitionDrift, aO as enableMultiRunStorage, aP as ensureRun, cf as findFailedListenersForSourceRun, cb as getOrCreateBlockPendingMap, c9 as getPendingInvocationsMap, aQ as getRunActionsMap, aR as getRunMeta, aU as getRunStorageVersion, aS as getRunsMap, aT as getRunsTerminalMap, aV as hasLegacyRuntimeHistory, b0 as isBelowTheLineBlock, aW as isLegacyRuntimeAdoptionEnabled, aX as isRecordInRun, bp as listOpenRuns, bq as listRuns, br as migrateFlowToSessions, cd as queuePendingInvocation, aY as readActionState, aZ as readActionStates, cc as readPendingInvocations, bs as readRunActionStates, c8 as readRunRecords, bt as recordRunDefinitionDrift, ce as removePendingInvocation, cg as replayFailedListenerRun, a_ as resetActionState, b1 as resolveActiveRunId, b2 as resolveRecordRunId, b3 as resolveRunIdForExecution, b4 as resolveRunIdForRead, b5 as seedRunFromLegacyRuntime, bu as setAdvisoryActiveRunId, b6 as setMultiRunStorage, ch as snapshotInputRefs, bv as startRun, b7 as subscribeToActionState, bw as toRunJsonValue, b8 as usesLegacyRuntimeCompatibility, b9 as writeActionState } from '../index-x1R0c9P_.js';
 import * as Y from 'yjs';
 import { Doc, Map } from 'yjs';
+export { b as NODE_CONTEXT_MAP_NAME, c as NODE_CONTEXT_OVERRIDES_MAP_NAME, a as NodeContextFieldProvenance, N as NodeContextRecord, i as isNodeContextRecord } from '../nodeContext-C-BsYuYi.js';
 import 'matrix-js-sdk';
 import '@blocknote/core';
 import 'react';
@@ -20,6 +20,28 @@ declare const STEP_COMPLETED_EVENT_NAME = "step.completed";
  *  - every completion is auditable (a run record is always written).
  */
 declare const STEP_COMPLETED_EVENT: ActionEventDefinition;
+/**
+ * The default Done contract: a one-shot step is Done once its run reached
+ * `completed`.
+ *
+ * The fold reads only the run state because proof of execution is enforced
+ * where the completion is *written* — `executeActionBlock` records a success
+ * that lacks the action's declared proof as `failed` (`PROOF_MISSING`) — and
+ * re-checked at the trust boundary by `verifyCompletion`, which is what
+ * trigger reconciliation, flow-agent planning and the completion badge gate on.
+ *
+ * Actions whose Done-ness is not simply the run state — it depends on an
+ * output field, a quota, or an external system — declare their own contract
+ * instead (see `qi/kyc.verify`).
+ */
+declare const doneWhenCompleted: ActionDoneContract;
+/**
+ * Done contract for repeatable capabilities (`cardinality: 'many'`): a
+ * standing block fires as often as the flow decides and never latches to a
+ * terminal Done, so its fold is always false. Real progress for these blocks
+ * is the count of successful runs in the audit trail, not the summary entry.
+ */
+declare const neverDone: ActionDoneContract;
 declare function registerAction<TInputs extends Record<string, any> = Record<string, any>>(definition: ActionDefinition<TInputs>): void;
 declare function getAction(type: string): ActionDefinition | undefined;
 declare function getAllActions(): ActionDefinition[];
@@ -62,6 +84,19 @@ type ManifestProofDeclaration = {
 } | {
     kind: 'custom';
 };
+interface ManifestDoneDeclaration {
+    /**
+     * `default` = one of the two shared standard contracts — a one-shot action
+     * is Done when its run reached `completed`, a repeatable one never latches
+     * (read `cardinality` to tell which applies). `custom` = the action defines
+     * its own predicate, which (like a custom proof) can't cross the JSON
+     * boundary; ask for an external check or run in-process to evaluate it.
+     */
+    kind: 'default' | 'custom';
+    /** Whether an external actor can request a side-effect-free truth check. */
+    hasExternalCheck: boolean;
+    cardinality: 'once' | 'many';
+}
 interface ActionManifestEntry {
     type: string;
     /** Legacy names that resolve to this canonical type. */
@@ -71,6 +106,7 @@ interface ActionManifestEntry {
     defaultRequiresConfirmation: boolean;
     requiredCapability?: string;
     proof: ManifestProofDeclaration;
+    done: ManifestDoneDeclaration;
     /** JSON Schema for the action's inputs, when declared. */
     inputSchema?: object;
     /** Static output schema. Actions with dynamic schemas also set hasDynamicOutputSchema. */
@@ -214,46 +250,281 @@ declare function parseServiceCan(value: string): {
 
 declare function buildServicesFromHandlers(handlers: any): ActionServices;
 
+type ConditionOperator = 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains' | 'not_contains' | 'is_empty' | 'is_not_empty';
+interface BlockCondition {
+    id: string;
+    name: string;
+    description?: string;
+    sourceBlockId: string;
+    sourceBlockType: string;
+    rule: {
+        type: 'property_value';
+        property: string;
+        operator: ConditionOperator;
+        value: string | number | boolean;
+    };
+    effect: {
+        action: 'enable' | 'disable' | 'hide' | 'show';
+        message?: string;
+    };
+}
+interface ConditionConfig {
+    enabled: boolean;
+    mode: 'all_must_pass' | 'any_can_pass';
+    conditions: BlockCondition[];
+}
+interface ConditionEvaluationResult {
+    passes: boolean;
+    message?: string;
+}
+interface ConditionActionResult {
+    action: 'enable' | 'disable' | 'hide' | 'show';
+    message?: string;
+    conditionName: string;
+}
+interface BlockConditionsResult {
+    actions: ConditionActionResult[];
+}
+interface BlockExecutionEligibility {
+    eligible: boolean;
+    enabled: boolean;
+    visible: boolean;
+    message?: string;
+    result: BlockConditionsResult;
+}
+interface ConditionEvaluationOptions {
+    getRuntimeState?: (blockId: string) => FlowNodeRuntimeState | undefined;
+    /**
+     * Phase A only: fall back to authored props when no run output exists.
+     * Multi-run documents deliberately disable this so execution results never
+     * leak through shared definition props.
+     */
+    allowPropsFallback?: boolean;
+}
+declare function normalizeCondition(condition: BlockCondition): BlockCondition;
+declare function normalizeConditions(conditions: BlockCondition[]): BlockCondition[];
+declare function parseConditionConfig(value: unknown): ConditionConfig;
+declare class InvalidConditionConfigError extends Error {
+    constructor(message: string);
+}
+/** Fail-closed parser for execution/planning boundaries. */
+declare function parseConditionConfigStrict(value: unknown): ConditionConfig;
+declare function resolveConditionSourceValue(condition: BlockCondition, sourceBlock: unknown, options?: ConditionEvaluationOptions): unknown;
+declare function evaluateCondition(condition: BlockCondition, sourceBlock: unknown, options?: ConditionEvaluationOptions): ConditionEvaluationResult;
+declare function evaluateBlockConditions(conditionConfig: ConditionConfig, editorDocument: unknown[], options?: ConditionEvaluationOptions): BlockConditionsResult;
+/** Canonical run-aware evaluator used by browser and headless consumers. */
+declare function evaluateBlockConditionsForRun(conditionConfig: ConditionConfig, editorDocument: unknown[], yDoc: Y.Doc, sessionRunId: string): BlockConditionsResult;
+/**
+ * Canonical decision used immediately before execution and by planners. The
+ * condition vocabulary is positive after normalization: if an authored
+ * enable/show gate exists, at least one corresponding action must fire.
+ */
+declare function evaluateBlockExecutionEligibilityForRun(conditionConfig: ConditionConfig, editorDocument: unknown[], yDoc: Y.Doc, sessionRunId: string): BlockExecutionEligibility;
+
 /**
- * Context passed to resolveRuntimeRefs when resolving inputs for a triggered
- * listener block. The runtime constructs this from a PendingInvocation when
- * the assignee invokes the listener.
+ * A run head must stay small enough to replicate cheaply. Full action history
+ * belongs in Matrix; the Y.Doc keeps only the latest referenceable output.
  *
- * - `payload`: the frozen event payload, used to resolve `trigger.payload.*` refs
- * - `refSnapshots`: frozen `nodeId.output.*` values captured at queue time,
- *   used to resolve those refs against the moment of emission rather than
- *   current state. See docs/flow-engine/events-and-triggers-plan.md §3.5.1 for the
- *   Sally → Mike scenario this fixes.
+ * 16 KiB leaves ample room for the run-event envelope under Matrix's 64 KiB
+ * event limit and bounds ten runs independently of retry/history volume.
  */
-interface TriggerResolutionContext {
-    payload: Record<string, unknown>;
-    refSnapshots: Record<string, unknown>;
+declare const MAX_RUN_ACTION_OUTPUT_BYTES: number;
+interface BoundedRunOutput {
+    output: Record<string, unknown>;
+    byteLength: number;
+    exceeded: boolean;
+}
+interface PendingRunTimelineEvent {
+    event: RunEventInput;
+    failedAt: number;
+    error: string;
+}
+interface RunTimelineAppendResult {
+    ok: boolean;
+    eventId?: string;
+    error?: string;
 }
+/** Stable, bounded, Matrix-safe key. Raw block/run ids never enter the key. */
+declare function createRunEventIdempotencyKey(kind: RunEventInput['kind'], ...identity: Array<string | number>): string;
+/**
+ * Prepare the value allowed into the Y.Doc. Oversized output is represented by
+ * a bounded marker; callers must route the action to needs-verification rather
+ * than pretending downstream references still have the complete value.
+ */
+declare function boundRunActionOutput(value: Record<string, unknown>): BoundedRunOutput;
+/**
+ * Append one canonical run event. Post-effect failures can be retained for
+ * replay; preflight failures pass retainOnFailure=false and abort execution.
+ */
+declare function appendRunTimelineEvent(params: {
+    eventLog?: RunEventAppender;
+    event: RunEventInput;
+    runtime?: FlowRuntimeStateManager;
+    blockId?: string;
+    retainOnFailure?: boolean;
+    now?: () => number;
+}): Promise<RunTimelineAppendResult>;
+/**
+ * Append an ordered event sequence. If one append fails, it and every event
+ * after it are retained in order so recovery cannot publish `action.done`
+ * ahead of the missing `action.output`.
+ */
+declare function appendRunTimelineEvents(params: {
+    eventLog?: RunEventAppender;
+    events: RunEventInput[];
+    runtime: FlowRuntimeStateManager;
+    blockId: string;
+    retainOnFailure?: boolean;
+    now?: () => number;
+}): Promise<{
+    ok: boolean;
+    appended: number;
+    remaining: number;
+    lastEventId?: string;
+    error?: string;
+}>;
+/** Pure read used by status/recovery surfaces. */
+declare function readPendingRunTimelineEvents(yDoc: Y.Doc, sessionRunId: string, blockId: string): PendingRunTimelineEvent[];
+/** Replay retained post-effect events in original order and clear successes. */
+declare function retryPendingRunTimelineEvents(params: {
+    yDoc: Y.Doc;
+    sessionRunId: string;
+    blockId: string;
+    eventLog: RunEventAppender;
+    now?: () => number;
+}): Promise<{
+    attempted: number;
+    remaining: number;
+    lastEventId?: string;
+}>;
+/**
+ * Bound arbitrary JSON before embedding it in an event. Inputs are diagnostic,
+ * not authoritative; oversized values become the same compact marker.
+ */
+declare function boundRunEventJson(value: unknown): RunJsonValue;
+
 /**
- * Resolve runtime references in an nb (caveats) object.
+ * Fold a run entry to Done using the action's own completion contract.
  *
- * At compile time, `{ "$ref": "nodeId.output.fieldPath" }` values are serialized
- * as-is into the block's `inputs` JSON string. At execution time, this function
- * replaces them with actual output values from upstream nodes.
+ * There is no fallback branch: every registered action declares `done` (the
+ * registry backfills the default for untyped consumers), so the contract is
+ * the single place Done-ness is decided. One-shot actions typically use
+ * `doneWhenCompleted`, repeatable ones `neverDone`.
+ */
+declare function isActionDone<TInputs extends Record<string, any> = Record<string, any>>(action: ActionDefinition<TInputs> | undefined, actionState: FlowNodeRuntimeState, runContext: ActionRunContext): boolean;
+declare function isActionTypeDone(actionType: string | undefined, actionState: FlowNodeRuntimeState, runContext: ActionRunContext): boolean;
+type CompletionReconciliationTransition = 'unchanged' | 'adopted' | 'needs_verification' | 'unknown';
+interface ReconcileCompletionParams<TInputs extends Record<string, any> = Record<string, any>> {
+    yDoc: Y.Doc;
+    sessionRunId: string;
+    blockId: string;
+    actionType: string;
+    inputs: TInputs;
+    flowId?: string;
+    flowUri?: string;
+    actorDid?: string;
+    services?: ActionRunContext['services'];
+    now?: () => number;
+}
+interface ReconcileCompletionResult {
+    transition: CompletionReconciliationTransition;
+    check: CompletionCheck;
+    previous: FlowNodeRuntimeState;
+    next: FlowNodeRuntimeState;
+}
+/**
+ * Reconcile a run entry against an action's pure/external completion contract.
  *
- * Two ref namespaces are supported:
- *  - `nodeId.output.fieldPath` — looked up via `getNodeOutput`. When a
- *    `triggerContext` is provided AND `refSnapshots[ref]` exists, the
- *    snapshot is preferred over the live lookup. This is the load-bearing
- *    fix for the lag-time scenario where multiple pending invocations are
- *    queued and the source block re-runs before the assignee acts on them.
- *  - `trigger.payload.fieldPath` — looked up in `triggerContext.payload`.
- *    Only valid when `triggerContext` is provided (i.e. resolving inputs
- *    for a triggered listener invocation). Compile-time validation in
- *    compiler.ts guarantees these only appear on `block.event`-triggered
- *    blocks.
+ * `check` is an explicit read: it must not execute the action or mutate the
+ * external system. Unknown results are inert. A positive read can adopt work
+ * completed outside this client; a negative read never retries an action and
+ * instead moves a contradictory completed entry to human verification.
+ */
+declare function reconcileCompletion<TInputs extends Record<string, any> = Record<string, any>>(params: ReconcileCompletionParams<TInputs>): Promise<ReconcileCompletionResult>;
+
+declare const INVOCATIONS_MAP_KEY = "invocations";
+/**
+ * Read UCAN invocation history for exactly one session run.
  *
- * @param nb - The caveats object (may contain nested RuntimeRef values)
- * @param getNodeOutput - Lookup function for upstream node outputs
- * @param triggerContext - Optional, present only for triggered listener invocations
- * @returns A new object with all $ref values resolved
+ * Records written before sessions existed carry no `sessionRunId` and belong to
+ * the unsessioned document until it is migrated — see {@link isRecordInRun}.
+ * The lookup uses `Doc.share` so inspecting a room with no invocation history
+ * does not create an empty shared map.
  */
-declare function resolveRuntimeRefs(nb: Record<string, unknown>, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined, triggerContext?: TriggerResolutionContext): Record<string, unknown>;
+declare function readInvocationsForRun(yDoc: Y.Doc, sessionRunId: string): StoredInvocation[];
+
+type EditorOrYDoc = IxoEditorType | Y.Doc;
+interface NormalizeReadBackMetadataParams {
+    readBack?: Record<string, unknown>;
+    blockId: string;
+    actionType: string;
+    actorDid: string;
+    invocationCid?: string;
+    capabilityId?: string;
+    requestedAt: number;
+    pendingInvocation?: PendingInvocation;
+}
+interface ActionReadBackResolution {
+    state: ReadBackTerminalState;
+    output?: Record<string, unknown>;
+    events?: NonNullable<ActionResult['events']>;
+    readBack?: Record<string, unknown>;
+    error?: string | {
+        message: string;
+        code?: string;
+    };
+}
+interface ActionReadBackResolverInput {
+    blockId: string;
+    runtime: FlowNodeRuntimeState;
+    output: Record<string, unknown>;
+    readBack: ActionReadBackMetadata;
+}
+type ActionReadBackResolver = (input: ActionReadBackResolverInput) => ActionReadBackResolution | Promise<ActionReadBackResolution>;
+interface ReconcileActionReadBackParams {
+    editorOrYDoc?: EditorOrYDoc | null;
+    blockId: string;
+    actorDid?: string;
+    runtime?: FlowRuntimeStateManager;
+    document?: Array<{
+        id?: string;
+        props?: Record<string, unknown>;
+    }>;
+    resolver?: ActionReadBackResolver;
+    resolvers?: Record<string, ActionReadBackResolver>;
+    runEventLog?: RunEventAppender;
+    now?: () => number;
+    /**
+     * The **session run** (`runs.ts`) this reconciliation writes into — not the
+     * per-execution audit id. Multi-run documents require this explicitly; only
+     * legacy documents retain the advisory active-run fallback.
+     *
+     * D2: every new parameter named `runId` means the session run.
+     */
+    runId?: string;
+}
+interface ReconcileActionReadBackResult {
+    success: boolean;
+    blockId: string;
+    state: ReadBackTerminalState;
+    output?: Record<string, unknown>;
+    events: NonNullable<ActionResult['events']>;
+    error?: string;
+    /**
+     * Id of the audit record this reconciliation wrote (`readback-<ts>-<rand>`).
+     *
+     * @deprecated Use {@link ReconcileActionReadBackResult.executionId}; both
+     * carry the same value. The persisted `RunRecordDetails.runId` is never
+     * renamed (D2).
+     */
+    runId?: string;
+    /** Forward name for the per-execution audit id. Identical to {@link runId}. */
+    executionId?: string;
+    pendingInvocationRemoved: boolean;
+    readBack?: ActionReadBackMetadata;
+}
+declare function normalizeActionReadBackMetadata(params: NormalizeReadBackMetadataParams): ActionReadBackMetadata;
+declare function reconcileActionReadBack(params: ReconcileActionReadBackParams): Promise<ReconcileActionReadBackResult>;
 
 declare const PROOF_MISSING_CODE = "PROOF_MISSING";
 interface ProofValidationResult {
@@ -318,7 +589,130 @@ interface VerifyCompletionParams {
 declare function verifyCompletion(params: VerifyCompletionParams): CompletionVerification;
 declare function isVerifiedCompletion(params: VerifyCompletionParams): boolean;
 
-declare function reconcilePendingInvocations(editor: IxoEditorType): void;
+/**
+ * Reference Resolver — the single engine for `{{blockId.propPath}}` string
+ * references.
+ *
+ * Handles resolution of block property references in the format:
+ * {{blockId.propKey}} or {{blockId.nestedProp.key}}
+ *
+ * Example:
+ * Input: "User email: {{user-block-123.email}}"
+ * Output: "User email: john@example.com"
+ *
+ * This lives in core (framework-free) so both the React layer
+ * (`src/mantine/utils/referenceResolver.ts` re-exports it) and headless
+ * consumers share one implementation. The structured `{ $ref }` resolver
+ * (`flowCompiler/resolveRefs.ts`) is a separate data model that shares
+ * `getNestedValue` from here.
+ *
+ * Behavioral contract (things consumers depend on — do not change):
+ * - Unresolved references become `fallback` (default `''`); every
+ *   FlowDetail `inputsReady` gate relies on empty-string-when-unresolved.
+ * - Objects stringify by default (`stringifyObjects: true`).
+ * - `:` is allowed in property paths (JSON-LD field names).
+ * - `output.*` paths fall back to `output.data.*` and legacy
+ *   `output.http.data.*`.
+ */
+/**
+ * Represents a parsed reference from a string
+ */
+interface ParsedReference {
+    /** Full reference string including delimiters: {{blockId.propKey}} */
+    fullMatch: string;
+    /** Block ID portion */
+    blockId: string;
+    /** Property path (can be nested): propKey or nested.prop.key */
+    propPath: string;
+    /** Start index in the original string */
+    startIndex: number;
+    /** End index in the original string */
+    endIndex: number;
+}
+/**
+ * Parse all references from a string
+ */
+declare function parseReferences(input: string): ParsedReference[];
+/**
+ * Get a nested property value from an object using dot notation.
+ * Shared by the `{{...}}` resolver, the structured `$ref` resolver, and
+ * ref snapshotting — keep the loose `current?.[key]` semantics.
+ */
+declare function getNestedValue(obj: any, path: string): any;
+type UnresolvedReferenceReason = 'unknown-block' | 'missing-value' | 'response-parse-error';
+interface UnresolvedReference {
+    /** The full `{{...}}` reference text. */
+    ref: string;
+    blockId: string;
+    propPath: string;
+    reason: UnresolvedReferenceReason;
+}
+/**
+ * Resolve a single reference by finding the block and extracting the property value
+ */
+declare function resolveSingleReference(blockId: string, propPath: string, editorDocument: any[], yRuntime?: any, scope?: Record<string, any>): any;
+interface ResolveReferencesOptions {
+    /** String to use when a reference cannot be resolved */
+    fallback?: string;
+    /** Whether to return objects as JSON strings */
+    stringifyObjects?: boolean;
+    /** Yjs runtime map for resolving action block output paths */
+    yRuntime?: any;
+    /**
+     * Local scope bindings for iterative contexts. When provided, a reference
+     * like `{{item.foo}}` resolves against `scope.item.foo` before falling
+     * back to editor blocks. Use this in iterative mappers (e.g. Xero
+     * invoice LineItems iterative mode).
+     */
+    scope?: Record<string, any>;
+    /**
+     * Diagnostic context: when set, unresolved references are logged once per
+     * (context, ref). Pass the consuming block's id so a typo'd reference is
+     * visible in the console instead of silently becoming ''.
+     */
+    warnContext?: string;
+}
+interface DetailedResolution {
+    value: string;
+    /** References that resolved to the fallback, with the reason. */
+    unresolved: UnresolvedReference[];
+}
+/**
+ * Resolve all references in a string, returning the resolved string plus
+ * structured diagnostics for every reference that fell back.
+ */
+declare function resolveReferencesDetailed(input: string | null | undefined, editorDocument: any[], options?: ResolveReferencesOptions): DetailedResolution;
+/**
+ * Resolve all references in a string and return the resolved string
+ */
+declare function resolveReferences(input: string | null | undefined, editorDocument: any[], options?: ResolveReferencesOptions): string;
+/**
+ * Check if a string contains any references
+ */
+declare function hasReferences(input: string | null | undefined): boolean;
+/**
+ * Create a reference string for a block property
+ */
+declare function createReference(blockId: string, propPath: string): string;
+/**
+ * Resolve references in an object's values recursively
+ * Useful for resolving references in API request bodies, headers, etc.
+ */
+declare function resolveObjectReferences<T extends Record<string, any>>(obj: T, editorDocument: any[], options?: ResolveReferencesOptions): T;
+
+declare function reconcilePendingInvocations(editor: IxoEditorType, runId?: string): void;
+/**
+ * Materialize `trigger: flow.start` as durable pending invocations in the new
+ * run. The run.started Matrix event is the source fact; deterministic ids make
+ * reconnect/retry safe without keeping a second history log in the Y.Doc.
+ */
+declare function dispatchFlowStartTriggers(params: {
+    yDoc: Y.Doc;
+    runId: string;
+    blocks: any[];
+    startedAt: number;
+    sourceEventId?: string;
+}): number;
 declare function getActionForBlock(block: any): ReturnType<typeof getAction>;
 
 /**
@@ -327,13 +721,20 @@ declare function getActionForBlock(block: any): ReturnType<typeof getAction>;
  *
  * Call this after `updateRuntime({ state: 'completed', output })` in any
  * FlowDetail component whose action defines events.
+ *
+ * @param runId The **session run** (`runs.ts`) this emission belongs to.
+ *   Defaults to the active run. Recorded additively as
+ *   `RunRecordDetails.sessionRunId`; nothing in Phase A reads it, and it is
+ *   deliberately kept out of `computePendingInvocationId` (D2 / spec §2 rule 8
+ *   — the id space moves in Phase B, together with `pendingInvocations` and
+ *   `barrierState`, or the same logical event queues once per generation).
  */
 declare function writeRunRecordAndReconcile(editor: IxoEditorType, blockId: string, output: Record<string, unknown>, events: Array<{
     name: string;
     payload: Record<string, unknown>;
 }>, actorDid: string, detailsPatch?: Partial<RunRecordDetails> & {
     sourceRunId?: string;
-}): void;
+}, runId?: string): void;
 
 /**
  * Flow Version Manifest
@@ -460,14 +861,14 @@ interface FlowDocumentRead {
  *
  * - structure        ← `readCompiledFlowFromYDoc` (nodes, order, edges, `can`/`with`)
  * - per-block props   ← `readBlocksFromFragment` (inputs/conditions/trigger/ttl/icon/…)
- * - per-block runtime ← the `runtime` Y.Map (state/output/error/…)
+ * - per-block runtime ← the run's `actions` map, resolved against the flat `runtime` mirror
  *
  * Fragment props are authoritative for the denormalized fields (`title`/`description`); the
  * node-map copy is used only as a fallback when the fragment didn't persist them.
  *
  * Returns `null` when the doc has no flow at all (mirrors `readCompiledFlowFromYDoc`).
  */
-declare function readFlowDocument(yDoc: Doc): FlowDocumentRead | null;
+declare function readFlowDocument(yDoc: Doc, runId?: string): FlowDocumentRead | null;
 interface AddFlowNodeOptions {
     /** Registry action type, e.g. `'qi/form.submit'`. Must exist in the registry. */
     type: string;
@@ -511,7 +912,7 @@ declare function setBlockProps(yDoc: Doc, blockId: string, partial: Record<strin
  * `{{nodeId.output.*}}` input ref points at this node, removal is refused and the referring
  * node ids are returned so the caller can surface them.
  */
-declare function removeFlowNode(yDoc: Doc, nodeId: string): {
+declare function removeFlowNode(yDoc: Doc, nodeId: string, runId?: string): {
     ok: true;
 } | {
     ok: false;
@@ -537,19 +938,30 @@ declare function reorderFlowNodes(yDoc: Doc, order: string[]): boolean;
  * Returns `false` if either block id is missing.
  */
 declare function swapFlowBlocks(yDoc: Doc, blockIdA: string, blockIdB: string): boolean;
-/** Merge a partial into a node's runtime entry — the headless twin of the React `updateRuntime`. */
-declare function updateNodeRuntime(yDoc: Doc, blockId: string, partial: Partial<FlowNodeRuntimeState>): void;
+/**
+ * Merge a partial into a node's action state — the headless twin of the React `updateRuntime`.
+ *
+ * Goes through `writeActionState`, so the run entry and the flat mirror are
+ * written in one transaction from one resolved `prev`. A flat-only write here
+ * would be invisible to run-scoped readers the moment they land.
+ */
+declare function updateNodeRuntime(yDoc: Doc, blockId: string, partial: Partial<FlowNodeRuntimeState>, runId?: string): void;
 /**
  * Clear a failed step back to idle so the user can cleanly re-run it. The headless twin of
  * the editor's "Reset" recovery affordance — benign and non-executing.
+ *
+ * Resetting only the flat map is the failure this exists to avoid: a surviving
+ * `completed`/`failed` run entry beats a fresh `idle` flat entry under
+ * `resolveActionState` rule (a), so "Reset" would appear to do nothing at all
+ * once readers go run-first.
  */
-declare function resetStepRuntime(yDoc: Doc, blockId: string): void;
+declare function resetStepRuntime(yDoc: Doc, blockId: string, runId?: string): void;
 /**
  * Pre-fill a (live) form step's answers at `runtime.output.form.answers` (a JSON string,
  * matching `FormPanel`). Merges into existing `output`; **never** sets `state:'completed'` —
  * submission stays the user's action.
  */
-declare function setFormAnswers(yDoc: Doc, blockId: string, answers: Record<string, unknown>): void;
+declare function setFormAnswers(yDoc: Doc, blockId: string, answers: Record<string, unknown>, runId?: string): void;
 
 /**
  * The operator vocabulary the FE condition evaluator actually understands
@@ -603,6 +1015,7 @@ interface ExecuteFlowAgentCoreCommandOptions {
     leaseTtlMs?: number;
     flowOwnerDid?: string;
     schemaVersion?: string;
+    runEventLog?: RunEventAppender;
     now?: () => number;
 }
 interface ExecuteQueuedFlowAgentCoreCommandsOptions extends ExecuteFlowAgentCoreCommandOptions {
@@ -803,6 +1216,26 @@ declare function computeCID(content: Uint8Array): Promise<string>;
  */
 declare function computeJsonCID(obj: Record<string, any>): Promise<string>;
 
+declare const XERO_TOOLKIT = "xero";
+/**
+ * The Xero account, organisation and bank account this flow acts through.
+ *
+ * Flow-level, not block-level: the binding is chosen once in the flow's
+ * Connections and is a prerequisite of starting a session, so by the time any
+ * action runs it is already there. Blocks therefore no longer carry their own
+ * connection or bank-account pin — two payment blocks in one flow debiting two
+ * different accounts was never a real case, and a per-block pin could disagree
+ * with the account the actors were actually granted.
+ *
+ * Reads defensively and never throws: the doc is live and replicated, so this
+ * can be called mid-sync.
+ */
+declare function readFlowXeroBinding(yDoc?: Doc | null): FlowConnectionBinding | undefined;
+/** Same, from an editor (or anything carrying `_yDoc`). */
+declare function readFlowXeroBindingFromEditor(editor: {
+    _yDoc?: Doc;
+} | null | undefined): FlowConnectionBinding | undefined;
+
 declare const oracleInitSurveySchema: {
     title: string;
     description: string;
@@ -917,4 +1350,4 @@ declare function createOracleInitFlowTemplate(): {
     nodes: FlowNode[];
 };
 
-export { ActionDefinition, ActionHandlers, type ActionManifest, type ActionManifestEntry, ActionServices, type AddFlowNodeOptions, type BlockConditionInput, type ClassifyNodeStateInput, CompiledBlock, CompiledEdge, CompiledFlow, type CompletionVerification, type CompletionVerificationStatus, type EvaluatorOperator, type ExecuteFlowAgentCoreCommandOptions, type ExecuteQueuedFlowAgentCoreCommandsOptions, FlowAgentBlockerCause, FlowAgentCommand, FlowAgentCommandResult, FlowAgentContext, FlowAgentExecutor, FlowAgentNodeSnapshot, FlowAgentPublicNodeState, type FlowDocumentNode, type FlowDocumentRead, FlowNode, FlowNodeRuntimeState, type FlowVersionString, InvocationStore, LATEST_VERSION, type ManifestProofDeclaration, OutputSchemaField, PROOF_MISSING_CODE, type ProofValidationResult, RunRecordDetails, SERVICE_VERBS, STEP_COMPLETED_EVENT, STEP_COMPLETED_EVENT_NAME, type ServiceVerb, StoredDelegation, StoredInvocation, type TriggerResolutionContext, UcanDelegationStore, UcanService, VERSION_MANIFEST, type VersionPolicy, XERO_WORK_ITEMS_MAP_NAME, XERO_WORK_TERMINAL_MAP_NAME, type XeroWorkAttempt, type XeroWorkItem, type XeroWorkItemFilter, type XeroWorkKind, type XeroWorkProvenance, type XeroWorkSource, type XeroWorkStatus, type XeroWorkTerminalRecord, addFlowNode, buildBlockConditionsProp, buildServicesFromHandlers, buildXeroInvoiceWorkKey, buildXeroPaymentWorkKey, canToType, classifyBlockerCause, classifyNodeState, computeCID, computeJsonCID, createOracleInitFlowTemplate, executeFlowAgentCoreCommand, executeQueuedFlowAgentCoreCommands, findXeroWorkItems, findXeroWorkItemsForEditor, generateActionManifest, getAction, getActionByCan, getActionForBlock, getAliasEntries, getAllActions, getAllCanMappings, getEventsForBlock, getMissingActionInputs, getOutputSchemaForBlock, getVersionPolicy, getXeroWorkItemsMap, getXeroWorkTerminalMap, hasAction, isBlankInputValue, isTempUcanEnforcementDisabled, isVerifiedCompletion, isVersionAtLeast, markXeroWorkApproved, markXeroWorkApprovedForEditor, markXeroWorkCompleted, markXeroWorkCompletedForEditor, markXeroWorkFailed, markXeroWorkFailedForEditor, oracleInitSurveySchema, parseServiceCan, readBlocksFromFragment, readFlowDocument, reconcilePendingInvocations, registerAction, removeBlockFromFragment, removeFlowNode, reorderFlowNodes, replaceBlockInFragment, resetStepRuntime, resolveRuntimeRefs, serviceCan, setBlockProps, setFormAnswers, setTempUcanEnforcementDisabled, snapshotNode, swapFlowBlocks, toEvaluatorOperator, typeToCan, updateNodeRuntime, updateXeroWorkReviewPayload, updateXeroWorkReviewPayloadForEditor, upsertXeroWorkItem, upsertXeroWorkItemForEditor, validateActionProof, verifyCompletion, writeCompiledBlocksToFragment, writeRunRecordAndReconcile };
+export { ActionDefinition, ActionDoneContract, ActionHandlers, type ActionManifest, type ActionManifestEntry, ActionReadBackMetadata, type ActionReadBackResolution, type ActionReadBackResolver, type ActionReadBackResolverInput, ActionResult, ActionRunContext, ActionServices, type AddFlowNodeOptions, type BlockCondition, type BlockConditionInput, type BlockConditionsResult, type BlockExecutionEligibility, type BoundedRunOutput, type ClassifyNodeStateInput, CompiledBlock, CompiledEdge, CompiledFlow, CompletionCheck, type CompletionReconciliationTransition, type CompletionVerification, type CompletionVerificationStatus, type ConditionActionResult, type ConditionConfig, type ConditionEvaluationOptions, type ConditionEvaluationResult, type ConditionOperator, type DetailedResolution, type EvaluatorOperator, type ExecuteFlowAgentCoreCommandOptions, type ExecuteQueuedFlowAgentCoreCommandsOptions, FlowAgentBlockerCause, FlowAgentCommand, FlowAgentCommandResult, FlowAgentContext, FlowAgentExecutor, FlowAgentNodeSnapshot, FlowAgentPublicNodeState, FlowConnectionBinding, type FlowDocumentNode, type FlowDocumentRead, FlowNode, FlowNodeRuntimeState, FlowRuntimeStateManager, type FlowVersionString, INVOCATIONS_MAP_KEY, InvalidConditionConfigError, InvocationStore, LATEST_VERSION, MAX_RUN_ACTION_OUTPUT_BYTES, type ManifestDoneDeclaration, type ManifestProofDeclaration, OutputSchemaField, PROOF_MISSING_CODE, type ParsedReference, PendingInvocation, type PendingRunTimelineEvent, type ProofValidationResult, ReadBackTerminalState, type ReconcileActionReadBackParams, type ReconcileActionReadBackResult, type ReconcileCompletionParams, type ReconcileCompletionResult, type ResolveReferencesOptions, RunEventAppender, RunEventInput, RunJsonValue, RunRecordDetails, type RunTimelineAppendResult, SERVICE_VERBS, STEP_COMPLETED_EVENT, STEP_COMPLETED_EVENT_NAME, type ServiceVerb, StoredDelegation, StoredInvocation, UcanDelegationStore, UcanService, type UnresolvedReference, type UnresolvedReferenceReason, VERSION_MANIFEST, type VersionPolicy, XERO_TOOLKIT, XERO_WORK_ITEMS_MAP_NAME, XERO_WORK_TERMINAL_MAP_NAME, type XeroWorkAttempt, type XeroWorkItem, type XeroWorkItemFilter, type XeroWorkKind, type XeroWorkProvenance, type XeroWorkSource, type XeroWorkStatus, type XeroWorkTerminalRecord, addFlowNode, appendRunTimelineEvent, appendRunTimelineEvents, boundRunActionOutput, boundRunEventJson, buildBlockConditionsProp, buildServicesFromHandlers, buildXeroInvoiceWorkKey, buildXeroPaymentWorkKey, canToType, classifyBlockerCause, classifyNodeState, computeCID, computeJsonCID, createOracleInitFlowTemplate, createReference, createRunEventIdempotencyKey, dispatchFlowStartTriggers, doneWhenCompleted, evaluateBlockConditions, evaluateBlockConditionsForRun, evaluateBlockExecutionEligibilityForRun, evaluateCondition, executeFlowAgentCoreCommand, executeQueuedFlowAgentCoreCommands, findXeroWorkItems, findXeroWorkItemsForEditor, generateActionManifest, getAction, getActionByCan, getActionForBlock, getAliasEntries, getAllActions, getAllCanMappings, getEventsForBlock, getMissingActionInputs, getNestedValue, getOutputSchemaForBlock, getVersionPolicy, getXeroWorkItemsMap, getXeroWorkTerminalMap, hasAction, hasReferences, isActionDone, isActionTypeDone, isBlankInputValue, isTempUcanEnforcementDisabled, isVerifiedCompletion, isVersionAtLeast, markXeroWorkApproved, markXeroWorkApprovedForEditor, markXeroWorkCompleted, markXeroWorkCompletedForEditor, markXeroWorkFailed, markXeroWorkFailedForEditor, neverDone, normalizeActionReadBackMetadata, normalizeCondition, normalizeConditions, oracleInitSurveySchema, parseConditionConfig, parseConditionConfigStrict, parseReferences, parseServiceCan, readBlocksFromFragment, readFlowDocument, readFlowXeroBinding, readFlowXeroBindingFromEditor, readInvocationsForRun, readPendingRunTimelineEvents, reconcileActionReadBack, reconcileCompletion, reconcilePendingInvocations, registerAction, removeBlockFromFragment, removeFlowNode, reorderFlowNodes, replaceBlockInFragment, resetStepRuntime, resolveConditionSourceValue, resolveObjectReferences, resolveReferences, resolveReferencesDetailed, resolveSingleReference, retryPendingRunTimelineEvents, serviceCan, setBlockProps, setFormAnswers, setTempUcanEnforcementDisabled, snapshotNode, swapFlowBlocks, toEvaluatorOperator, typeToCan, updateNodeRuntime, updateXeroWorkReviewPayload, updateXeroWorkReviewPayloadForEditor, upsertXeroWorkItem, upsertXeroWorkItemForEditor, validateActionProof, verifyCompletion, writeCompiledBlocksToFragment, writeRunRecordAndReconcile };