@ixo/editor 3.0.0-beta.26 → 3.0.0-beta.28

package/dist/{capabilityValidation-BSzFr-F6.d.ts → setup-C5MpJdyr.d.ts}

@@ -1,6 +1,160 @@
-import { r as FlowNode, F as FlowNodeAuthzExtension, p as FlowNodeRuntimeState, J as IxoEditorType, S as SignedCapability, B as CreateRootDelegationParams, t as StoredDelegation, G as CreateDelegationParams, H as CreateInvocationParams, w as InvocationResult, x as ExecutionWithInvocationResult, s as UcanCapability, y as DelegationChainValidationResult, z as FindProofsResult, M as MigrationReport, U as UcanDelegationStore, l as InvocationStore, E as EvaluationStatus, C as Capability, a as CapabilityValidationResult } from './index-aAHFla8N.mjs';
+import { r as FlowNode, F as FlowNodeAuthzExtension, p as FlowNodeRuntimeState, J as IxoEditorType, S as SignedCapability, B as CreateRootDelegationParams, t as StoredDelegation, G as CreateDelegationParams, H as CreateInvocationParams, w as InvocationResult, x as ExecutionWithInvocationResult, s as UcanCapability, y as DelegationChainValidationResult, z as FindProofsResult, M as MigrationReport, U as UcanDelegationStore, l as InvocationStore, E as EvaluationStatus, C as Capability, a as CapabilityValidationResult } from './index-BmOZ-1iJ.mjs';
 import { Delegation } from '@ixo/ucan';
 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):
+ *   dependsOn, condition, 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>;
+    /** 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. */
+    parallelGroup?: string;
+    /** Semantic grouping for layout lanes. */
+    phase?: string;
+    /** Who can execute this step. */
+    actor?: ActorConstraint;
+    /** Time-to-live constraints. */
+    ttl?: TTLConstraint;
+    /** Display title (falls back to can statement). */
+    title?: string;
+    /** Description of what this step does. */
+    description?: string;
+    /** Icon identifier. */
+    icon?: string;
+}
+/**
+ * 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>;
+}
+/** A dependency edge in the flow graph. */
+interface CompiledEdge {
+    id: string;
+    source: string;
+    target: string;
+    kind: 'dependency';
+    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>;
+    dependsOn: 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>;
+}
 
 declare const buildAuthzFromProps: (props: Record<string, any>) => FlowNodeAuthzExtension;
 declare const buildFlowNodeFromBlock: (block: any) => FlowNode;
@@ -403,4 +557,224 @@ declare const findValidCapability: (params: {
     error?: string;
 }>;
 
-export { type AuthorizationResult as A, type CapabilityGrant as C, type DelegationStore as D, type ExecuteNodeParams as E, type FlowRuntimeStateManager as F, type NodeActionResult as N, SimpleUCANManager as S, type UcanService as U, isNodeActive as a, createMemoryDelegationStore as b, createDelegationStore as c, createRuntimeStateManager as d, executeNode as e, findValidCapability as f, buildFlowNodeFromBlock as g, buildAuthzFromProps as h, isActorAuthorized as i, type ExecutionOutcome as j, type ExecutionContext as k, type AuthorizationContext as l, type ActivationResult as m, clearRuntimeForTemplateClone as n, executeNodeWithInvocation as o, type ExecuteNodeParamsV2 as p, type ExecutionContextV2 as q, isActorAuthorizedV2 as r, type AuthorizationContextV2 as s, createUcanService as t, type UcanServiceConfig as u, validateCapabilityChain as v, type UcanServiceHandlers as w, type UCANManager as x, type DerivedCapability as y };
+interface ActionContext {
+    actorDid: string;
+    flowId: string;
+    nodeId: string;
+    services: ActionServices;
+    flowNode?: any;
+    runtime?: any;
+    delegationStore?: any;
+    verifySignature?: (capabilityRaw: string, issuerDid: string) => Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    rootIssuer?: string;
+    flowUri?: string;
+    handlers?: any;
+    editor?: any;
+}
+interface ActionServices {
+    http?: {
+        request: (params: {
+            url: string;
+            method: string;
+            headers?: Record<string, string>;
+            body?: any;
+        }) => Promise<{
+            status: number;
+            headers: Record<string, string>;
+            data: any;
+        }>;
+    };
+    email?: {
+        send: (params: {
+            to: string;
+            subject: string;
+            template: string;
+            templateVersion?: string;
+            variables?: Record<string, any>;
+            cc?: string;
+            bcc?: string;
+            replyTo?: string;
+        }) => Promise<{
+            messageId: string;
+            sentAt: string;
+        }>;
+    };
+    notify?: {
+        send: (params: {
+            channel: string;
+            to: string[];
+            cc?: string[];
+            bcc?: string[];
+            subject?: string;
+            body?: string;
+            bodyType?: 'text' | 'html';
+            from?: string;
+            replyTo?: string;
+        }) => Promise<{
+            messageId: string;
+            sentAt: string;
+        }>;
+    };
+    bid?: {
+        submitBid: (params: {
+            collectionId: string;
+            role: string;
+            surveyAnswers: Record<string, any>;
+        }) => Promise<any>;
+        approveBid: (params: {
+            bidId: string;
+            collectionId: string;
+            did: string;
+        }) => Promise<any>;
+        rejectBid: (params: {
+            bidId: string;
+            collectionId: string;
+            did: string;
+            reason: string;
+        }) => Promise<any>;
+        approveServiceAgentApplication: (params: {
+            adminAddress: string;
+            collectionId: string;
+            agentQuota: number;
+            deedDid: string;
+            currentUserAddress: string;
+        }) => Promise<void>;
+        approveEvaluatorApplication: (params: {
+            adminAddress: string;
+            collectionId: string;
+            deedDid: string;
+            evaluatorAddress: string;
+            agentQuota?: number;
+            claimIds?: string[];
+            maxAmounts?: Array<{
+                denom: string;
+                amount: string;
+            }>;
+        }) => Promise<void>;
+    };
+    claim?: {
+        requestPin: (config?: {
+            title?: string;
+            description?: string;
+            submitText?: string;
+        }) => Promise<string>;
+        submitClaim: (params: {
+            surveyData: any;
+            deedDid: string;
+            collectionId: string;
+            adminAddress: string;
+            pin: string;
+        }) => Promise<{
+            transactionHash: string;
+            claimId: string;
+        }>;
+        evaluateClaim: (granteeAddress: string, did: string, payload: {
+            claimId: string;
+            collectionId: string;
+            adminAddress: string;
+            status?: number;
+            verificationProof: string;
+            amount?: {
+                denom: string;
+                amount: string;
+            } | Array<{
+                denom: string;
+                amount: string;
+            }>;
+        }) => Promise<void>;
+        getCurrentUser: () => {
+            address: string;
+        };
+        createUdid?: (params: any) => Promise<any>;
+    };
+    matrix?: {
+        storeCredential: (params: {
+            roomId: string;
+            credentialKey: string;
+            credential: Record<string, any>;
+            cid: string;
+        }) => Promise<{
+            storedAt: string;
+            duplicate: boolean;
+        }>;
+    };
+}
+interface OutputSchemaField {
+    path: string;
+    displayName: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+}
+interface ActionDefinition {
+    type: string;
+    /** UCAN-style ability string used by the flow compiler, e.g., "bid/submit". */
+    can?: string;
+    sideEffect: boolean;
+    defaultRequiresConfirmation: boolean;
+    requiredCapability?: string;
+    inputSchema?: object;
+    /** 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[];
+    run: (inputs: Record<string, any>, ctx: ActionContext) => Promise<ActionResult>;
+}
+interface ActionResult {
+    output: Record<string, any>;
+}
+
+/** 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;
+
+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;
+}
+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;
+}
+/**
+ * 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, ... })
+ * ```
+ */
+declare function setupFlowFromBaseUcan(options: SetupFlowOptions): Promise<SetupFlowResult>;
+
+export { isRuntimeRef as $, type AuthorizationResult as A, type BaseUcanFlow as B, type CompilerRegistry as C, type DelegationStore as D, type ExecuteNodeParams as E, type FlowRuntimeStateManager as F, type AuthorizationContextV2 as G, createUcanService as H, type UcanServiceConfig as I, type UcanServiceHandlers as J, SimpleUCANManager as K, type UCANManager as L, type CapabilityGrant as M, type NodeActionResult as N, type DerivedCapability as O, type ActionContext as P, type ActionResult as Q, type OutputSchemaField as R, type SetupFlowOptions as S, type ConditionRef as T, type UcanService as U, type ActorConstraint as V, type TTLConstraint as W, type RuntimeRef as X, type CompiledBlock as Y, type CompiledEdge as Z, type CompiledFlowNode as _, isNodeActive as a, createMemoryDelegationStore as b, createDelegationStore as c, createRuntimeStateManager as d, executeNode as e, findValidCapability as f, buildFlowNodeFromBlock as g, buildAuthzFromProps as h, isActorAuthorized as i, type ExecutionOutcome as j, type ExecutionContext as k, type AuthorizationContext as l, type ActivationResult as m, compileBaseUcanFlow as n, type SetupFlowResult as o, type FlowCapability as p, type CompiledFlow as q, type ActionDefinition as r, setupFlowFromBaseUcan as s, type ActionServices as t, clearRuntimeForTemplateClone as u, validateCapabilityChain as v, executeNodeWithInvocation as w, type ExecuteNodeParamsV2 as x, type ExecutionContextV2 as y, isActorAuthorizedV2 as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ixo/editor",
-  "version": "3.0.0-beta.26",
+  "version": "3.0.0-beta.28",
   "description": "A custom BlockNote editor wrapper for IXO team",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",