@ixo/editor 6.32.0 → 6.32.1

package/dist/core/index.d.ts

@@ -1,15 +1,39 @@
-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-CqvAkvIZ.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-CqvAkvIZ.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-Up8gA_E9.js';
-export { bV as ActionContext, bD as ActionRunEventInput, bZ as BidService, bB as CancelRunParams, c4 as CarbonService, co as ClaimCollectionURI, b_ as ClaimService, bC as CloseRunParams, b$ as CollectionService, c0 as CollectionUsersService, cy as CreateDelegationParams, cz as CreateInvocationParams, cx as CreateRootDelegationParams, cn as DID, D as DelegationChainValidationResult, l as DelegationGrant, bX as EmailService, c5 as EntityService, c6 as EvalRegisterService, a8 as EvaluationStatus, cv as ExecutionWithInvocationResult, ba as ExplicitRunRequiredError, cm as FailedListenerRun, cw as FindProofsResult, bE as FinishRunResult, a7 as FlowNodeAuthzExtension, cs as FlowNodeBase, bx as FlowNotMigratedError, c8 as FlowRunLifecycleService, bW as HttpService, c2 as IntegrationsService, ct as InvocationRequest, cu as InvocationResult, aD as LEGACY_RUN_STORAGE_VERSION, bH as LifecycleRunEventInput, cp as LinkedClaim, aE as MULTI_RUN_STORAGE_VERSION, c1 as MatrixCredentialService, bF as MigrateFlowParams, bG as MigrateFlowResult, be as MultiRunMigrationResult, cq as NodeServiceReport, cr as NodeState, bY as NotifyService, c3 as OracleService, aF as RUNS_TERMINAL_MAP_KEY, cl as RUN_RECORD_AUDIT_TYPE, aG as RUN_STORAGE_VERSION_KEY, c7 as RubricService, 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, c9 as appendRunRecord, a$ as assertRunActionExecutionAllowed, bh as buildRunDefinitionSnapshot, bi as cancelRun, aI as clearAllActionState, aC as clearRuntimeForTemplateClone, bj as closeRun, aJ as collectPhantomLegacyRun, ck as computePendingInvocationId, bk as computeRunDefinitionHash, bl as computeRunSummary, cc 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, ch as findFailedListenersForSourceRun, cd as getOrCreateBlockPendingMap, cb 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, cf as queuePendingInvocation, aY as readActionState, aZ as readActionStates, ce as readPendingInvocations, bs as readRunActionStates, ca as readRunRecords, bt as recordRunDefinitionDrift, cg as removePendingInvocation, ci 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, cj as snapshotInputRefs, bv as startRun, b7 as subscribeToActionState, bw as toRunJsonValue, b8 as usesLegacyRuntimeCompatibility, b9 as writeActionState } from '../index-Up8gA_E9.js';
+import { k as FlowAgentExecutor, h as FlowAgentCommand, j as FlowAgentContext, i as FlowAgentCommandResult, an as FlowAgentBlockerCause, n as FlowAgentPublicNodeState, m as FlowAgentNodeSnapshot, ao as CompiledBlock, C as CompiledFlow, ap as CompiledEdge, s as FlowConnectionBinding } from '../connections-1NtNQrsY.js';
+export { aq as AcquireFlowAgentLeaseParams, ar as ActionBlockLike, as as ActionExecutionCompletionState, at as ActorConstraint, A as AuthorizationResult, B as BaseUcanFlow, au as BuildActionRunInputsParams, av as BuildActionRunInputsResult, a as BuildFlowAgentContextParams, aw as CompiledFlowNode, b as CompilerRegistry, ax as ConditionRef, ay as CreateAgentCommandParams, az as EvaluateFlowAgentPolicyParams, aA as ExecuteActionBlockParams, aB as ExecuteActionBlockResult, E as ExecuteNodeParams, c as ExecutionContext, d as ExecutionOutcome, F as FLOW_CONNECTIONS_MAP_KEY, e as FLOW_CONNECTION_BINDINGS_MAP_KEY, f as FLOW_PARTICIPANTS_MAP_KEY, g as FlowAgentActor, aC as FlowAgentCommandBase, aD as FlowAgentCommandStatus, aE as FlowAgentCommandType, l as FlowAgentLease, aF as FlowAgentLedgerEvent, aG as FlowAgentLedgerEventType, aH as FlowAgentMaps, aI as FlowAgentOrchestratorOptions, aJ as FlowAgentPolicyDecision, aK as FlowAgentRunPhase, o as FlowAgentService, aL as FlowAgentServiceOptions, p as FlowAgentTickResult, q as FlowCapability, r as FlowConnection, t as FlowConnectionRequirementKey, u as FlowParticipant, v as FlowStrategy, M as MergeResult, N as NodeActionResult, R as ReadFlowOptions, w as ReadFlowResult, aM as RuntimeRef, S as SetupFlowOptions, y as SetupFlowResult, aN as TTLConstraint, aO as TriggerResolutionContext, aP as TriggerSpec, z as acquireFlowAgentLease, D as appendAgentLedgerEvent, aQ as buildActionRunInputs, G as buildAuthzFromProps, H as buildFlowAgentContext, I as buildFlowNodeFromBlock, aR as canMatches, J as cleanupExpiredFlowAgentLeases, K as compileBaseUcanFlow, aS as computeAgentCommandId, L as createAgentCommand, O as decompileToBaseUcanFlow, P as evaluateFlowAgentPolicy, aT as executeActionBlock, Q as executeNode, T as executeQueuedAgentCommands, U as getActiveEditor, V as getFlowAgentMaps, W as isAuthorized, aU as isCapabilityMatch, aV as isExternalMutation, aW as isRuntimeRef, X as mergeCompiledFlows, Y as planRalphLoopCommands, Z as queueAgentCommand, aX as readAgentCommands, _ as readAgentLedgerEvents, $ as readCompiledFlowFromYDoc, a0 as readFlow, aY as readFlowAgentLeases, a1 as readFlowAsBaseUcan, a2 as readFlowConnectionBindings, a3 as readFlowConnections, a4 as readFlowFromEditor, a5 as readFlowParticipants, a6 as readQueuedAgentCommands, a7 as releaseFlowAgentLease, a8 as removeFlowConnection, a9 as removeFlowConnectionBinding, aa as removeFlowParticipant, aZ as requiredCapabilityForCommand, a_ as resolveRuntimeRefs, a$ as resourceMatches, ab as setActiveEditor, ac as setFlowConnectionOptional, ad as setFlowConnectionRequires, ae as setFlowParticipantPowerLevel, af as setFlowParticipantRequirements, ag as setupFlowFromBaseUcan, ah as tickFlowAgent, b0 as updateAgentCommand, ai as upsertFlowConnection, aj as upsertFlowConnectionBinding, ak as upsertFlowParticipant, al as validateAgentCommand, am as validateFlowAgentLease } from '../connections-1NtNQrsY.js';
+import { au as TopicSemanticRecordDefinition, av as TopicActionMetadata, aw as ActionEventDefinition, ax as ActionDoneContract, aj as ActionDefinition, ay as OutputSchemaField, az as ActionRiskTier, aA as ActionSchedulingContract, ab as ActionServices, aB as TopicActionInvocationV1, aC as TopicActionReceiptV2, aD as TopicActionRecord, aE as TopicActionRuntimeProvider, af as TopicActionBridge, ah as TopicActionWriteBackResult, ai as FlowNodeRuntimeState, aF as RunEventInput, ad as RunEventAppender, F as FlowRuntimeStateManager, aG as RunJsonValue, aH as ActionRunContext, aI as CompletionCheck, w as StoredInvocation, aJ as ReadBackTerminalState, ag as ActionResult, aK as ActionReadBackMetadata, a9 as IxoEditorType, aa as PendingInvocation, aL as ActionProofDeclaration, aM as RunRecordDetails, G as UcanService, ac as ActionHandlers, z as UcanDelegationStore, v as StoredDelegation, g as InvocationStore, aN as FlowMetadata, a7 as FlowNode } from '../runtime-BFwvCQDF.js';
+export { aO as ActionContext, aP as ActionRunEventInput, aQ as AgentRuntimeService, aR as BidService, aS as CancelRunParams, aT as CarbonService, aU as ClaimCollectionURI, aV as ClaimService, aW as CloseRunParams, aX as CollectionService, aY as CollectionUsersService, aZ as CreateDelegationParams, a_ as CreateInvocationParams, a$ as CreateRootDelegationParams, b0 as DID, D as DelegationChainValidationResult, e as DelegationGrant, b1 as EmailService, b2 as EntityService, b3 as EvalRegisterService, b4 as EvaluationRuntimeService, a8 as EvaluationStatus, b5 as EvidenceService, b6 as ExecutionWithInvocationResult, b7 as ExplicitRunRequiredError, b8 as FailedListenerRun, b9 as FindProofsResult, ba as FinishRunResult, a6 as FlowNodeAuthzExtension, bb as FlowNodeBase, bc as FlowNotMigratedError, bd as FlowRunLifecycleService, be as HttpService, bf as InMemoryTopicActionOutboxStore, bg as IncidentService, bh as IntegrationsService, bi as InvocationRequest, bj as InvocationResult, bk as LEGACY_RUN_STORAGE_VERSION, bl as LifecycleRunEventInput, bm as LinkedClaim, bn as MULTI_RUN_STORAGE_VERSION, bo as MatrixCredentialService, bp as MigrateFlowParams, bq as MigrateFlowResult, br as MultiRunMigrationResult, bs as NodeServiceReport, bt as NodeState, bu as NotifyService, bv as OracleService, bw as RUNS_TERMINAL_MAP_KEY, bx as RUN_RECORD_AUDIT_TYPE, by as RUN_STORAGE_VERSION_KEY, bz as RecordFlowActionPhaseParams, bA as RubricService, bB as RunDefinitionBlock, bC as RunDefinitionDrift, bD as RunDefinitionSnapshot, bE as RunJsonObject, bF as RunLifecycleAuthorizationDecision, bG as RunLifecycleAuthorizationError, bH as RunLifecycleAuthorizationRequest, bI as RunLifecycleAuthorizer, bJ as RunLifecycleCapability, bK as RunLogEventInput, bL as RunManifest, bM as RunMeta, bN as RunNotMigratedError, bO as RunNotReadyError, bP as RunSnapshot, bQ as RunStorageVersion, bR as RunTerminalRecord, bS as SettlementService, bT as StartRunParams, bU as StartRunResult, bV as TerminalRunExecutionError, bW as TopicActionOutboxEntry, bX as TopicActionOutboxStore, bY as TopicActionReceiptSigner, bZ as TopicActionReceiptSink, b_ as TopicActionReceiptStatus, b$ as TopicActionReceiptVerifier, c0 as TopicActionTerminalStatus, c1 as TopicActionThreadUpdateV1, c2 as TopicActionWriteBackState, ae as TopicExecutionContext, c3 as TopicOperationAppendResult, c4 as TopicRevisionConflictError, c5 as TopicService, U as UcanCapability, H as UcanServiceConfig, J as UcanServiceHandlers, c6 as UnknownRunError, c7 as UnsignedTopicActionReceiptV2, c8 as YjsTopicActionOutboxStore, c9 as adoptLegacyRuntime, ca as appendRunRecord, cb as assertRunActionExecutionAllowed, cc as buildRunDefinitionSnapshot, cd as buildTopicActionThreadUpdate, ce as cancelRun, cf as clearAllActionState, cg as clearRuntimeForTemplateClone, ch as closeRun, ci as collectPhantomLegacyRun, cj as computePendingInvocationId, ck as computeRunDefinitionHash, cl as computeRunSummary, cm as countPendingInvocations, Y as createInvocationStore, Z as createMemoryInvocationStore, _ as createMemoryUcanDelegationStore, cn as createRunId, co as createRunRuntimeReader, cp as createRunRuntimeReaderWithDoc, cq as createRunScopedRuntimeManager, cr as createRunUlid, $ as createRuntimeStateManager, a0 as createUcanDelegationStore, a1 as createUcanService, cs as createYDocRuntimeManager, ct as deleteActionState, cu as detectRunDefinitionDrift, cv as enableMultiRunStorage, cw as ensureRun, cx as findFailedListenersForSourceRun, cy as getOrCreateBlockPendingMap, cz as getPendingInvocationsMap, cA as getRunActionsMap, cB as getRunMeta, cC as getRunStorageVersion, cD as getRunsMap, cE as getRunsTerminalMap, cF as hasLegacyRuntimeHistory, cG as isBelowTheLineBlock, cH as isLegacyRuntimeAdoptionEnabled, cI as isRecordInRun, cJ as listOpenRuns, cK as listRuns, cL as migrateFlowToSessions, cM as queuePendingInvocation, cN as readActionState, cO as readActionStates, cP as readPendingInvocations, cQ as readRunActionStates, cR as readRunRecords, cS as recordRunDefinitionDrift, cT as removePendingInvocation, cU as replayFailedListenerRun, cV as resetActionState, cW as resolveActiveRunId, cX as resolveRecordRunId, cY as resolveRunIdForExecution, cZ as resolveRunIdForRead, c_ as seedRunFromLegacyRuntime, c$ as setAdvisoryActiveRunId, d0 as setMultiRunStorage, d1 as snapshotInputRefs, d2 as startRun, d3 as subscribeToActionState, d4 as toRunJsonValue, d5 as topicActionReceiptSigningPayload, d6 as topicActionThreadUpdateBody, d7 as topicActionThreadUpdateId, d8 as topicActionThreadUpdateTransactionId, d9 as topicSemanticRecordsDigest, da as usesLegacyRuntimeCompatibility, db as writeActionState } from '../runtime-BFwvCQDF.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 { Map, Doc } from 'yjs';
+import { ErrorObject } from 'ajv/dist/2020.js';
+export { a as NODE_CONTEXT_MAP_NAME, b as NODE_CONTEXT_OVERRIDES_MAP_NAME, c as NodeContextFieldProvenance, N as NodeContextRecord, i as isNodeContextRecord } from '../nodeContext-CV9D4s3X.js';
 import 'matrix-js-sdk';
 import '@blocknote/core';
 import 'react';
 import '@ixo/ucan';
 
+/** Keep the complete record batch comfortably below Matrix's event-size ceiling. */
+declare const MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT = 25;
+declare const MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES: number;
+type TopicSemanticRecordValidationResult = {
+    valid: true;
+    definition: TopicSemanticRecordDefinition;
+} | {
+    valid: false;
+    code: string;
+    errors?: ErrorObject[];
+};
+type TopicSemanticRecordBatchValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    code: string;
+    errors?: ErrorObject[];
+};
+/** Validate the complete safe envelope and its declared value contract. */
+declare function validateTopicSemanticRecord(record: unknown, topic: TopicActionMetadata): TopicSemanticRecordValidationResult;
+/** Validate every record and the bounded, JSON-portable batch written to Matrix. */
+declare function validateTopicSemanticRecordBatch(records: readonly unknown[], topic: TopicActionMetadata): TopicSemanticRecordBatchValidationResult;
+
 /** Stable name of the universal completion event every step emits. */
 declare const STEP_COMPLETED_EVENT_NAME = "step.completed";
 /**
@@ -59,7 +83,8 @@ interface CapabilityPatternCoversCanOptions {
 }
 /** Return true when a capability pattern grants the requested `can` ability. */
 declare function capabilityPatternCoversCan(pattern: string, can: string, options?: CapabilityPatternCoversCanOptions): boolean;
-declare function registerAction<TInputs extends Record<string, any> = Record<string, any>>(definition: ActionDefinition<TInputs>): void;
+type ActionRegistrationDefinition<TInputs extends Record<string, any>> = Omit<ActionDefinition<TInputs>, 'displayName' | 'description'> & Partial<Pick<ActionDefinition<TInputs>, 'displayName' | 'description'>>;
+declare function registerAction<TInputs extends Record<string, any> = Record<string, any>>(definition: ActionRegistrationDefinition<TInputs>): void;
 declare function getAction(type: string): ActionDefinition | undefined;
 declare function getAllActions(): ActionDefinition[];
 /** All (alias → canonical type) pairs, for manifest generation and consistency checks. */
@@ -88,11 +113,9 @@ declare function getEventsForBlock(action: ActionDefinition | undefined, inputs:
  */
 declare function getOutputSchemaForBlock(action: ActionDefinition | undefined, inputs: unknown): OutputSchemaField[];
 
-/**
- * Serializable proof declaration: custom `validate` functions can't cross a
- * JSON boundary, so they are represented as `{ kind: 'custom' }` — consumers
- * know a proof exists and is enforced kernel-side, without its logic.
- */
+declare const ACTION_MANIFEST_VERSION: "4";
+declare const ACTION_REGISTRY_VERSION: "6.32.0-topic-actions.3";
+/** Serializable declaration; custom functions remain kernel-enforced. */
 type ManifestProofDeclaration = {
     kind: 'none';
 } | {
@@ -102,61 +125,375 @@ 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. */
+    displayName: string;
+    description: string;
     aliases: string[];
-    can?: string;
+    contractDigest: `sha256:${string}`;
+    can: string;
+    effectiveCapability: {
+        action: string;
+        flowExecution?: string;
+        topicWriteBack: string[];
+    };
     sideEffect: boolean;
     defaultRequiresConfirmation: boolean;
-    requiredCapability?: string;
+    executionOwner: 'agent' | 'human';
+    riskTier: ActionRiskTier;
+    requiredServices: string[];
+    sensitiveInputPaths: string[];
+    sensitiveOutputPaths: string[];
+    hidden: boolean;
+    deprecated: boolean;
+    supersededBy?: 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. */
-    outputSchema?: OutputSchemaField[];
-    /** Static event vocabulary. Actions with dynamic events also set hasDynamicEvents. */
-    events?: Array<Pick<ActionEventDefinition, 'name' | 'displayName' | 'description' | 'payloadSchema'>>;
+    inputSchema: object;
+    outputSchema: OutputSchemaField[];
+    events: Array<Pick<ActionEventDefinition, 'name' | 'displayName' | 'description' | 'payloadSchema'>>;
     hasDynamicEvents: boolean;
     hasDynamicOutputSchema: boolean;
     eligibleForEventTrigger: boolean;
-    /**
-     * True when the action defines `getMissingInputs` — conditional requiredness
-     * that `inputSchema.required` cannot express (like a custom proof, the
-     * function itself can't cross the JSON boundary). Out-of-process consumers
-     * should treat the schema's `required` as a lower bound for such actions;
-     * in-process consumers get the full logic via `getMissingActionInputs`.
-     */
+    /** Whether a time trigger may target this action (Sovereign Scheduling, IXO-4433). */
+    eligibleForTimeTrigger: boolean;
+    /** Present exactly when eligibleForTimeTrigger is true: the Timed Action contract. */
+    scheduling?: ActionSchedulingContract;
     hasCustomInputValidation: boolean;
+    topic: TopicActionMetadata;
 }
 interface ActionManifest {
-    /** Schema version of the manifest format itself. */
-    manifestVersion: '1';
+    manifestVersion: typeof ACTION_MANIFEST_VERSION;
+    registryVersion: string;
+    manifestDigest: `sha256:${string}`;
     actions: ActionManifestEntry[];
 }
 /**
- * Generate the machine-readable action contract from the live registry.
+ * Generate deterministic Action Manifest v4 from the one live registry.
+ *
+ * Memoized against the registry revision: building the manifest canonicalizes and
+ * SHA-256s every registered contract, and the validation paths (flow bindings,
+ * Action requests, receipts, external invocations) call this on every check —
+ * several of them from React render. The registry only changes when an Action
+ * registers, which bumps the revision and invalidates this.
  *
- * This is the single artifact external actors (the flow-manager oracle,
- * third-party agentic Oracle actors) implement against, replacing
- * hand-maintained copies of input contracts. It is emitted to
- * `dist/action-manifest.json` at build time and also callable at runtime
- * from `@ixo/editor/core`.
+ * The returned manifest is shared, so callers must treat it as read-only.
  */
 declare function generateActionManifest(): ActionManifest;
+interface ActionManifestIssue {
+    actionType: string;
+    code: 'MISSING_CAN' | 'MISSING_PRESENTATION' | 'MISSING_INPUT_SCHEMA' | 'MISSING_OUTPUT_SCHEMA' | 'SIDE_EFFECT_WITHOUT_PROOF' | 'MISSING_TOPIC_POLICY' | 'INVALID_TOPIC_POLICY' | 'INVALID_SEMANTIC_RECORD_DEFINITION';
+    message: string;
+}
+/** CI/build gate for the public portable registry contract. */
+declare function actionManifestIssues(manifest?: ActionManifest): ActionManifestIssue[];
+
+declare function sha256Digest(value: unknown): `sha256:${string}`;
+
+/** JSON values accepted by the Manifest v2 portable contract. */
+type ManifestV2JsonValue = null | boolean | number | string | ManifestV2JsonValue[] | {
+    [key: string]: ManifestV2JsonValue;
+};
+interface ActionManifestV2Package {
+    name: string;
+    version: string;
+    sourceCommit: string;
+    buildId?: string;
+    distributionUrl?: string;
+}
+interface ActionManifestV2Issuer {
+    did: string;
+    verificationMethod: string;
+}
+interface ActionManifestV2Compatibility {
+    engine: {
+        versionRange: string;
+    };
+    flowSchemaVersions: string[];
+    features: string[];
+}
+/**
+ * The complete action and primitive groups are introduced by the registry
+ * migration. Keeping their extension fields JSON-only prevents executable
+ * functions or class instances from crossing this portable boundary.
+ */
+type ActionManifestV2Action = {
+    type: string;
+    contractVersion: string;
+    aliases?: string[];
+} & Record<string, ManifestV2JsonValue>;
+type ActionManifestV2Primitive = {
+    type: string;
+    contractVersion: string;
+    aliases?: string[];
+} & Record<string, ManifestV2JsonValue>;
+/** The unsigned, portable portion of an Action Manifest v2 envelope. */
+interface ActionManifestV2Payload {
+    manifestVersion: '2.0';
+    manifestId: string;
+    generatedAt: string;
+    package: ActionManifestV2Package;
+    issuer: ActionManifestV2Issuer;
+    compatibility: ActionManifestV2Compatibility;
+    actions: ActionManifestV2Action[];
+    primitives: ActionManifestV2Primitive[];
+}
+interface ActionManifestV2Integrity {
+    canonicalization: 'RFC8785';
+    digest: {
+        algorithm: 'SHA-256';
+        value: `sha256:${string}`;
+    };
+    signature: {
+        algorithm: string;
+        verificationMethod: string;
+        value: string;
+    };
+}
+type SignedActionManifestV2 = ActionManifestV2Payload & {
+    integrity: ActionManifestV2Integrity;
+};
+declare const verifiedActionManifestV2: unique symbol;
+type DeepReadonly<T> = T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+/** A manifest that crossed the trust-policy boundary successfully. */
+type VerifiedActionManifestV2 = DeepReadonly<SignedActionManifestV2> & {
+    readonly [verifiedActionManifestV2]: true;
+};
+interface ActionManifestV2Signer {
+    issuerDid: string;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface ActionManifestV2SignatureVerificationInput {
+    issuerDid: string;
+    verificationMethod: string;
+    algorithm: string;
+    data: Uint8Array;
+    signature: string;
+}
+interface ActionManifestV2TrustPolicy {
+    trustedIssuerDids: readonly string[];
+    revokedIssuerDids?: readonly string[];
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: ActionManifestV2SignatureVerificationInput): Promise<boolean>;
+}
+type ActionManifestV2VerificationErrorCode = 'INVALID_MANIFEST' | 'UNSUPPORTED_MANIFEST_VERSION' | 'UNSIGNED_MANIFEST' | 'SIGNER_MISMATCH' | 'DUPLICATE_CONTRACT_TYPE' | 'AMBIGUOUS_ALIAS' | 'UNSORTED_CONTRACTS' | 'UNTRUSTED_ISSUER' | 'REVOKED_ISSUER' | 'VERIFICATION_METHOD_MISMATCH' | 'DISALLOWED_SIGNATURE_ALGORITHM' | 'DIGEST_MISMATCH' | 'INVALID_SIGNATURE';
+declare class ActionManifestV2VerificationError extends Error {
+    readonly code: ActionManifestV2VerificationErrorCode;
+    constructor(code: ActionManifestV2VerificationErrorCode, message: string);
+}
+/**
+ * Serialize a Manifest v2 payload using the RFC 8785 JSON Canonicalization
+ * Scheme. Invalid JSON-domain values are rejected rather than being silently
+ * omitted or coerced.
+ */
+declare function canonicalizeManifestV2Payload(payload: ActionManifestV2Payload): string;
+/** Compute the content address for the unsigned Manifest v2 payload. */
+declare function computeActionManifestV2Digest(payload: ActionManifestV2Payload): Promise<string>;
+/**
+ * Sign a portable Manifest v2 payload. The host owns key resolution and the
+ * concrete signature algorithm; this module owns canonical bytes and issuer
+ * binding.
+ */
+declare function signActionManifestV2(payload: ActionManifestV2Payload, signer: ActionManifestV2Signer): Promise<SignedActionManifestV2>;
+/**
+ * Load a signed manifest across the execution trust boundary. Every failure
+ * throws; this API never returns a partially trusted or downgraded contract.
+ */
+declare function verifyActionManifestV2(candidate: unknown, trustPolicy: ActionManifestV2TrustPolicy): Promise<VerifiedActionManifestV2>;
+
+/** JSON Schema 2020-12 for the signed Manifest v2 envelope. */
+declare const ACTION_MANIFEST_V2_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://ixo.world/schemas/qi/action-manifest-v2.schema.json";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["manifestVersion", "manifestId", "generatedAt", "package", "issuer", "compatibility", "actions", "primitives", "integrity"];
+    readonly properties: {
+        readonly manifestVersion: {
+            readonly const: "2.0";
+        };
+        readonly manifestId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly generatedAt: {
+            readonly type: "string";
+            readonly pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$";
+        };
+        readonly package: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["name", "version", "sourceCommit"];
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly version: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly sourceCommit: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly buildId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly distributionUrl: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-zA-Z][a-zA-Z0-9+.-]*:";
+                };
+            };
+        };
+        readonly issuer: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["did", "verificationMethod"];
+            readonly properties: {
+                readonly did: {
+                    readonly type: "string";
+                    readonly pattern: "^did:[a-z0-9]+:.+";
+                };
+                readonly verificationMethod: {
+                    readonly type: "string";
+                    readonly pattern: "^did:[a-z0-9]+:.+#.+";
+                };
+            };
+        };
+        readonly compatibility: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["engine", "flowSchemaVersions", "features"];
+            readonly properties: {
+                readonly engine: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["versionRange"];
+                    readonly properties: {
+                        readonly versionRange: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly flowSchemaVersions: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly features: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly actions: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/$defs/contract";
+            };
+        };
+        readonly primitives: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/$defs/contract";
+            };
+        };
+        readonly integrity: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["canonicalization", "digest", "signature"];
+            readonly properties: {
+                readonly canonicalization: {
+                    readonly const: "RFC8785";
+                };
+                readonly digest: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["algorithm", "value"];
+                    readonly properties: {
+                        readonly algorithm: {
+                            readonly const: "SHA-256";
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                            readonly pattern: "^sha256:[0-9a-f]{64}$";
+                        };
+                    };
+                };
+                readonly signature: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["algorithm", "verificationMethod", "value"];
+                    readonly properties: {
+                        readonly algorithm: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly verificationMethod: {
+                            readonly type: "string";
+                            readonly pattern: "^did:[a-z0-9]+:.+#.+";
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly $defs: {
+        readonly contract: {
+            readonly type: "object";
+            readonly required: readonly ["type", "contractVersion"];
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly contractVersion: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly aliases: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+    };
+};
+
+interface ActionPresentation {
+    displayName: string;
+    description: string;
+}
+/** Core-owned default used by built-ins and by legacy registrations during migration. */
+declare function getActionPresentation(type: string): ActionPresentation;
 
 /**
  * Required-input evaluation for action types — the machine-readable mirror of
@@ -267,6 +604,26 @@ declare function parseServiceCan(value: string): {
 
 declare function buildServicesFromHandlers(handlers: any): ActionServices;
 
+interface ExternalTopicExecutorResult {
+    receipt: TopicActionReceiptV2;
+    semanticRecords?: TopicActionRecord[];
+}
+interface ExternalTopicExecutorPort {
+    invoke(invocation: TopicActionInvocationV1): Promise<ExternalTopicExecutorResult>;
+}
+/** Shared manifest/invocation boundary for both QiForge and MCP providers. */
+declare class ManifestBoundTopicExecutorAdapter {
+    readonly provider: Exclude<TopicActionRuntimeProvider, 'qi-flow'>;
+    private readonly executor;
+    private readonly bridge;
+    constructor(provider: Exclude<TopicActionRuntimeProvider, 'qi-flow'>, executor: ExternalTopicExecutorPort, bridge: TopicActionBridge);
+    execute(invocation: TopicActionInvocationV1): Promise<TopicActionWriteBackResult>;
+    private validateInvocation;
+    private validateResult;
+}
+declare const createQiForgeTopicExecutorAdapter: (executor: ExternalTopicExecutorPort, bridge: TopicActionBridge) => ManifestBoundTopicExecutorAdapter;
+declare const createMcpTopicExecutorAdapter: (executor: ExternalTopicExecutorPort, bridge: TopicActionBridge) => ManifestBoundTopicExecutorAdapter;
+
 type ConditionOperator = 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains' | 'not_contains' | 'is_empty' | 'is_not_empty';
 interface BlockCondition {
     id: string;
@@ -813,212 +1170,6 @@ declare function getVersionPolicy(version: string): VersionPolicy;
  */
 declare function isVersionAtLeast(current: string, minimum: FlowVersionString): boolean;
 
-/**
- * Writes compiled blocks into BlockNote's collaborative XmlFragment using the
- * ProseMirror/Yjs structure that BlockNote reads from collaboration.
- */
-declare function writeCompiledBlocksToFragment(fragment: Y.XmlFragment, blocks: CompiledBlock[]): void;
-/**
- * Remove a single block container by its block ID.
- * Returns `true` if the block was found and removed.
- */
-declare function removeBlockFromFragment(fragment: Y.XmlFragment, blockId: string): boolean;
-/**
- * Replace a block container in-place (same position) by its block ID.
- * Returns `true` if the block was found and replaced.
- */
-declare function replaceBlockInFragment(fragment: Y.XmlFragment, block: CompiledBlock): boolean;
-/**
- * Read all blocks (with their props) back out of the document fragment.
- *
- * The inverse of `writeCompiledBlocksToFragment` / `createBlockContainer`: walks the single
- * `blockGroup` and, for each `blockContainer`, returns `{ id, type, props }` where `props` is
- * the inner `blockContent` element's attributes — the **authoritative per-block prop store**
- * (the `qi.flow.nodes` map omits props, so this is the only place to recover them headlessly).
- *
- * `textColor`/`backgroundColor` are folded back into `props` only when non-`'default'`, so a
- * default-styled block round-trips to exactly its content props. Note: props written as `''`
- * are not persisted by `createBlockContainer`, so they do not reappear here.
- *
- * Returns `[]` when the fragment has no `blockGroup`.
- */
-declare function readBlocksFromFragment(fragment: Y.XmlFragment): CompiledBlock[];
-
-/**
- * A single flow node as read from a live Y.Doc, assembled from all three sources:
- * structure (`qi.flow.*`), per-block `props` (the `document` fragment), and per-block
- * `runtime` (the `runtime` map). `props` and `runtime` are what the graph map cannot provide.
- */
-interface FlowDocumentNode {
-    nodeId: string;
-    blockId: string;
-    can: string;
-    with: string;
-    title: string;
-    description: string;
-    /** Authoritative per-block props, recovered from the document fragment. */
-    props: Record<string, string>;
-    /** Per-block runtime; `{}` for a fresh/never-run node (e.g. a template). */
-    runtime: FlowNodeRuntimeState;
-}
-interface FlowDocumentRead {
-    meta: CompiledFlow['meta'];
-    order: string[];
-    edges: CompiledEdge[];
-    blockIndex: Record<string, string>;
-    nodes: FlowDocumentNode[];
-}
-/**
- * Read a flow document **losslessly** from a headless Y.Doc, in one call.
- *
- * Why this exists: `readCompiledFlowFromYDoc` returns nodes with **empty `props`** (the
- * `qi.flow.nodes` map omits props — they live only in the `document` fragment), and
- * `decompileToBaseUcanFlow` is lossy for the same reason. `readFlowDocument` merges the three
- * sources so a consumer (e.g. an authoring agent) sees the *true* current flow:
- *
- * - structure        ← `readCompiledFlowFromYDoc` (nodes, order, edges, `can`/`with`)
- * - per-block props   ← `readBlocksFromFragment` (inputs/conditions/trigger/ttl/icon/…)
- * - 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, runId?: string): FlowDocumentRead | null;
-interface AddFlowNodeOptions {
-    /** Registry action type, e.g. `'qi/form.submit'`. Must exist in the registry. */
-    type: string;
-    /** Insert into the logical order right after this node id; appended to the end if omitted. */
-    afterNodeId?: string;
-    /** Optional starting title (defaults to the action's `can` / type). */
-    title?: string;
-    /** Optional extra block props merged over the compiled defaults. */
-    props?: Record<string, string>;
-}
-/**
- * Add a step to the flow document — the inverse of `removeFlowNode`. Inserts an
- * attr-only `action` block into the `document` fragment and registers the
- * matching `qi.flow.*` structure (`nodes`, `blockIndex`, `order`) in one
- * transaction, mirroring exactly what the compiler's `hydrate` writes for a
- * single node. No recompile, no runtime entry (a template node is never-run).
- *
- * Returns the new ids, or `null` if `type` is not a known registry action.
- */
-declare function addFlowNode(yDoc: Doc, opts: AddFlowNodeOptions): {
-    nodeId: string;
-    blockId: string;
-} | null;
-/**
- * Edit one block's config props in place, in the `document` fragment. Surgical: it touches
- * only the target block (siblings untouched), does **not** recompile, and does **not** touch
- * the `runtime` map. Pass `''` for a prop to clear it (the writer drops empty values).
- *
- * Keeps the denormalized node-map fields in sync — `title`/`description` and the `actor`
- * object (derived from `authorisedActors`/`parentCapability`) live in BOTH the fragment and
- * `qi.flow.nodes`, so a fragment-only write would desync structural readers.
- *
- * Returns `false` when no block with `blockId` exists.
- */
-declare function setBlockProps(yDoc: Doc, blockId: string, partial: Record<string, string>): boolean;
-/**
- * Remove one step from the flow document — fragment block + `qi.flow.*` entries + its
- * `runtime` entry + any edges touching it — in one transaction. Siblings untouched.
- *
- * Guards against orphaning references: if another node's trigger, condition, or a
- * `{{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, runId?: string): {
-    ok: true;
-} | {
-    ok: false;
-    referencedBy: string[];
-};
-/**
- * Reorder the flow's steps. Always rewrites the logical order (`qi.flow.order`). Also
- * reorders the visual `document` fragment to match — but only when every block is an
- * attr-only compiled block; if the doc contains inline prose, the fragment is left untouched
- * (recreating it would lose content) and only the logical order changes.
- *
- * `order` must be a permutation of the current `qi.flow.order` (same ids, no dups); returns
- * `false` otherwise.
- */
-declare function reorderFlowNodes(yDoc: Doc, order: string[]): boolean;
-/**
- * Swap two step blocks by document position — the move-up/move-down primitive
- * for template authoring. Reorders the visual `document` fragment (so the change
- * is what the author sees), and keeps `qi.flow.order` consistent when BOTH
- * blocks are graph-registered nodes. Works for slash-menu ("legacy") blocks too,
- * since it operates on document position rather than the graph.
- *
- * 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 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, 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>, runId?: string): void;
-
-/**
- * The operator vocabulary the FE condition evaluator actually understands
- * (`src/mantine/blocks/utils/conditionEvaluator.ts`). The compiler historically wrote the
- * BaseUcan `ConditionRef` vocabulary (`eq`/`neq`/…) verbatim, which the evaluator does NOT
- * recognise (and no normalizer bridged them) — so those conditions silently never fired.
- * This module is the single source of truth that maps every supported spelling onto the
- * evaluator's vocabulary, and assembles the `props.conditions` JSON.
- */
-type EvaluatorOperator = 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains' | 'not_contains' | 'is_empty' | 'is_not_empty';
-/** Normalize any supported operator spelling to the evaluator's vocabulary. Unknown → `equals`. */
-declare function toEvaluatorOperator(operator: string): EvaluatorOperator;
-interface BlockConditionInput {
-    /** The BLOCK id of the source step (note: the stored shape keys on blockId, not nodeId). */
-    sourceBlockId: string;
-    /** Property on the source block to test. */
-    property: string;
-    /** Any supported operator spelling — normalized to the evaluator's vocabulary on write. */
-    operator: string;
-    value?: unknown;
-    effect?: {
-        action: 'enable' | 'disable' | 'show' | 'hide';
-        message?: string;
-    };
-    /** Source block type label; defaults to the compiled action type (`'action'`). */
-    sourceBlockType?: string;
-    name?: string;
-}
-/**
- * Build the `props.conditions` JSON string in the exact shape the FE evaluator reads, with
- * operators normalized to its vocabulary. Single source of truth for the conditions prop —
- * used by both the flow compiler (`compileCondition`) and direct authoring writes
- * (`setBlockProps('conditions', buildBlockConditionsProp(...))`), so a condition authored
- * either way actually evaluates.
- */
-declare function buildBlockConditionsProp(conditions: BlockConditionInput[], opts?: {
-    mode?: 'all_must_pass' | 'any_can_pass';
-    enabled?: boolean;
-}): string;
-
 interface ExecuteFlowAgentCoreCommandOptions {
     ucanService: UcanService;
     pin: string;
@@ -1261,6 +1412,212 @@ declare function computeCID(content: Uint8Array): Promise<string>;
  */
 declare function computeJsonCID(obj: Record<string, any>): Promise<string>;
 
+/**
+ * Writes compiled blocks into BlockNote's collaborative XmlFragment using the
+ * ProseMirror/Yjs structure that BlockNote reads from collaboration.
+ */
+declare function writeCompiledBlocksToFragment(fragment: Y.XmlFragment, blocks: CompiledBlock[]): void;
+/**
+ * Remove a single block container by its block ID.
+ * Returns `true` if the block was found and removed.
+ */
+declare function removeBlockFromFragment(fragment: Y.XmlFragment, blockId: string): boolean;
+/**
+ * Replace a block container in-place (same position) by its block ID.
+ * Returns `true` if the block was found and replaced.
+ */
+declare function replaceBlockInFragment(fragment: Y.XmlFragment, block: CompiledBlock): boolean;
+/**
+ * Read all blocks (with their props) back out of the document fragment.
+ *
+ * The inverse of `writeCompiledBlocksToFragment` / `createBlockContainer`: walks the single
+ * `blockGroup` and, for each `blockContainer`, returns `{ id, type, props }` where `props` is
+ * the inner `blockContent` element's attributes — the **authoritative per-block prop store**
+ * (the `qi.flow.nodes` map omits props, so this is the only place to recover them headlessly).
+ *
+ * `textColor`/`backgroundColor` are folded back into `props` only when non-`'default'`, so a
+ * default-styled block round-trips to exactly its content props. Note: props written as `''`
+ * are not persisted by `createBlockContainer`, so they do not reappear here.
+ *
+ * Returns `[]` when the fragment has no `blockGroup`.
+ */
+declare function readBlocksFromFragment(fragment: Y.XmlFragment): CompiledBlock[];
+
+/**
+ * A single flow node as read from a live Y.Doc, assembled from all three sources:
+ * structure (`qi.flow.*`), per-block `props` (the `document` fragment), and per-block
+ * `runtime` (the `runtime` map). `props` and `runtime` are what the graph map cannot provide.
+ */
+interface FlowDocumentNode {
+    nodeId: string;
+    blockId: string;
+    can: string;
+    with: string;
+    title: string;
+    description: string;
+    /** Authoritative per-block props, recovered from the document fragment. */
+    props: Record<string, string>;
+    /** Per-block runtime; `{}` for a fresh/never-run node (e.g. a template). */
+    runtime: FlowNodeRuntimeState;
+}
+interface FlowDocumentRead {
+    meta: CompiledFlow['meta'];
+    order: string[];
+    edges: CompiledEdge[];
+    blockIndex: Record<string, string>;
+    nodes: FlowDocumentNode[];
+}
+/**
+ * Read a flow document **losslessly** from a headless Y.Doc, in one call.
+ *
+ * Why this exists: `readCompiledFlowFromYDoc` returns nodes with **empty `props`** (the
+ * `qi.flow.nodes` map omits props — they live only in the `document` fragment), and
+ * `decompileToBaseUcanFlow` is lossy for the same reason. `readFlowDocument` merges the three
+ * sources so a consumer (e.g. an authoring agent) sees the *true* current flow:
+ *
+ * - structure        ← `readCompiledFlowFromYDoc` (nodes, order, edges, `can`/`with`)
+ * - per-block props   ← `readBlocksFromFragment` (inputs/conditions/trigger/ttl/icon/…)
+ * - 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, runId?: string): FlowDocumentRead | null;
+interface AddFlowNodeOptions {
+    /** Registry action type, e.g. `'qi/form.submit'`. Must exist in the registry. */
+    type: string;
+    /** Insert into the logical order right after this node id; appended to the end if omitted. */
+    afterNodeId?: string;
+    /** Optional starting title (defaults to the action's `can` / type). */
+    title?: string;
+    /** Optional extra block props merged over the compiled defaults. */
+    props?: Record<string, string>;
+}
+/**
+ * Add a step to the flow document — the inverse of `removeFlowNode`. Inserts an
+ * attr-only `action` block into the `document` fragment and registers the
+ * matching `qi.flow.*` structure (`nodes`, `blockIndex`, `order`) in one
+ * transaction, mirroring exactly what the compiler's `hydrate` writes for a
+ * single node. No recompile, no runtime entry (a template node is never-run).
+ *
+ * Returns the new ids, or `null` if `type` is not a known registry action.
+ */
+declare function addFlowNode(yDoc: Doc, opts: AddFlowNodeOptions): {
+    nodeId: string;
+    blockId: string;
+} | null;
+/**
+ * Edit one block's config props in place, in the `document` fragment. Surgical: it touches
+ * only the target block (siblings untouched), does **not** recompile, and does **not** touch
+ * the `runtime` map. Pass `''` for a prop to clear it (the writer drops empty values).
+ *
+ * Keeps the denormalized node-map fields in sync — `title`/`description` and the `actor`
+ * object (derived from `authorisedActors`/`parentCapability`) live in BOTH the fragment and
+ * `qi.flow.nodes`, so a fragment-only write would desync structural readers.
+ *
+ * Returns `false` when no block with `blockId` exists.
+ */
+declare function setBlockProps(yDoc: Doc, blockId: string, partial: Record<string, string>): boolean;
+/**
+ * Remove one step from the flow document — fragment block + `qi.flow.*` entries + its
+ * `runtime` entry + any edges touching it — in one transaction. Siblings untouched.
+ *
+ * Guards against orphaning references: if another node's trigger, condition, or a
+ * `{{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, runId?: string): {
+    ok: true;
+} | {
+    ok: false;
+    referencedBy: string[];
+};
+/**
+ * Reorder the flow's steps. Always rewrites the logical order (`qi.flow.order`). Also
+ * reorders the visual `document` fragment to match — but only when every block is an
+ * attr-only compiled block; if the doc contains inline prose, the fragment is left untouched
+ * (recreating it would lose content) and only the logical order changes.
+ *
+ * `order` must be a permutation of the current `qi.flow.order` (same ids, no dups); returns
+ * `false` otherwise.
+ */
+declare function reorderFlowNodes(yDoc: Doc, order: string[]): boolean;
+/**
+ * Swap two step blocks by document position — the move-up/move-down primitive
+ * for template authoring. Reorders the visual `document` fragment (so the change
+ * is what the author sees), and keeps `qi.flow.order` consistent when BOTH
+ * blocks are graph-registered nodes. Works for slash-menu ("legacy") blocks too,
+ * since it operates on document position rather than the graph.
+ *
+ * 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 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, 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>, runId?: string): void;
+
+/**
+ * The operator vocabulary the FE condition evaluator actually understands
+ * (`src/mantine/blocks/utils/conditionEvaluator.ts`). The compiler historically wrote the
+ * BaseUcan `ConditionRef` vocabulary (`eq`/`neq`/…) verbatim, which the evaluator does NOT
+ * recognise (and no normalizer bridged them) — so those conditions silently never fired.
+ * This module is the single source of truth that maps every supported spelling onto the
+ * evaluator's vocabulary, and assembles the `props.conditions` JSON.
+ */
+type EvaluatorOperator = 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'contains' | 'not_contains' | 'is_empty' | 'is_not_empty';
+/** Normalize any supported operator spelling to the evaluator's vocabulary. Unknown → `equals`. */
+declare function toEvaluatorOperator(operator: string): EvaluatorOperator;
+interface BlockConditionInput {
+    /** The BLOCK id of the source step (note: the stored shape keys on blockId, not nodeId). */
+    sourceBlockId: string;
+    /** Property on the source block to test. */
+    property: string;
+    /** Any supported operator spelling — normalized to the evaluator's vocabulary on write. */
+    operator: string;
+    value?: unknown;
+    effect?: {
+        action: 'enable' | 'disable' | 'show' | 'hide';
+        message?: string;
+    };
+    /** Source block type label; defaults to the compiled action type (`'action'`). */
+    sourceBlockType?: string;
+    name?: string;
+}
+/**
+ * Build the `props.conditions` JSON string in the exact shape the FE evaluator reads, with
+ * operators normalized to its vocabulary. Single source of truth for the conditions prop —
+ * used by both the flow compiler (`compileCondition`) and direct authoring writes
+ * (`setBlockProps('conditions', buildBlockConditionsProp(...))`), so a condition authored
+ * either way actually evaluates.
+ */
+declare function buildBlockConditionsProp(conditions: BlockConditionInput[], opts?: {
+    mode?: 'all_must_pass' | 'any_can_pass';
+    enabled?: boolean;
+}): string;
+
 declare const XERO_TOOLKIT = "xero";
 /**
  * The Xero account, organisation and bank account this flow acts through.
@@ -1395,4 +1752,4 @@ declare function createOracleInitFlowTemplate(): {
     nodes: FlowNode[];
 };
 
-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 CapabilityPatternCoversCanOptions, 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_ORACLE_WORKING_STATUSES, XERO_PAYMENT_CREATE_ACTION_TYPE, 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, actionTypeToCan, addFlowNode, appendRunTimelineEvent, appendRunTimelineEvents, boundRunActionOutput, boundRunEventJson, buildBlockConditionsProp, buildServicesFromHandlers, buildXeroInvoiceWorkKey, buildXeroPaymentWorkKey, canToActionType, canToType, capabilityPatternCoversCan, 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, normalizeCan, normalizeCapabilityPattern, 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, xeroOracleActivityForBlock, xeroOracleActivityForBlockForEditor };
+export { ACTION_MANIFEST_V2_SCHEMA, ACTION_MANIFEST_VERSION, ACTION_REGISTRY_VERSION, ActionDefinition, ActionDoneContract, ActionHandlers, type ActionManifest, type ActionManifestEntry, type ActionManifestIssue, type ActionManifestV2Action, type ActionManifestV2Compatibility, type ActionManifestV2Integrity, type ActionManifestV2Issuer, type ActionManifestV2Package, type ActionManifestV2Payload, type ActionManifestV2Primitive, type ActionManifestV2SignatureVerificationInput, type ActionManifestV2Signer, type ActionManifestV2TrustPolicy, ActionManifestV2VerificationError, type ActionManifestV2VerificationErrorCode, ActionReadBackMetadata, type ActionReadBackResolution, type ActionReadBackResolver, type ActionReadBackResolverInput, ActionResult, ActionRunContext, ActionServices, type AddFlowNodeOptions, type BlockCondition, type BlockConditionInput, type BlockConditionsResult, type BlockExecutionEligibility, type BoundedRunOutput, type CapabilityPatternCoversCanOptions, 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, type ExternalTopicExecutorPort, type ExternalTopicExecutorResult, 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, MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT, MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES, ManifestBoundTopicExecutorAdapter, type ManifestDoneDeclaration, type ManifestProofDeclaration, type ManifestV2JsonValue, 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, type SignedActionManifestV2, StoredDelegation, StoredInvocation, TopicActionBridge, TopicActionInvocationV1, TopicActionMetadata, TopicActionReceiptV2, TopicActionRecord, TopicActionWriteBackResult, TopicSemanticRecordDefinition, type TopicSemanticRecordValidationResult, UcanDelegationStore, UcanService, type UnresolvedReference, type UnresolvedReferenceReason, VERSION_MANIFEST, type VerifiedActionManifestV2, type VersionPolicy, XERO_ORACLE_WORKING_STATUSES, XERO_PAYMENT_CREATE_ACTION_TYPE, 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, actionManifestIssues, actionTypeToCan, addFlowNode, appendRunTimelineEvent, appendRunTimelineEvents, boundRunActionOutput, boundRunEventJson, buildBlockConditionsProp, buildServicesFromHandlers, buildXeroInvoiceWorkKey, buildXeroPaymentWorkKey, canToActionType, canToType, canonicalizeManifestV2Payload, capabilityPatternCoversCan, classifyBlockerCause, classifyNodeState, computeActionManifestV2Digest, computeCID, computeJsonCID, createMcpTopicExecutorAdapter, createOracleInitFlowTemplate, createQiForgeTopicExecutorAdapter, createReference, createRunEventIdempotencyKey, dispatchFlowStartTriggers, doneWhenCompleted, evaluateBlockConditions, evaluateBlockConditionsForRun, evaluateBlockExecutionEligibilityForRun, evaluateCondition, executeFlowAgentCoreCommand, executeQueuedFlowAgentCoreCommands, findXeroWorkItems, findXeroWorkItemsForEditor, generateActionManifest, getAction, getActionByCan, getActionForBlock, getActionPresentation, 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, normalizeCan, normalizeCapabilityPattern, 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, sha256Digest, signActionManifestV2, snapshotNode, swapFlowBlocks, toEvaluatorOperator, typeToCan, updateNodeRuntime, updateXeroWorkReviewPayload, updateXeroWorkReviewPayloadForEditor, upsertXeroWorkItem, upsertXeroWorkItemForEditor, validateActionProof, validateTopicSemanticRecord, validateTopicSemanticRecordBatch, verifyActionManifestV2, verifyCompletion, writeCompiledBlocksToFragment, writeRunRecordAndReconcile, xeroOracleActivityForBlock, xeroOracleActivityForBlockForEditor };