@ixo/editor 6.22.0 → 6.24.0

package/dist/store-wmrw3T5K.d.ts

@@ -0,0 +1,1039 @@
+import { a6 as FlowNode, a7 as FlowNodeAuthzExtension, F as FlowRuntimeStateManager, g as UcanService, I as InvocationStore, a8 as EvaluationStatus, a9 as IxoEditorType, aa as PendingInvocation, ab as ActionServices, ac as ActionHandlers, ad as RunEventAppender, ae as ActionResult, af as ActionDefinition, j as UcanCapability, ag as FlowNodeRuntimeState, U as UcanDelegationStore, S as StoredDelegation } from './index-x1R0c9P_.js';
+import * as Y from 'yjs';
+import { Doc, Map } from 'yjs';
+import { MatrixClient } from 'matrix-js-sdk';
+
+/** Condition that gates when a capability activates. */
+interface ConditionRef {
+    /** ID of the upstream capability whose output is checked. */
+    sourceId: string;
+    /** Output field path to inspect, e.g., "decision". */
+    field: string;
+    /** Comparison operator. */
+    operator: 'eq' | 'neq' | 'gt' | 'lt' | 'in' | 'exists';
+    /** Value to compare against (omit for 'exists'). */
+    value?: unknown;
+    /** What happens when the condition is (not) met. */
+    effect?: {
+        action: 'enable' | 'disable' | 'hide' | 'show';
+        message?: string;
+    };
+}
+/** Authorization constraint for a capability. */
+interface ActorConstraint {
+    /** Whitelisted actor DIDs. */
+    authorisedActors?: string[];
+    /** Parent capability URI for delegation chain. */
+    parentCapability?: string;
+}
+/** Time-to-live constraint for a capability. */
+interface TTLConstraint {
+    /** Hard deadline (ISO 8601 date string). */
+    absoluteDueDate?: string;
+    /** Duration from when the block becomes enabled (ISO 8601 duration, e.g., "P7D"). */
+    fromEnablement?: string;
+    /** Duration from when an actor commits (ISO 8601 duration, e.g., "PT2H"). */
+    fromCommitment?: string;
+}
+/**
+ * A single capability in a Base UCAN flow plan.
+ *
+ * UCAN semantics:
+ *   can  = the action
+ *   with = the resource or scope
+ *   nb   = typed caveats, inputs, parameters
+ *
+ * Workflow semantics (kept separate from nb):
+ *   condition, trigger, parallelGroup, phase
+ */
+interface FlowCapability {
+    /** Stable node identifier for this step. */
+    id: string;
+    /** UCAN-style ability string, e.g., "bid/submit", "email/send". */
+    can: string;
+    /** Resource URI, e.g., "ixo:flow:{flowId}" or "ixo:flow:{flowId}:{nodeId}". */
+    with: string;
+    /** Typed caveats / input parameters. Shape is dictated by the action registry. */
+    nb?: Record<string, unknown>;
+    /** Condition that must be met for this capability to activate. */
+    condition?: ConditionRef;
+    /** Capabilities sharing a parallelGroup run concurrently. */
+    parallelGroup?: string;
+    /** Semantic grouping for layout lanes. */
+    phase?: string;
+    /** Who can execute this step. */
+    actor?: ActorConstraint;
+    /** Time-to-live constraints. */
+    ttl?: TTLConstraint;
+    /**
+     * When and how this block fires. Defaults to `{ type: 'manual' }` if absent
+     * (i.e. block runs only when a user explicitly invokes it).
+     *
+     * `block.event` triggers turn this block into a listener: when the source
+     * block emits an event matching `eventName`, a pending invocation is
+     * queued on this block and the assigned actor is DM'd to invoke it. See
+     * `docs/flow-engine/events-and-triggers-plan.md` §3.7 and §18 for the full model.
+     *
+     * Triggers are a NEW sibling field on FlowCapability (decided in eng review
+     * pass 2 phase 0 #1). They are NOT an extension of `condition`. The decompile
+     * branch's author needs to add `props.trigger` parsing when their work merges.
+     */
+    trigger?: TriggerSpec;
+    /** Display title (falls back to can statement). */
+    title?: string;
+    /** Description of what this step does. */
+    description?: string;
+    /** Icon identifier. */
+    icon?: string;
+}
+/**
+ * Trigger declaration for a block. When and how it fires.
+ */
+/** A single event source in a barrier trigger. */
+interface TriggerSource {
+    /** ID of the block that emits the event. */
+    sourceBlockId: string;
+    /** Name of the event (must match an event declared on the source action's `events` vocabulary). */
+    eventName: string;
+    /** Namespace alias for payload access: `trigger.payload.<alias>.*` */
+    alias: string;
+    /**
+     * When `true`, this source does NOT block queuing — the barrier fires once all
+     * *required* (non-optional) sources have fired. If an optional source fired before
+     * the barrier completes, its payload is merged in; if it never fires, it's skipped.
+     * Defaults to `false` (required) for backward compatibility.
+     */
+    optional?: boolean;
+}
+interface TriggerSpec {
+    /**
+     * - `manual`: block runs only when a user explicitly invokes it (default).
+     * - `flow.start`: block runs when the flow execution begins.
+     * - `block.event`: block runs each time another block emits a matching event.
+     * - `block.event.all`: block runs once ALL listed sources have emitted (barrier/join).
+     */
+    type: 'manual' | 'flow.start' | 'block.event' | 'block.event.all';
+    /** Required when `type === 'block.event'`. ID of the block that emits the event. */
+    sourceBlockId?: string;
+    /** Required when `type === 'block.event'`. Name of the event (must match an event declared on the source action's `events` vocabulary). */
+    eventName?: string;
+    /** Required when `type === 'block.event.all'`. Array of event sources — ALL must fire before the listener is queued. */
+    sources?: TriggerSource[];
+}
+/**
+ * The Base UCAN flow plan — the intermediate representation between
+ * user intent and the compiled flow graph.
+ *
+ * capabilities is an ordered list. Each capability carries its own stable `id`.
+ */
+interface BaseUcanFlow {
+    kind: 'qi.flow.base-ucan';
+    version: '1.0';
+    flowId: string;
+    title: string;
+    goal?: string;
+    meta?: {
+        entityDid?: string;
+        flowUri?: string;
+        rootIssuer?: string;
+    };
+    /** Ordered capabilities, each with its own stable node ID. */
+    capabilities: FlowCapability[];
+}
+/** A reference to an upstream node's output field. Format: "nodeId.output.fieldPath" */
+interface RuntimeRef {
+    $ref: string;
+}
+declare function isRuntimeRef(value: unknown): value is RuntimeRef;
+/** A single block ready for insertion into BlockNote. */
+interface CompiledBlock {
+    /** Pre-generated stable block ID. */
+    id: string;
+    /** BlockNote block type (e.g., "action"). */
+    type: string;
+    /** Block props — all values are strings per BlockNote convention. */
+    props: Record<string, string>;
+}
+/**
+ * An edge in the flow graph. Currently only `kind: 'trigger'` edges are
+ * synthesized — they come from `block.event` triggers and represent the
+ * source → listener relationship visually on the canvas.
+ */
+interface CompiledEdge {
+    id: string;
+    source: string;
+    target: string;
+    kind: 'trigger';
+    condition?: ConditionRef;
+}
+/** A compiled flow node stored in qi.flow.nodes. */
+interface CompiledFlowNode {
+    id: string;
+    blockId: string;
+    can: string;
+    with: string;
+    registryType: string;
+    title: string;
+    description: string;
+    props: Record<string, string>;
+    phase?: string;
+    parallelGroup?: string;
+    actor?: ActorConstraint;
+}
+/** The complete compiled output from the Base UCAN compiler. */
+interface CompiledFlow {
+    /** Flow metadata for qi.flow.meta and Y.Map('root'). */
+    meta: {
+        flowId: string;
+        title: string;
+        goal?: string;
+        version: string;
+        flowOwnerDid: string;
+        flowUri?: string;
+        compiledAt: string;
+        compiledFrom: 'BaseUcanFlow';
+    };
+    /** Blocks to insert into BlockNote, in topological order. */
+    blocks: CompiledBlock[];
+    /** Flow graph nodes, keyed by node ID. */
+    nodes: Record<string, CompiledFlowNode>;
+    /** Dependency edges. */
+    edges: CompiledEdge[];
+    /** Topological order of node IDs. */
+    order: string[];
+    /** nodeId → blockId mapping. */
+    blockIndex: Record<string, string>;
+}
+/** Strategy for how a compiled flow is applied to an existing document. */
+type FlowStrategy = 'full' | 'merge' | 'patch';
+
+declare const buildAuthzFromProps: (props: Record<string, any>) => FlowNodeAuthzExtension;
+declare const buildFlowNodeFromBlock: (block: any) => FlowNode;
+
+/**
+ * Context passed to resolveRuntimeRefs when resolving inputs for a triggered
+ * listener block. The runtime constructs this from a PendingInvocation when
+ * the assignee invokes the listener.
+ *
+ * - `payload`: the frozen event payload, used to resolve `trigger.payload.*` refs
+ * - `refSnapshots`: frozen `nodeId.output.*` values captured at queue time,
+ *   used to resolve those refs against the moment of emission rather than
+ *   current state. See docs/flow-engine/events-and-triggers-plan.md §3.5.1 for the
+ *   Sally → Mike scenario this fixes.
+ */
+interface TriggerResolutionContext {
+    payload: Record<string, unknown>;
+    refSnapshots: Record<string, unknown>;
+}
+/**
+ * Resolve runtime references in an nb (caveats) object.
+ *
+ * At compile time, `{ "$ref": "nodeId.output.fieldPath" }` values are serialized
+ * as-is into the block's `inputs` JSON string. At execution time, this function
+ * replaces them with actual output values from upstream nodes.
+ *
+ * Two ref namespaces are supported:
+ *  - `nodeId.output.fieldPath` — looked up via `getNodeOutput`. When a
+ *    `triggerContext` is provided AND `refSnapshots[ref]` exists, the
+ *    snapshot is preferred over the live lookup. This is the load-bearing
+ *    fix for the lag-time scenario where multiple pending invocations are
+ *    queued and the source block re-runs before the assignee acts on them.
+ *  - `trigger.payload.fieldPath` — looked up in `triggerContext.payload`.
+ *    Only valid when `triggerContext` is provided (i.e. resolving inputs
+ *    for a triggered listener invocation). Compile-time validation in
+ *    compiler.ts guarantees these only appear on `block.event`-triggered
+ *    blocks.
+ *
+ * @param nb - The caveats object (may contain nested RuntimeRef values)
+ * @param getNodeOutput - Lookup function for upstream node outputs
+ * @param triggerContext - Optional, present only for triggered listener invocations
+ * @returns A new object with all $ref values resolved
+ */
+declare function resolveRuntimeRefs(nb: Record<string, unknown>, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined, triggerContext?: TriggerResolutionContext): Record<string, unknown>;
+
+interface NodeActionResult {
+    claimId?: string;
+    evaluationStatus?: EvaluationStatus;
+    submittedByDid?: string;
+    payload?: any;
+}
+interface ExecutionContext {
+    runtime: FlowRuntimeStateManager;
+    /** UCAN service — optional for v0.x flows, required for v1.0.0+ */
+    ucanService?: UcanService;
+    /** Invocation store — optional for v0.x flows */
+    invocationStore?: InvocationStore;
+    flowUri: string;
+    flowId: string;
+    /** Session run that owns runtime and invocation records for this execution. */
+    sessionRunId?: string;
+    flowOwnerDid: string;
+    /** Flow schema version. When set, controls whether UCAN is enforced. */
+    schemaVersion?: string;
+    now?: () => number;
+}
+interface ExecutionOutcome {
+    success: boolean;
+    stage: 'authorization' | 'claim' | 'action' | 'complete';
+    error?: string;
+    result?: NodeActionResult;
+    capabilityId?: string;
+    invocationCid?: string;
+}
+interface ExecuteNodeParams {
+    node: FlowNode;
+    actorDid: string;
+    actorType: 'entity' | 'user';
+    entityRoomId?: string;
+    context: ExecutionContext;
+    action: () => Promise<NodeActionResult>;
+    pin: string;
+}
+/**
+ * Execute a node.
+ *
+ * The pipeline adapts based on the flow's schema version (via context.schemaVersion):
+ *
+ * **v0.x (legacy):** activation → action → runtime update.
+ * UCAN authorization and invocations are skipped when ucanService is not available.
+ *
+ * **v1.0.0+:** activation → UCAN authorization → invocation → action → runtime update.
+ * Requires a configured ucanService with valid delegation chains.
+ */
+declare const executeNode: ({ node, actorDid, actorType, entityRoomId, context, action, pin }: ExecuteNodeParams) => Promise<ExecutionOutcome>;
+
+type ActionBlockLike = {
+    id?: string;
+    props?: Record<string, unknown>;
+};
+type EditorOrYDoc = IxoEditorType | Y.Doc;
+interface BuildActionRunInputsParams {
+    editorOrYDoc?: EditorOrYDoc | null;
+    block?: ActionBlockLike | null;
+    blockId?: string;
+    document?: ActionBlockLike[];
+    runtime?: FlowRuntimeStateManager;
+    savedInputs?: unknown;
+    runtimeInputs?: Record<string, unknown>;
+    pendingInvocationId?: string;
+    /**
+     * The **session run** this execution belongs to (`runs.ts`), not the
+     * per-execution audit id. Defaults to `resolveActiveRunId(yDoc)`, which is a
+     * constant in Phase A.
+     *
+     * D2: every *new* parameter named `runId` means the session run. The
+     * execution-scoped id keeps its historical name only where it is already
+     * persisted (`RunRecordDetails.runId`), and is surfaced going forward as
+     * {@link ExecuteActionBlockResult.executionId}.
+     */
+    runId?: string;
+}
+interface BuildActionRunInputsResult {
+    inputs: Record<string, unknown>;
+    savedInputs: Record<string, unknown>;
+    mergedInputs: Record<string, unknown>;
+    pendingInvocation?: PendingInvocation;
+    triggerContext?: TriggerResolutionContext;
+}
+type ActionExecutionCompletionState = 'completed' | 'failed' | 'awaiting_readback' | 'needs_verification';
+interface ExecuteActionBlockParams extends BuildActionRunInputsParams {
+    actorDid: string;
+    actorType: 'entity' | 'user';
+    entityRoomId?: string;
+    ucanService?: UcanService;
+    invocationStore?: InvocationStore;
+    services?: ActionServices;
+    handlers?: ActionHandlers;
+    runEventLog?: RunEventAppender;
+    pin?: string;
+    now?: () => number;
+    flowUri?: string;
+    flowId?: string;
+    flowOwnerDid?: string;
+    schemaVersion?: string;
+}
+interface ExecuteActionBlockResult {
+    success: boolean;
+    stage: ExecutionOutcome['stage'] | 'input' | 'action_lookup';
+    blockId: string;
+    actionType?: string;
+    output?: Record<string, unknown>;
+    events: NonNullable<ActionResult['events']>;
+    error?: string;
+    invocationCid?: string;
+    capabilityId?: string;
+    /**
+     * Id of the audit record this execution wrote (`run-<ts>-<rand>`).
+     *
+     * @deprecated Use {@link ExecuteActionBlockResult.executionId}. Both fields
+     * carry the same value and both stay populated — `flow-manager` and
+     * `flow-agent` read `runId` today, and `RunRecordDetails.runId` is persisted
+     * live data feeding `computePendingInvocationId`, so the *stored* name is
+     * never renamed.
+     *
+     * PHASE A COMPAT — REMOVAL TRIGGER: Phase B, once both orchestrators read
+     * `executionId` (compat register item 8).
+     */
+    runId?: string;
+    /**
+     * Forward name for the per-execution audit id. Identical to {@link runId}.
+     *
+     * D2: bare `runId` now means the *session* run everywhere in new code, so the
+     * execution id gets an unambiguous name rather than the persisted one being
+     * renamed out from under live rooms.
+     */
+    executionId?: string;
+    pendingInvocationRemoved?: boolean;
+    completionState: ActionExecutionCompletionState;
+    pendingInvocation?: PendingInvocation;
+}
+declare function buildActionRunInputs(params: BuildActionRunInputsParams): BuildActionRunInputsResult;
+declare function executeActionBlock(params: ExecuteActionBlockParams): Promise<ExecuteActionBlockResult>;
+
+interface AuthorizationResult {
+    authorized: boolean;
+    reason?: string;
+    capabilityId?: string;
+    proofCids?: string[];
+}
+/**
+ * Check if an actor is authorized to execute a block.
+ *
+ * Behaviour depends on the flow's schema version:
+ * - v0.x (or no version): UCAN is optional. If ucanService is unavailable,
+ *   execution is allowed without a delegation chain.
+ * - v1.0.0+: UCAN is required. A valid delegation chain must exist.
+ */
+declare const isAuthorized: (blockId: string, actorDid: string, ucanService: UcanService | undefined, flowUri: string, schemaVersion?: string) => Promise<AuthorizationResult>;
+
+/** Registry interface expected by the compiler (keeps it pure / testable). */
+interface CompilerRegistry {
+    getActionByCan(can: string): ActionDefinition | undefined;
+}
+/**
+ * Compile a Base UCAN flow plan into blocks, graph state, and metadata.
+ *
+ * This is a **pure function** — no React, no Yjs, no side effects.
+ * The output is consumed by `hydrateFlowFromPlan()`.
+ */
+declare function compileBaseUcanFlow(plan: BaseUcanFlow, registry: CompilerRegistry): CompiledFlow;
+
+/** Describes what changed when merging two compiled flows. */
+interface MergeResult {
+    /** The merged compiled flow (full state). */
+    merged: CompiledFlow;
+    /** Node IDs that were added (new in incoming, not in existing). */
+    added: string[];
+    /** Node IDs that were replaced (patch only — existed and was overwritten). */
+    replaced: string[];
+    /** Node IDs that were kept unchanged from existing. */
+    kept: string[];
+}
+/**
+ * Merge an incoming compiled flow into an existing one.
+ *
+ * This is a **pure function** — no Yjs, no side effects.
+ *
+ * Strategies:
+ * - `merge`: existing nodes win on ID collision. Incoming nodes with new IDs
+ *   are added. Existing nodes are never modified.
+ * - `patch`: incoming nodes overwrite existing nodes on ID collision. Incoming
+ *   nodes with new IDs are added. Existing nodes not in incoming are kept.
+ *
+ * Edges in the merged result are the union of edges from both sides, filtered
+ * to those whose source and target both exist in the merged node set, with
+ * duplicates collapsed by edge id. Order is the merged node insertion order
+ * (existing first, then newly added) — there is no topological sort because
+ * there is no inferred dependency relationship.
+ */
+declare function mergeCompiledFlows(existing: CompiledFlow, incoming: CompiledFlow, strategy: 'merge' | 'patch'): MergeResult;
+
+interface SetupFlowOptions {
+    /** The Base UCAN flow plan to compile. */
+    plan: BaseUcanFlow;
+    /** Matrix room ID to hydrate the flow into. */
+    roomId: string;
+    /** Authenticated Matrix client. */
+    matrixClient: MatrixClient;
+    /** DID of the user setting up the flow. */
+    creatorDid: string;
+    /** Optional doc ID override (defaults to plan.flowId). */
+    docId?: string;
+    /**
+     * Room ID of the template this flow was instantiated from, if any.
+     * Recorded into the root map as `source_template_id` for lineage tracking.
+     */
+    templateId?: string;
+    /**
+     * How to apply the plan to the existing document.
+     * - `full` (default): wipe existing flow state and rebuild entirely.
+     * - `merge`: keep existing blocks, add new capabilities from the plan.
+     * - `patch`: replace matching nodes, add new ones, keep the rest.
+     */
+    strategy?: FlowStrategy;
+}
+interface SetupFlowResult {
+    /** The compiled flow artifacts. */
+    compiled: CompiledFlow;
+    /** The room ID (same as input, for convenience). */
+    roomId: string;
+    /** The flow ID from the plan. */
+    flowId: string;
+}
+interface ReadFlowOptions {
+    /** Matrix room ID to read from. */
+    roomId: string;
+    /** Authenticated Matrix client. */
+    matrixClient: MatrixClient;
+}
+interface ReadFlowResult {
+    /** The current flow plan in BaseUcanFlow format (what the agent reads/writes). */
+    plan: BaseUcanFlow;
+    /** The compiled flow state (lower-level representation). */
+    compiled: CompiledFlow;
+    /** The room ID (same as input, for convenience). */
+    roomId: string;
+}
+/**
+ * Read the current Base UCAN flow plan from a Matrix room.
+ *
+ * Connects to the room, reads the Y.Doc, decompiles the flow state
+ * back into a `BaseUcanFlow`, and disconnects. Returns `null` if the
+ * room has no flow state.
+ *
+ * **This is the lower-level API.** It exists for cases where you need
+ * to read a flow from a room you are NOT currently editing — e.g.
+ * cross-room operations or background reads. For the common case of
+ * "read the flow the user is currently looking at," use
+ * `readFlowFromEditor(editor)` instead. That function takes no
+ * parameters from the agent and reads from the editor's existing
+ * Y.Doc directly — no Matrix connection, no async, no room ID
+ * resolution. The browser tool that exposes `read_flow` to the AI
+ * agent should wrap `readFlowFromEditor`, not this function.
+ */
+declare function readFlowAsBaseUcan(options: ReadFlowOptions): Promise<ReadFlowResult | null>;
+/**
+ * Minimal editor shape required by `readFlowFromEditor` and the active
+ * editor registry. The full `IxoEditorType` is fine to pass — this is
+ * just a structural lower bound so test harnesses can construct fake
+ * editors without pulling in React dependencies.
+ */
+interface ReadableEditor {
+    _yDoc?: Y.Doc;
+    getRoomId?: () => string;
+}
+/**
+ * Read the current flow from a specific editor instance, synchronously.
+ *
+ * Use this when you have an editor reference in hand (e.g. from inside a
+ * React component, a test, or a multi-editor host that needs to target a
+ * specific instance). For the common case of "read the flow the user is
+ * currently looking at," prefer the parameterless `readFlow()` below — it
+ * uses the active editor registry so you don't have to thread an editor
+ * reference through your call sites.
+ *
+ * Returns `null` ONLY when the editor's Y.Doc has no flow state at all
+ * (no nodes AND no meta). An empty `flowId` string is no longer treated
+ * as "no flow" — that was the historical bug where successful
+ * `setup_flow` calls authored with `flowId: ""` (the documented agent
+ * convention) showed up as null on subsequent reads.
+ */
+declare function readFlowFromEditor(editor: ReadableEditor): ReadFlowResult | null;
+/**
+ * Register an editor as the current active editor. Called by the editor's
+ * mount hook when the document is connected and ready. Pass `null` on
+ * unmount to clear the registry.
+ *
+ * If a different editor is already registered, it is replaced silently —
+ * the most recent registration wins. This matches the single-editor
+ * assumption above.
+ */
+declare function setActiveEditor(editor: ReadableEditor | null): void;
+/**
+ * Get the currently registered active editor, or null if none is set.
+ * Provided for cases where a caller wants to check the registry directly
+ * (e.g. for diagnostics) without going through `readFlow()`.
+ */
+declare function getActiveEditor(): ReadableEditor | null;
+/**
+ * Read the current flow from the active editor, with no parameters at all.
+ *
+ * This is the parameterless API the AI agent's `read_flow` browser tool
+ * should wrap. The browser tool literally becomes `read_flow: () => readFlow()`.
+ *
+ * Returns `null` if there is no active editor registered (e.g. the editor
+ * hasn't finished mounting yet, or no editor is open in this JS context),
+ * OR if the active editor's Y.Doc has no flow state at all.
+ *
+ * If `null` is returned and the user is referencing an existing flow, that
+ * is a hard signal to STOP and report to the user — never silently rebuild,
+ * because the duplicate-blocks bug is the inevitable consequence.
+ */
+declare function readFlow(): ReadFlowResult | null;
+/**
+ * One-shot function that compiles a Base UCAN flow plan and writes it
+ * into a Matrix room's Y.Doc. After this completes, the room is a
+ * normal flow that anyone can open via `useCreateCollaborativeIxoEditor`.
+ *
+ * Supports three strategies:
+ * - `full` (default): clears any existing flow and rebuilds from scratch.
+ * - `merge`: adds new capabilities alongside existing ones.
+ * - `patch`: replaces matching nodes and adds new ones.
+ */
+declare function setupFlowFromBaseUcan(options: SetupFlowOptions): Promise<SetupFlowResult>;
+
+/**
+ * Read the current compiled flow state from a live Y.Doc.
+ *
+ * This is the inverse of `hydrateYDocFromCompiledFlow`. It extracts the flow
+ * graph state from Yjs maps so that the pure merge/patch logic can operate
+ * on plain objects.
+ *
+ * Returns `null` if the document has no flow state.
+ */
+declare function readCompiledFlowFromYDoc(yDoc: Doc): CompiledFlow | null;
+
+/**
+ * Reconstruct a BaseUcanFlow plan from a CompiledFlow.
+ *
+ * This is the inverse of `compileBaseUcanFlow`. It allows the AI agent to
+ * read the current flow in the same format it writes — a plain capability
+ * list it can reason about, modify, and pass back to the compiler.
+ *
+ * This is a **pure function** — no Yjs, no side effects.
+ *
+ * Note: some information is lossy (e.g. conditions are stored as a JSON
+ * string in props and are not fully round-tripped back to ConditionRef).
+ * The core capability data (can, with, nb, trigger, actor, ttl, metadata)
+ * is fully preserved.
+ */
+declare function decompileToBaseUcanFlow(compiled: CompiledFlow): BaseUcanFlow;
+
+/**
+ * Top-level Y.Doc map holding the flow's **human** participant roster, keyed by
+ * Matrix user id. Deliberately not called "agents": everything under
+ * `lib/flowAgent/*` means an AI/oracle actor, and the two must not be conflated.
+ *
+ * This is template *configuration*, not execution state — the roster records who
+ * a flow is meant to be run with, at what Matrix power level, and which of the
+ * flow's connections (`connections.ts`) each of them needs access to, so that
+ * instantiating a template into a room can invite exactly those users and ask
+ * for exactly the right grants. It is therefore NOT cleared by
+ * `clearRuntimeForTemplateClone` (`flowEngine/runtime.ts`), which only clears
+ * observation/execution maps; a clone must carry the roster forward or the
+ * instantiated room comes up empty.
+ */
+declare const FLOW_PARTICIPANTS_MAP_KEY = "qi.flow.participants";
+type FlowParticipant = {
+    /** Matrix user id, e.g. `'@alice:matrix.example.org'`. */
+    userId: string;
+    /** Matrix power level; integer, `0` when unknown. */
+    powerLevel: number;
+    displayName?: string;
+    /** `mxc://` url. */
+    avatarUrl?: string;
+    /**
+     * Toolkit keys (`FlowConnection.toolkit`) this participant needs access to.
+     * Absent when the participant needs none.
+     */
+    requires?: string[];
+    /** Epoch ms. Supplied by the caller — this module never calls `Date.now()`. */
+    addedAt?: number;
+};
+/**
+ * Read the participant roster.
+ *
+ * Normalizes defensively rather than trusting the map: this is read against a
+ * live, replicated doc, so an entry can be observed mid-sync, written by an older
+ * client, or malformed outright. Anything that is not a `Y.Map` carrying a
+ * non-empty `userId` is skipped, and a read never throws.
+ *
+ * Order is stable across peers — `addedAt` ascending with unstamped entries last,
+ * tie-broken by `userId` — so a rendered roster does not reshuffle on every sync.
+ */
+declare function readFlowParticipants(yDoc: Doc): FlowParticipant[];
+/**
+ * Add a participant, or merge into the existing entry for the same `userId`.
+ *
+ * `addedAt` is write-once: an existing stamp is preserved so a later edit
+ * (a power-level bump, a display-name refresh) cannot reorder the roster.
+ * Optional string fields are merged — omit one to leave it as it is, pass `''`
+ * to clear it; `requires` follows the same rule with `[]` as the clearing value.
+ */
+declare function upsertFlowParticipant(yDoc: Doc, participant: FlowParticipant): void;
+/** Remove a participant. No-op when the roster has no entry for `userId`. */
+declare function removeFlowParticipant(yDoc: Doc, userId: string): void;
+/**
+ * Set an existing participant's power level. No-op when the participant is not on
+ * the roster — a power level alone carries no identity, so creating an entry from
+ * one would invent a participant nobody added.
+ */
+declare function setFlowParticipantPowerLevel(yDoc: Doc, userId: string, powerLevel: number): void;
+/**
+ * Replace the connections an existing participant needs access to. Pass `[]` to
+ * clear them. No-op when the participant is not on the roster, for the same
+ * reason as {@link setFlowParticipantPowerLevel}.
+ */
+declare function setFlowParticipantRequirements(yDoc: Doc, userId: string, requires: string[]): void;
+
+/**
+ * Top-level Y.Doc map holding the integrations a flow needs, keyed by toolkit
+ * slug. This is template *configuration* — "this flow talks to Xero, and needs
+ * an organisation and a bank account picked before it can run" — so it is NOT
+ * cleared by `clearRuntimeForTemplateClone` (`flowEngine/runtime.ts`), exactly
+ * like the participant roster: a clone that lost its requirements would come up
+ * looking ready while every integration call has nowhere to go.
+ */
+declare const FLOW_CONNECTIONS_MAP_KEY = "qi.flow.connections";
+/**
+ * Top-level Y.Doc map holding the concrete account/organisation/bank selections
+ * made for *this* flow, keyed by toolkit slug.
+ *
+ * Bindings are execution state, not configuration: they name one workspace's
+ * connected account. `clearRuntimeForTemplateClone` therefore clears this map —
+ * a template cloned out of a live flow must not carry another entity's Xero
+ * account into a room whose members were never granted access to it.
+ */
+declare const FLOW_CONNECTION_BINDINGS_MAP_KEY = "qi.flow.connectionBindings";
+/** Sub-selections a toolkit needs before it counts as satisfied. */
+type FlowConnectionRequirementKey = 'org' | 'bankAccount';
+type FlowConnection = {
+    /** Toolkit slug, e.g. `'xero'`. Also the map key — one entry per toolkit. */
+    toolkit: string;
+    label?: string;
+    /** Absent/false = required. True = the flow may start without it. */
+    optional?: boolean;
+    requires: FlowConnectionRequirementKey[];
+    /** Epoch ms. Supplied by the caller — this module never calls `Date.now()`. */
+    addedAt?: number;
+};
+type FlowConnectionBinding = {
+    /** Toolkit slug, e.g. `'xero'`. Also the map key — one entry per toolkit. */
+    toolkit: string;
+    connectedAccountId: string;
+    /** Entity the connection belongs to — guards template-copy across workspaces. */
+    entityDid: string;
+    /** Xero organisation (tenant). */
+    tenantId?: string;
+    /** Xero chart-of-accounts UUID for the bank/treasury account. */
+    bankAccountId?: string;
+    /** Epoch ms. Supplied by the caller — this module never calls `Date.now()`. */
+    boundAt?: number;
+    boundByDid?: string;
+};
+/**
+ * Read the connections a flow requires.
+ *
+ * Normalizes defensively rather than trusting the map: this is read against a
+ * live, replicated doc, so an entry can be observed mid-sync, written by an older
+ * client, or malformed outright. Anything that is not a `Y.Map` carrying a
+ * non-empty `toolkit` is skipped, and a read never throws.
+ *
+ * Order is stable across peers — `addedAt` ascending with unstamped entries last,
+ * tie-broken by `toolkit` — so a rendered list does not reshuffle on every sync.
+ */
+declare function readFlowConnections(yDoc: Doc): FlowConnection[];
+/**
+ * Add a connection, or merge into the existing entry for the same `toolkit`.
+ *
+ * `addedAt` is write-once: an existing stamp is preserved so a later edit (a
+ * label refresh, a requirement change) cannot reorder the list. `requires` is
+ * part of the connection's identity as a requirement and is always written —
+ * pass the full list. `optional` and the optional string fields are merged —
+ * omit one to leave it as it is, pass `''` (or `false`) to clear it.
+ */
+declare function upsertFlowConnection(yDoc: Doc, connection: FlowConnection): void;
+/** Remove a connection. No-op when the flow has no entry for `toolkit`. */
+declare function removeFlowConnection(yDoc: Doc, toolkit: string): void;
+/**
+ * Mark an existing connection optional or required. No-op when the flow has no
+ * entry for `toolkit` — a flag alone carries no identity, so creating an entry
+ * from one would invent a requirement nobody declared.
+ */
+declare function setFlowConnectionOptional(yDoc: Doc, toolkit: string, optional: boolean): void;
+/**
+ * Replace an existing connection's sub-selection requirements. No-op when the
+ * flow has no entry for `toolkit`, for the same reason as
+ * {@link setFlowConnectionOptional}.
+ */
+declare function setFlowConnectionRequires(yDoc: Doc, toolkit: string, requires: FlowConnectionRequirementKey[]): void;
+/**
+ * Read the concrete connection bindings for this flow.
+ *
+ * Normalized as defensively as {@link readFlowConnections}: an entry is skipped
+ * unless it carries the three fields that make a binding usable — `toolkit`,
+ * `connectedAccountId` and `entityDid`. A half-written binding is not a binding
+ * to a different account, it is no binding at all.
+ *
+ * Order is stable across peers — `boundAt` ascending with unstamped entries last,
+ * tie-broken by `toolkit`.
+ */
+declare function readFlowConnectionBindings(yDoc: Doc): FlowConnectionBinding[];
+/**
+ * Bind a toolkit to a connected account, or merge into the existing binding for
+ * the same `toolkit`.
+ *
+ * `boundAt` is write-once, so re-picking an organisation does not reorder the
+ * list. Optional string fields are merged — omit one to leave it as it is, pass
+ * `''` to clear it. Ignored unless `toolkit`, `connectedAccountId` and
+ * `entityDid` are all present: those three are what a binding *is*.
+ */
+declare function upsertFlowConnectionBinding(yDoc: Doc, binding: FlowConnectionBinding): void;
+/** Remove a binding. No-op when the flow has no binding for `toolkit`. */
+declare function removeFlowConnectionBinding(yDoc: Doc, toolkit: string): void;
+
+type FlowAgentPublicNodeState = 'Pending' | 'Blocked' | 'Overdue' | 'Done';
+type FlowAgentRunPhase = 'Running' | 'Validating' | 'Failed' | 'Archived';
+type FlowAgentBlockerCause = 'missing_input' | 'failed_upstream' | 'missing_ucan' | 'stale_config' | 'service_error' | 'external_confirmation_pending' | 'validation_mismatch' | 'unverified_completion' | 'awaiting_verification' | 'unknown';
+type FlowAgentCommandType = 'diagnose_blocker' | 'assign_actor' | 'notify_actor' | 'execute_action' | 'validate_external_state' | 'archive_flow' | 'propose_config_change';
+type FlowAgentCommandStatus = 'queued' | 'leased' | 'running' | 'confirmed' | 'awaiting_readback' | 'failed' | 'skipped';
+type FlowAgentLedgerEventType = 'agent.decision' | 'agent.command' | 'agent.validation' | 'agent.escalation' | 'agent.memory';
+interface FlowAgentActor {
+    did: string;
+    matrixUserId?: string;
+    displayName?: string;
+    skills?: string[];
+}
+interface FlowAgentLease {
+    id: string;
+    commandId: string;
+    sessionRunId: string;
+    nodeId: string;
+    actorDid: string;
+    acquiredAt: number;
+    expiresAt: number;
+    epoch: number;
+}
+interface FlowAgentNodeSnapshot {
+    nodeId: string;
+    blockType: string;
+    actionType?: string;
+    title?: string;
+    runtime: FlowNodeRuntimeState;
+    publicState: FlowAgentPublicNodeState;
+    blockerCause?: FlowAgentBlockerCause;
+    assigneeDid?: string;
+    dueAt?: number;
+    pendingInvocationCount: number;
+}
+interface FlowAgentCommandBase {
+    id: string;
+    type: FlowAgentCommandType;
+    flowId: string;
+    sessionRunId: string;
+    flowUri: string;
+    nodeId: string;
+    actorDid: string;
+    status: FlowAgentCommandStatus;
+    capability: UcanCapability;
+    idempotencyKey: string;
+    createdAt: number;
+    updatedAt: number;
+    reason: string;
+    payload: Record<string, unknown>;
+    lease?: FlowAgentLease;
+    error?: string;
+}
+type FlowAgentCommand = FlowAgentCommandBase;
+interface FlowAgentLedgerEvent {
+    id: string;
+    type: FlowAgentLedgerEventType;
+    flowId: string;
+    sessionRunId: string;
+    nodeId?: string;
+    commandId?: string;
+    actorDid: string;
+    timestamp: number;
+    details: Record<string, unknown>;
+}
+interface FlowAgentMaps {
+    outbox: Map<FlowAgentCommand>;
+    leases: Map<FlowAgentLease>;
+}
+interface FlowAgentPolicyDecision {
+    allowed: boolean;
+    reason: string;
+    capability: UcanCapability;
+    proofCids: string[];
+}
+interface FlowAgentContext {
+    yDoc: Doc;
+    editor?: IxoEditorType;
+    /** Planner targets, including executable actions and manual work nodes. */
+    blocks?: unknown[];
+    /** Full recursive document used to resolve condition source blocks. */
+    documentBlocks?: unknown[];
+    flowId: string;
+    sessionRunId: string;
+    flowUri: string;
+    actor: FlowAgentActor;
+    now?: () => number;
+}
+interface FlowAgentCommandResult {
+    commandId: string;
+    success: boolean;
+    output?: Record<string, unknown>;
+    confirmed?: boolean;
+    completionState?: ActionExecutionCompletionState;
+    status?: FlowAgentCommandStatus;
+    error?: string;
+}
+interface FlowAgentExecutor {
+    executeAction?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    assignActor?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    notifyActor?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    validateExternalState?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    archiveFlow?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    proposeConfigChange?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    diagnoseBlocker?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+}
+interface FlowAgentTickResult {
+    flowDone: boolean;
+    snapshots: FlowAgentNodeSnapshot[];
+    queuedCommands: FlowAgentCommand[];
+    executedCommands: FlowAgentCommandResult[];
+}
+
+interface CreateAgentCommandParams {
+    type: FlowAgentCommandType;
+    flowId: string;
+    sessionRunId: string;
+    flowUri: string;
+    nodeId: string;
+    actor: FlowAgentActor;
+    reason: string;
+    payload?: Record<string, unknown>;
+    now?: number;
+}
+declare function createAgentCommand({ type, flowId, sessionRunId, flowUri, nodeId, actor, reason, payload, now }: CreateAgentCommandParams): FlowAgentCommand;
+declare function validateAgentCommand(command: FlowAgentCommand): {
+    valid: boolean;
+    error?: string;
+};
+declare function isExternalMutation(type: FlowAgentCommandType): boolean;
+
+interface BuildFlowAgentContextParams {
+    yDoc: Doc;
+    flowId: string;
+    sessionRunId: string;
+    flowUri?: string;
+    actor: FlowAgentActor;
+    blocks?: unknown[];
+    documentBlocks?: unknown[];
+    editor?: IxoEditorType;
+    now?: () => number;
+}
+/**
+ * Builds the host-facing runtime context expected by the Flow Agent.
+ *
+ * Headless hosts own Matrix login, room joins, and Y.Doc sync. Once a host has
+ * a live room document and an agent identity, this helper gives it the stable
+ * context shape to pass into `tickFlowAgent` or `FlowAgentService`.
+ */
+declare function buildFlowAgentContext({ yDoc, flowId, sessionRunId, flowUri, actor, blocks, documentBlocks, editor, now, }: BuildFlowAgentContextParams): FlowAgentContext;
+
+interface AcquireFlowAgentLeaseParams {
+    leases: Map<FlowAgentLease>;
+    commandId: string;
+    sessionRunId: string;
+    nodeId: string;
+    actorDid: string;
+    now?: number;
+    ttlMs?: number;
+}
+declare function acquireFlowAgentLease({ leases, commandId, sessionRunId, nodeId, actorDid, now, ttlMs, }: AcquireFlowAgentLeaseParams): FlowAgentLease | null;
+declare function validateFlowAgentLease(leases: Map<FlowAgentLease>, lease: FlowAgentLease, now?: number): boolean;
+declare function releaseFlowAgentLease(leases: Map<FlowAgentLease>, lease: FlowAgentLease): boolean;
+declare function cleanupExpiredFlowAgentLeases(leases: Map<FlowAgentLease>, now?: number): FlowAgentLease[];
+
+declare function requiredCapabilityForCommand(type: FlowAgentCommandType, flowUri: string, nodeId: string): UcanCapability;
+declare function isCapabilityMatch(granted: UcanCapability, required: UcanCapability): boolean;
+/**
+ * Match a granted capability pattern against a required `can`.
+ *
+ * ⚠️ This is the **trusted flow-agent policy** matcher: it allows the global
+ * `'*'` wildcard, so a delegation granting `can: '*'` matches every ability.
+ * It is re-exported from `src/core/index.ts` — do not use it to gate public or
+ * untrusted matching. For that, call `capabilityPatternCoversCan` directly and
+ * leave `allowGlobalWildcard` off (the default), which rejects `'*'`.
+ *
+ * Note: the granted side is normalized (`normalizeCan`), so dotted legacy
+ * grants such as `flow.notify` / `flow.*` now match `flow/notify` where they
+ * were previously inert.
+ */
+declare function canMatches(granted: string, required: string): boolean;
+declare function resourceMatches(granted: string, required: string): boolean;
+interface EvaluateFlowAgentPolicyParams {
+    actorDid: string;
+    commandType: FlowAgentCommandType;
+    flowUri: string;
+    nodeId: string;
+    delegationStore?: UcanDelegationStore;
+    delegations?: StoredDelegation[];
+    now?: number;
+}
+declare function evaluateFlowAgentPolicy({ actorDid, commandType, flowUri, nodeId, delegationStore, delegations, now, }: EvaluateFlowAgentPolicyParams): FlowAgentPolicyDecision;
+
+interface FlowAgentOrchestratorOptions {
+    delegationStore?: UcanDelegationStore;
+    delegations?: StoredDelegation[];
+    candidateActors?: FlowAgentActor[];
+    executor?: FlowAgentExecutor;
+    leaseTtlMs?: number;
+    archiveWhenDone?: boolean;
+}
+declare function planRalphLoopCommands(context: FlowAgentContext, options?: FlowAgentOrchestratorOptions): {
+    snapshots: FlowAgentNodeSnapshot[];
+    queuedCommands: FlowAgentCommand[];
+    flowDone: boolean;
+};
+declare function executeQueuedAgentCommands(context: FlowAgentContext, options?: FlowAgentOrchestratorOptions): Promise<FlowAgentCommandResult[]>;
+declare function tickFlowAgent(context: FlowAgentContext, options?: FlowAgentOrchestratorOptions): Promise<FlowAgentTickResult>;
+
+interface FlowAgentServiceOptions extends FlowAgentOrchestratorOptions {
+    intervalMs?: number;
+    onTick?: (result: FlowAgentTickResult) => void | Promise<void>;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Headless-service adapter boundary.
+ *
+ * Host applications own Matrix login, room joins, and Y.Doc sync. Once they
+ * have a live Y.Doc/editor snapshot, this service provides the deterministic
+ * Ralph-loop tick and command execution cycle.
+ */
+declare class FlowAgentService {
+    private readonly context;
+    private readonly options;
+    private timer;
+    private running;
+    constructor(context: FlowAgentContext, options?: FlowAgentServiceOptions);
+    tick(): Promise<FlowAgentTickResult>;
+    start(): void;
+    stop(): void;
+}
+
+declare function getFlowAgentMaps(yDoc: Doc): FlowAgentMaps;
+declare function computeAgentCommandId(params: {
+    flowId: string;
+    sessionRunId: string;
+    nodeId: string;
+    type: string;
+    payload: Record<string, unknown>;
+}): string;
+declare function queueAgentCommand(yDoc: Doc, command: FlowAgentCommand): {
+    command: FlowAgentCommand;
+    created: boolean;
+};
+/** Read every command for one session without creating the outbox map. */
+declare function readAgentCommands(yDoc: Doc, sessionRunId?: string): FlowAgentCommand[];
+declare function readQueuedAgentCommands(yDoc: Doc, sessionRunId?: string): FlowAgentCommand[];
+/** Read every lease for one session without creating the leases map. */
+declare function readFlowAgentLeases(yDoc: Doc, sessionRunId?: string): FlowAgentLease[];
+declare function updateAgentCommand(yDoc: Doc, commandId: string, patch: Partial<FlowAgentCommand>): FlowAgentCommand | null;
+declare function appendAgentLedgerEvent(yDoc: Doc, event: Omit<FlowAgentLedgerEvent, 'id'> & {
+    id?: string;
+}): FlowAgentLedgerEvent;
+declare function readAgentLedgerEvents(yDoc: Doc, eventType?: FlowAgentLedgerEventType, sessionRunId?: string): FlowAgentLedgerEvent[];
+
+export { buildFlowAgentContext as $, type AuthorizationResult as A, readFlowConnectionBindings as B, upsertFlowConnectionBinding as C, removeFlowConnectionBinding as D, type ExecuteNodeParams as E, FLOW_PARTICIPANTS_MAP_KEY as F, FLOW_CONNECTIONS_MAP_KEY as G, FLOW_CONNECTION_BINDINGS_MAP_KEY as H, type SetupFlowResult as I, type ReadFlowResult as J, type ReadableEditor as K, type CompilerRegistry as L, type MergeResult as M, type NodeActionResult as N, type FlowParticipant as O, type FlowConnection as P, type FlowConnectionBinding as Q, type ReadFlowOptions as R, type SetupFlowOptions as S, type FlowConnectionRequirementKey as T, type BaseUcanFlow as U, type FlowCapability as V, type CompiledFlow as W, type FlowStrategy as X, FlowAgentService as Y, acquireFlowAgentLease as Z, appendAgentLedgerEvent as _, buildAuthzFromProps as a, type TriggerSpec as a$, cleanupExpiredFlowAgentLeases as a0, createAgentCommand as a1, evaluateFlowAgentPolicy as a2, executeQueuedAgentCommands as a3, getFlowAgentMaps as a4, planRalphLoopCommands as a5, queueAgentCommand as a6, readAgentLedgerEvents as a7, readQueuedAgentCommands as a8, releaseFlowAgentLease as a9, isCapabilityMatch as aA, isExternalMutation as aB, readAgentCommands as aC, readFlowAgentLeases as aD, requiredCapabilityForCommand as aE, resourceMatches as aF, updateAgentCommand as aG, type AcquireFlowAgentLeaseParams as aH, type CreateAgentCommandParams as aI, type EvaluateFlowAgentPolicyParams as aJ, type FlowAgentOrchestratorOptions as aK, type FlowAgentServiceOptions as aL, type FlowAgentCommandBase as aM, type FlowAgentCommandStatus as aN, type FlowAgentCommandType as aO, type FlowAgentLedgerEvent as aP, type FlowAgentLedgerEventType as aQ, type FlowAgentMaps as aR, type FlowAgentPolicyDecision as aS, type FlowAgentRunPhase as aT, resolveRuntimeRefs as aU, type TriggerResolutionContext as aV, type ConditionRef as aW, type ActorConstraint as aX, type TTLConstraint as aY, type RuntimeRef as aZ, type CompiledFlowNode as a_, tickFlowAgent as aa, validateAgentCommand as ab, validateFlowAgentLease as ac, type BuildFlowAgentContextParams as ad, type FlowAgentActor as ae, type FlowAgentCommand as af, type FlowAgentCommandResult as ag, type FlowAgentContext as ah, type FlowAgentExecutor as ai, type FlowAgentLease as aj, type FlowAgentNodeSnapshot as ak, type FlowAgentPublicNodeState as al, type FlowAgentTickResult as am, type CompiledBlock as an, type CompiledEdge as ao, type FlowAgentBlockerCause as ap, buildActionRunInputs as aq, executeActionBlock as ar, type ActionBlockLike as as, type ActionExecutionCompletionState as at, type BuildActionRunInputsParams as au, type BuildActionRunInputsResult as av, type ExecuteActionBlockParams as aw, type ExecuteActionBlockResult as ax, canMatches as ay, computeAgentCommandId as az, buildFlowNodeFromBlock as b, isRuntimeRef as b0, type ExecutionOutcome as c, type ExecutionContext as d, executeNode as e, readFlowFromEditor as f, readFlow as g, setActiveEditor as h, isAuthorized as i, getActiveEditor as j, compileBaseUcanFlow as k, readCompiledFlowFromYDoc as l, mergeCompiledFlows as m, decompileToBaseUcanFlow as n, readFlowParticipants as o, removeFlowParticipant as p, setFlowParticipantPowerLevel as q, readFlowAsBaseUcan as r, setupFlowFromBaseUcan as s, setFlowParticipantRequirements as t, upsertFlowParticipant as u, readFlowConnections as v, upsertFlowConnection as w, removeFlowConnection as x, setFlowConnectionOptional as y, setFlowConnectionRequires as z };