@ixo/editor 6.31.0 → 6.31.2

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-B24zj0RI.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-B24zj0RI.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-DFPayq89.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-DFPayq89.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,81 @@ 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.
  *
- * 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`.
+ * 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.
+ *
+ * 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}`;
+
+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 +310,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 +876,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 +1118,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 +1458,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_VERSION, ACTION_REGISTRY_VERSION, ActionDefinition, ActionDoneContract, ActionHandlers, type ActionManifest, type ActionManifestEntry, type ActionManifestIssue, 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, 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, TopicActionBridge, TopicActionInvocationV1, TopicActionMetadata, TopicActionReceiptV2, TopicActionRecord, TopicActionWriteBackResult, TopicSemanticRecordDefinition, type TopicSemanticRecordValidationResult, 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, actionManifestIssues, actionTypeToCan, addFlowNode, appendRunTimelineEvent, appendRunTimelineEvents, boundRunActionOutput, boundRunEventJson, buildBlockConditionsProp, buildServicesFromHandlers, buildXeroInvoiceWorkKey, buildXeroPaymentWorkKey, canToActionType, canToType, capabilityPatternCoversCan, classifyBlockerCause, classifyNodeState, 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, snapshotNode, swapFlowBlocks, toEvaluatorOperator, typeToCan, updateNodeRuntime, updateXeroWorkReviewPayload, updateXeroWorkReviewPayloadForEditor, upsertXeroWorkItem, upsertXeroWorkItemForEditor, validateActionProof, validateTopicSemanticRecord, validateTopicSemanticRecordBatch, verifyCompletion, writeCompiledBlocksToFragment, writeRunRecordAndReconcile, xeroOracleActivityForBlock, xeroOracleActivityForBlockForEditor };