@ixo/editor 3.6.0 → 3.8.0

package/dist/core/index.d.ts

@@ -1,6 +1,6 @@
-import { n as ActionDefinition, o as ActionServices } from '../setup-mrrJlbcA.mjs';
-export { q as ActionContext, r as ActionResult, h as ActivationResult, u as ActorConstraint, A as AuthorizationResult, B as BaseUcanFlow, v as CompiledBlock, w as CompiledEdge, m as CompiledFlow, x as CompiledFlowNode, C as CompilerRegistry, t as ConditionRef, E as ExecuteNodeParams, g as ExecutionContext, f as ExecutionOutcome, l as FlowCapability, F as FlowRuntimeStateManager, N as NodeActionResult, O as OutputSchemaField, R as RuntimeRef, S as SetupFlowOptions, k as SetupFlowResult, T as TTLConstraint, d as buildAuthzFromProps, b as buildFlowNodeFromBlock, p as clearRuntimeForTemplateClone, j as compileBaseUcanFlow, c as createRuntimeStateManager, e as executeNode, i as isAuthorized, a as isNodeActive, y as isRuntimeRef, s as setupFlowFromBaseUcan } from '../setup-mrrJlbcA.mjs';
-export { A as ActivationCondition, C as ClaimCollectionURI, G as CreateDelegationParams, H as CreateInvocationParams, B as CreateRootDelegationParams, s as DID, D as DelegationChainValidationResult, k as DelegationGrant, E as EvaluationStatus, y as ExecutionWithInvocationResult, z as FindProofsResult, v as FlowNode, F as FlowNodeAuthzExtension, u as FlowNodeBase, t as FlowNodeRuntimeState, w as InvocationRequest, x as InvocationResult, I as InvocationStore, L as LinkedClaim, N as NodeState, S as StoredDelegation, j as StoredInvocation, i as UcanCapability, U as UcanDelegationStore, f as UcanService, g as UcanServiceConfig, h as UcanServiceHandlers, b as createInvocationStore, d as createMemoryInvocationStore, a as createMemoryUcanDelegationStore, c as createUcanDelegationStore, e as createUcanService } from '../index-MLwb3a2P.mjs';
+import { x as ActionDefinition, y as ActionServices } from '../decompile-BroSNv1q.mjs';
+export { D as ActionContext, G as ActionResult, I as ActorConstraint, A as AuthorizationResult, B as BaseUcanFlow, K as CompiledBlock, L as CompiledEdge, v as CompiledFlow, P as CompiledFlowNode, C as CompilerRegistry, H as ConditionRef, E as ExecuteNodeParams, f as ExecutionContext, d as ExecutionOutcome, u as FlowCapability, F as FlowRuntimeStateManager, w as FlowStrategy, M as MergeResult, N as NodeActionResult, O as OutputSchemaField, R as ReadFlowOptions, q as ReadFlowResult, J as RuntimeRef, S as SetupFlowOptions, p as SetupFlowResult, T as TTLConstraint, a as buildAuthzFromProps, b as buildFlowNodeFromBlock, z as clearRuntimeForTemplateClone, l as compileBaseUcanFlow, c as createRuntimeStateManager, o as decompileToBaseUcanFlow, e as executeNode, k as getActiveEditor, i as isAuthorized, Q as isRuntimeRef, n as mergeCompiledFlows, m as readCompiledFlowFromYDoc, h as readFlow, r as readFlowAsBaseUcan, g as readFlowFromEditor, j as setActiveEditor, s as setupFlowFromBaseUcan } from '../decompile-BroSNv1q.mjs';
+export { C as ClaimCollectionURI, B as CreateDelegationParams, G as CreateInvocationParams, A as CreateRootDelegationParams, s as DID, D as DelegationChainValidationResult, k as DelegationGrant, E as EvaluationStatus, y as ExecutionWithInvocationResult, z as FindProofsResult, v as FlowNode, F as FlowNodeAuthzExtension, u as FlowNodeBase, t as FlowNodeRuntimeState, w as InvocationRequest, x as InvocationResult, I as InvocationStore, L as LinkedClaim, N as NodeState, S as StoredDelegation, j as StoredInvocation, i as UcanCapability, U as UcanDelegationStore, f as UcanService, g as UcanServiceConfig, h as UcanServiceHandlers, b as createInvocationStore, d as createMemoryInvocationStore, a as createMemoryUcanDelegationStore, c as createUcanDelegationStore, e as createUcanService } from '../index-BEoftwDZ.mjs';
 import 'yjs';
 import 'matrix-js-sdk';
 import '@blocknote/core';
@@ -37,6 +37,21 @@ declare function getAllCanMappings(): ReadonlyArray<{
  */
 declare function buildServicesFromHandlers(handlers: any): ActionServices;
 
+/**
+ * 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/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.
  *
@@ -44,11 +59,24 @@ declare function buildServicesFromHandlers(handlers: any): ActionServices;
  * 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): Record<string, unknown>;
+declare function resolveRuntimeRefs(nb: Record<string, unknown>, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined, triggerContext?: TriggerResolutionContext): Record<string, unknown>;
 
 /**
  * Compute an IPFS-compatible CID for arbitrary content.

package/dist/core/index.mjs

@@ -1,32 +1,39 @@
 import {
-  compileBaseUcanFlow,
-  isRuntimeRef,
-  resolveRuntimeRefs,
-  setupFlowFromBaseUcan
-} from "../chunk-VG4NLEZB.mjs";
+  resolveRuntimeRefs
+} from "../chunk-FXFKKA6L.mjs";
 import {
   buildAuthzFromProps,
   buildFlowNodeFromBlock,
   buildServicesFromHandlers,
   canToType,
   clearRuntimeForTemplateClone,
+  compileBaseUcanFlow,
   createInvocationStore,
   createMemoryInvocationStore,
   createMemoryUcanDelegationStore,
   createRuntimeStateManager,
   createUcanDelegationStore,
   createUcanService,
+  decompileToBaseUcanFlow,
   executeNode,
   getAction,
   getActionByCan,
+  getActiveEditor,
   getAllActions,
   getAllCanMappings,
   hasAction,
   isAuthorized,
-  isNodeActive,
+  isRuntimeRef,
+  mergeCompiledFlows,
+  readCompiledFlowFromYDoc,
+  readFlow,
+  readFlowAsBaseUcan,
+  readFlowFromEditor,
   registerAction,
+  setActiveEditor,
+  setupFlowFromBaseUcan,
   typeToCan
-} from "../chunk-UBCN5SXM.mjs";
+} from "../chunk-QIJA3CMG.mjs";
 import {
   computeCID,
   computeJsonCID
@@ -46,17 +53,24 @@ export {
   createRuntimeStateManager,
   createUcanDelegationStore,
   createUcanService,
+  decompileToBaseUcanFlow,
   executeNode,
   getAction,
   getActionByCan,
+  getActiveEditor,
   getAllActions,
   getAllCanMappings,
   hasAction,
   isAuthorized,
-  isNodeActive,
   isRuntimeRef,
+  mergeCompiledFlows,
+  readCompiledFlowFromYDoc,
+  readFlow,
+  readFlowAsBaseUcan,
+  readFlowFromEditor,
   registerAction,
   resolveRuntimeRefs,
+  setActiveEditor,
   setupFlowFromBaseUcan,
   typeToCan
 };

package/dist/{setup-mrrJlbcA.d.ts → decompile-BroSNv1q.d.ts}

@@ -1,4 +1,5 @@
-import { v as FlowNode, F as FlowNodeAuthzExtension, t as FlowNodeRuntimeState, J as IxoEditorType, f as UcanService, I as InvocationStore, E as EvaluationStatus } from './index-MLwb3a2P.mjs';
+import { v as FlowNode, F as FlowNodeAuthzExtension, t as FlowNodeRuntimeState, H as IxoEditorType, f as UcanService, I as InvocationStore, E as EvaluationStatus } from './index-BEoftwDZ.mjs';
+import * as Y from 'yjs';
 import { Doc } from 'yjs';
 import { MatrixClient } from 'matrix-js-sdk';
 
@@ -43,7 +44,7 @@ interface TTLConstraint {
  *   nb   = typed caveats, inputs, parameters
  *
  * Workflow semantics (kept separate from nb):
- *   dependsOn, condition, parallelGroup, phase
+ *   condition, trigger, parallelGroup, phase
  */
 interface FlowCapability {
     /** Stable node identifier for this step. */
@@ -54,8 +55,6 @@ interface FlowCapability {
     with: string;
     /** Typed caveats / input parameters. Shape is dictated by the action registry. */
     nb?: Record<string, unknown>;
-    /** IDs of upstream capabilities this depends on. */
-    dependsOn?: string[];
     /** Condition that must be met for this capability to activate. */
     condition?: ConditionRef;
     /** Capabilities sharing a parallelGroup run concurrently. */
@@ -66,6 +65,20 @@ interface FlowCapability {
     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/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. */
@@ -73,6 +86,21 @@ interface FlowCapability {
     /** Icon identifier. */
     icon?: string;
 }
+/**
+ * Trigger declaration for a block. When and how it fires.
+ */
+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.
+     */
+    type: 'manual' | 'flow.start' | 'block.event';
+    /** 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;
+}
 /**
  * The Base UCAN flow plan — the intermediate representation between
  * user intent and the compiled flow graph.
@@ -107,12 +135,16 @@ interface CompiledBlock {
     /** Block props — all values are strings per BlockNote convention. */
     props: Record<string, string>;
 }
-/** A dependency edge in the flow graph. */
+/**
+ * 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: 'dependency';
+    kind: 'trigger';
     condition?: ConditionRef;
 }
 /** A compiled flow node stored in qi.flow.nodes. */
@@ -125,7 +157,6 @@ interface CompiledFlowNode {
     title: string;
     description: string;
     props: Record<string, string>;
-    dependsOn: string[];
     phase?: string;
     parallelGroup?: string;
     actor?: ActorConstraint;
@@ -154,6 +185,8 @@ interface CompiledFlow {
     /** 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;
@@ -164,9 +197,13 @@ interface FlowRuntimeStateManager {
 }
 declare const createRuntimeStateManager: (editor?: IxoEditorType | null) => FlowRuntimeStateManager;
 /**
- * Clears runtime and invocations from a Y.Doc.
+ * Clears runtime, invocations, and pending invocations from a Y.Doc.
  * Used when cloning a flow as a template — the new document should
  * carry only configuration (intent), not execution history.
+ *
+ * The audit trail (which now also holds run records as `type: 'block.run'`
+ * entries) and pending invocations are observation, not configuration —
+ * both are cleared on template clone.
  */
 declare function clearRuntimeForTemplateClone(yDoc: Doc): void;
 
@@ -191,7 +228,7 @@ interface ExecutionContext {
 }
 interface ExecutionOutcome {
     success: boolean;
-    stage: 'activation' | 'authorization' | 'claim' | 'action' | 'complete';
+    stage: 'authorization' | 'claim' | 'action' | 'complete';
     error?: string;
     result?: NodeActionResult;
     capabilityId?: string;
@@ -235,12 +272,6 @@ interface AuthorizationResult {
  */
 declare const isAuthorized: (blockId: string, actorDid: string, ucanService: UcanService | undefined, flowUri: string, schemaVersion?: string) => Promise<AuthorizationResult>;
 
-interface ActivationResult {
-    active: boolean;
-    reason?: string;
-}
-declare const isNodeActive: (node: FlowNode, runtime: FlowRuntimeStateManager) => ActivationResult;
-
 interface ActionContext {
     actorDid: string;
     flowId: string;
@@ -386,6 +417,30 @@ interface OutputSchemaField {
     type: 'string' | 'number' | 'boolean' | 'object' | 'array';
     description?: string;
 }
+/**
+ * A typed event that an action can emit when it runs.
+ *
+ * Events drive the trigger/listener model: another block can declare a
+ * `block.event` trigger on a (sourceBlockId, eventName) pair, and when this
+ * action emits a matching event, a pending invocation is queued on the
+ * listener block. See `docs/events-and-triggers-plan.md` for the full model.
+ */
+interface ActionEventDefinition {
+    /** Stable identifier — used in trigger declarations and ref strings. */
+    name: string;
+    /** Human-readable label shown in the trigger picker UI. */
+    displayName: string;
+    /** Short description shown as inline hint in the trigger picker. */
+    description: string;
+    /** Schema of the event payload. Same shape as `outputSchema`. */
+    payloadSchema: OutputSchemaField[];
+    /**
+     * Field paths from `payloadSchema` (in order) shown inline in the
+     * pending-invocation list so the assignee can distinguish queued
+     * invocations at a glance. E.g. `['claimId', 'evaluatedAt']`.
+     */
+    pendingDisplayFields?: string[];
+}
 interface ActionDefinition<TInputs extends Record<string, any> = Record<string, any>> {
     type: string;
     /** UCAN-style ability string used by the flow compiler, e.g., "bid/submit". */
@@ -397,10 +452,39 @@ interface ActionDefinition<TInputs extends Record<string, any> = Record<string,
     /** Static output schema for action types with predictable output (e.g. email.send).
      *  For action types with dynamic output (e.g. http.request), the schema is user-defined in inputs. */
     outputSchema?: OutputSchemaField[];
+    /**
+     * Typed vocabulary of events this action can emit. Drives the trigger
+     * picker UI and compile-time validation of `block.event` triggers.
+     */
+    events?: ActionEventDefinition[];
+    /**
+     * Whether this action can be wired to a `block.event` trigger.
+     * False (the default) for user-interaction-driven actions like forms,
+     * claims, and evaluations — they always run as `manual`. True for actions
+     * where it makes sense for an event to nudge a human assignee to invoke
+     * them (email, http, notify).
+     *
+     * The trigger picker UI is hidden for blocks whose action type has this
+     * set to false.
+     */
+    eligibleForEventTrigger?: boolean;
     run: (inputs: TInputs, ctx: ActionContext) => Promise<ActionResult>;
 }
+/**
+ * Result returned by an action's `run()` function.
+ *
+ * The optional `events` array is the explicit emission surface — actions
+ * declare which named events they're emitting on this particular run, with
+ * the payload by value. The runtime persists these as part of the run record
+ * and the reconciliation loop turns them into pending invocations on
+ * subscribed listener blocks.
+ */
 interface ActionResult {
     output: Record<string, any>;
+    events?: Array<{
+        name: string;
+        payload: Record<string, any>;
+    }>;
 }
 
 /** Registry interface expected by the compiler (keeps it pure / testable). */
@@ -415,6 +499,36 @@ interface CompilerRegistry {
  */
 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;
@@ -426,6 +540,13 @@ interface SetupFlowOptions {
     creatorDid: string;
     /** Optional doc ID override (defaults to plan.flowId). */
     docId?: 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. */
@@ -435,24 +556,133 @@ interface SetupFlowResult {
     /** 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`.
  *
- * Usage:
- * ```ts
- * const result = await setupFlowFromBaseUcan({
- *   plan: myBaseUcanFlow,
- *   roomId: '!abc:matrix.org',
- *   matrixClient,
- *   creatorDid: 'did:ixo:abc123',
- * });
- *
- * // Now open the flow through normal channels:
- * // useCreateCollaborativeIxoEditor({ roomId: result.roomId, ... })
- * ```
+ * 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>;
 
-export { type AuthorizationResult as A, type BaseUcanFlow as B, type CompilerRegistry as C, type ExecuteNodeParams as E, type FlowRuntimeStateManager as F, type NodeActionResult as N, type OutputSchemaField as O, type RuntimeRef as R, type SetupFlowOptions as S, type TTLConstraint as T, isNodeActive as a, buildFlowNodeFromBlock as b, createRuntimeStateManager as c, buildAuthzFromProps as d, executeNode as e, type ExecutionOutcome as f, type ExecutionContext as g, type ActivationResult as h, isAuthorized as i, compileBaseUcanFlow as j, type SetupFlowResult as k, type FlowCapability as l, type CompiledFlow as m, type ActionDefinition as n, type ActionServices as o, clearRuntimeForTemplateClone as p, type ActionContext as q, type ActionResult as r, setupFlowFromBaseUcan as s, type ConditionRef as t, type ActorConstraint as u, type CompiledBlock as v, type CompiledEdge as w, type CompiledFlowNode as x, isRuntimeRef as y };
+/**
+ * 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;
+
+export { type AuthorizationResult as A, type BaseUcanFlow as B, type CompilerRegistry as C, type ActionContext as D, type ExecuteNodeParams as E, type FlowRuntimeStateManager as F, type ActionResult as G, type ConditionRef as H, type ActorConstraint as I, type RuntimeRef as J, type CompiledBlock as K, type CompiledEdge as L, type MergeResult as M, type NodeActionResult as N, type OutputSchemaField as O, type CompiledFlowNode as P, isRuntimeRef as Q, type ReadFlowOptions as R, type SetupFlowOptions as S, type TTLConstraint as T, buildAuthzFromProps as a, buildFlowNodeFromBlock as b, createRuntimeStateManager as c, type ExecutionOutcome as d, executeNode as e, type ExecutionContext as f, readFlowFromEditor as g, readFlow as h, isAuthorized as i, setActiveEditor as j, getActiveEditor as k, compileBaseUcanFlow as l, readCompiledFlowFromYDoc as m, mergeCompiledFlows as n, decompileToBaseUcanFlow as o, type SetupFlowResult as p, type ReadFlowResult as q, readFlowAsBaseUcan as r, setupFlowFromBaseUcan as s, type ReadableEditor as t, type FlowCapability as u, type CompiledFlow as v, type FlowStrategy as w, type ActionDefinition as x, type ActionServices as y, clearRuntimeForTemplateClone as z };

package/dist/{graphql-client-vuaTCDox.d.ts → graphql-client-2XFN6m9v.d.ts}

@@ -1,5 +1,5 @@
 import * as _blocknote_core from '@blocknote/core';
-import { K as IxoBlockProps, J as IxoEditorType, l as IxoEditorOptions, p as IxoCollaborativeEditorOptions, k as DelegationGrant } from './index-MLwb3a2P.mjs';
+import { J as IxoBlockProps, H as IxoEditorType, l as IxoEditorOptions, p as IxoCollaborativeEditorOptions, k as DelegationGrant } from './index-BEoftwDZ.mjs';
 import { Text, Doc, Map, Array as Array$1 } from 'yjs';
 import React__default from 'react';
 import { MatrixClient } from 'matrix-js-sdk';
@@ -2721,11 +2721,9 @@ interface CoverImageProps {
 }
 declare function CoverImage({ coverImageUrl, logoUrl }: CoverImageProps): React__default.ReactElement | null;
 
-type AuthorizationTabState = {
-    activationUpstreamNodeId: string;
-    activationRequiredStatus: 'pending' | 'approved' | 'rejected' | '';
-    activationRequireAuthorisedActor: boolean;
-};
+/** @deprecated The activation gating fields were removed; this type is kept
+ *  empty for any external imports during the transition. */
+type AuthorizationTabState = Record<string, never>;
 interface AuthorizationTabProps extends IxoBlockProps {
     /** Flow URI for capability scoping */
     flowUri?: string;