@ixo/editor 2.26.0 → 2.27.1

package/dist/{graphql-client-sR5y0LAb.d.ts → graphql-client-C6wosaS5.d.ts}

@@ -1544,6 +1544,7 @@ interface BlocknoteHandlers {
     }>;
     /**
      * Sign a capability delegation
+     * @deprecated Use createDelegation instead for @ixo/ucan CAR format
      */
     signCapability?: (params: {
         /** DID of issuer (entity or user) */
@@ -1573,6 +1574,7 @@ interface BlocknoteHandlers {
     }>;
     /**
      * Verify a capability signature against issuer's DID document
+     * @deprecated Use validateInvocation instead
      */
     verifyCapabilitySignature?: (params: {
         /** Raw capability JSON */
@@ -1583,6 +1585,101 @@ interface BlocknoteHandlers {
         valid: boolean;
         error?: string;
     }>;
+    /**
+     * Create a delegation using @ixo/ucan (CAR format)
+     */
+    createDelegation?: (params: {
+        /** DID of issuer */
+        issuerDid: string;
+        /** Whether signing as entity or user */
+        issuerType: 'entity' | 'user';
+        /** Entity room ID (required if issuerType is 'entity') */
+        entityRoomId?: string;
+        /** DID of recipient */
+        audience: string;
+        /** Capabilities to grant */
+        capabilities: Array<{
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        }>;
+        /** CIDs of proof delegations */
+        proofs?: string[];
+        /** Expiration timestamp (milliseconds) */
+        expiration?: number;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+    }) => Promise<{
+        /** Content ID of the delegation */
+        cid: string;
+        /** Base64-encoded CAR bytes */
+        delegation: string;
+    }>;
+    /**
+     * Create an invocation using @ixo/ucan (CAR format)
+     */
+    createInvocation?: (params: {
+        /** DID of invoker */
+        invokerDid: string;
+        /** Whether signing as entity or user */
+        invokerType: 'entity' | 'user';
+        /** Entity room ID (required if invokerType is 'entity') */
+        entityRoomId?: string;
+        /** Capability to invoke */
+        capability: {
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        };
+        /** CIDs of proof delegations */
+        proofs: string[];
+        /** Additional facts/context */
+        facts?: Record<string, unknown>;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+    }) => Promise<{
+        /** Content ID of the invocation */
+        cid: string;
+        /** Base64-encoded CAR bytes */
+        invocation: string;
+    }>;
+    /**
+     * Validate an invocation against its proof chain
+     */
+    validateInvocation?: (params: {
+        /** Base64-encoded CAR invocation */
+        invocation: string;
+        /** Base64-encoded CAR delegations (proofs) */
+        delegations: string[];
+    }) => Promise<{
+        valid: boolean;
+        error?: string;
+        /** Issuer DID if valid */
+        issuer?: string;
+        /** Validated capability if valid */
+        capability?: {
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        };
+    }>;
+    /**
+     * Parse a delegation from Base64 CAR format
+     */
+    parseDelegation?: (
+    /** Base64-encoded CAR delegation */
+    delegation: string) => Promise<{
+        cid: string;
+        issuer: string;
+        audience: string;
+        capabilities: Array<{
+            can: string;
+            with: string;
+            nb?: Record<string, unknown>;
+        }>;
+        expiration?: number;
+        proofs: string[];
+    }>;
     /**
      * Search for users by name or DID
      */
@@ -1842,6 +1939,105 @@ interface BlocknoteHandlers {
         status: 'not_started' | 'in_progress' | 'completed';
         completedAt?: string;
     }>;
+    /**
+     * Create a new signer session for handle-based signing.
+     *
+     * This allows the editor to request signing operations without receiving
+     * raw key material. The host app manages the session lifecycle and key security.
+     *
+     * @example
+     * ```typescript
+     * // Create a session-scoped signer for batch operations
+     * const session = await handlers.createSignerSession({
+     *   did: 'did:ixo:entity:abc123',
+     *   didType: 'entity',
+     *   entityRoomId: '!room:matrix.ixo.world',
+     *   pin: '123456',
+     *   scope: 'session',
+     *   ttlSeconds: 300
+     * });
+     *
+     * // Use for multiple signatures without re-entering PIN
+     * const sig1 = await handlers.signWithSession({ sessionId: session.sessionId, data: '...' });
+     * const sig2 = await handlers.signWithSession({ sessionId: session.sessionId, data: '...' });
+     *
+     * // Release when done
+     * await handlers.releaseSignerSession({ sessionId: session.sessionId });
+     * ```
+     */
+    createSignerSession?: (params: {
+        /** DID of the signer (entity or user) */
+        did: string;
+        /** Whether signing as entity or user */
+        didType: 'entity' | 'user';
+        /** Entity room ID (required if didType is 'entity') */
+        entityRoomId?: string;
+        /** PIN to decrypt signing mnemonic */
+        pin: string;
+        /**
+         * Session scope:
+         * - 'session': Remains valid for multiple sign operations until TTL or explicit release
+         * - 'operation': Automatically invalidated after first sign operation
+         */
+        scope: 'session' | 'operation';
+        /**
+         * Time-to-live in seconds (only applicable for 'session' scope)
+         * Default: 300 (5 minutes), Maximum: 3600 (1 hour)
+         */
+        ttlSeconds?: number;
+    }) => Promise<{
+        /** Opaque session identifier */
+        sessionId: string;
+        /** DID of the signer */
+        did: string;
+        /** Public key in multibase format (for verification) */
+        publicKey: string;
+        /** Key ID (verification method ID) */
+        keyId: string;
+        /** Unix timestamp when the session expires */
+        expiresAt: number;
+        /** The scope this session was created with */
+        scope: 'session' | 'operation';
+    }>;
+    /**
+     * Sign data using an existing signer session.
+     *
+     * For 'operation' scoped sessions, the session is automatically
+     * invalidated after this call succeeds.
+     *
+     * @throws If session not found, expired, or signing fails
+     */
+    signWithSession?: (params: {
+        /** The session ID returned from createSignerSession */
+        sessionId: string;
+        /** Data to sign (passed as-is to Ed25519 sign) */
+        data: string;
+        /** Algorithm hint (currently only Ed25519 supported) */
+        algorithm?: 'Ed25519';
+    }) => Promise<{
+        /** The signature in hex format */
+        signature: string;
+        /** The algorithm used */
+        algorithm: 'Ed25519';
+        /** Key ID that was used for signing */
+        keyId: string;
+    }>;
+    /**
+     * Release a signer session before it expires.
+     *
+     * This immediately clears the session from host memory, preventing
+     * any further signing operations. Idempotent - safe to call on
+     * already-expired or released sessions.
+     */
+    releaseSignerSession?: (params: {
+        /** The session ID to release */
+        sessionId: string;
+    }) => Promise<{
+        /** Whether the session was successfully released */
+        released: boolean;
+        /** Reason if not released (e.g., already expired) */
+        reason?: string;
+    }>;
 }
 type DocType = 'template' | 'page' | 'flow';
 /**
@@ -2812,6 +3008,9 @@ declare const blockSpecs: {
                 readonly activationRequireAuthorisedActor: {
                     readonly default: false;
                 };
+                readonly hookedActions: {
+                    readonly default: "";
+                };
                 readonly assignment: {
                     readonly default: string;
                 };
@@ -2854,6 +3053,9 @@ declare const blockSpecs: {
                 readonly activationRequireAuthorisedActor: {
                     readonly default: false;
                 };
+                readonly hookedActions: {
+                    readonly default: "";
+                };
                 readonly assignment: {
                     readonly default: string;
                 };
@@ -3507,6 +3709,9 @@ declare const blockSpecs: {
                 readonly afterCreate: {
                     readonly default: "";
                 };
+                readonly hookedActions: {
+                    readonly default: "";
+                };
             };
             readonly content: "none";
         };
@@ -3543,6 +3748,9 @@ declare const blockSpecs: {
                 readonly afterCreate: {
                     readonly default: "";
                 };
+                readonly hookedActions: {
+                    readonly default: "";
+                };
             };
             readonly content: "none";
         }, any, _blocknote_core.InlineContentSchema, _blocknote_core.StyleSchema>;
@@ -3696,17 +3904,108 @@ interface FlowNodeBase {
 }
 type FlowNode = FlowNodeBase & FlowNodeAuthzExtension;
 
+/**
+ * UCAN types for @ixo/ucan integration
+ *
+ * These types support the new invocation-based execution model where:
+ * - Delegations grant permissions (stored as Base64 CAR)
+ * - Invocations exercise permissions (stored for audit trail)
+ */
+/**
+ * Caveats/constraints for a capability
+ */
+interface CapabilityCaveats {
+    /** Intent - user-provided description of the purpose of this capability */
+    int?: string;
+    /** Additional custom caveats */
+    [key: string]: unknown;
+}
+/**
+ * Capability definition aligned with @ixo/ucan
+ */
+interface UcanCapability {
+    /** Action that can be performed, e.g., "flow/execute", "flow/block/execute" */
+    can: string;
+    /** Resource URI, e.g., "ixo:flow:abc123", "ixo:flow:abc123:blockId" */
+    with: string;
+    /** Additional constraints/caveats (optional) */
+    nb?: CapabilityCaveats;
+}
+/**
+ * Stored delegation in new CAR format or legacy JSON format
+ */
+interface StoredDelegation {
+    /** CID of the delegation (content-addressed ID) */
+    cid: string;
+    /** Base64-encoded CAR bytes (for 'car' format) or empty string for legacy */
+    delegation: string;
+    /** Issuer DID (for quick lookup without parsing) */
+    issuerDid: string;
+    /** Audience DID (for quick lookup without parsing) */
+    audienceDid: string;
+    /** Capabilities granted (for quick lookup without parsing) */
+    capabilities: UcanCapability[];
+    /** Expiration timestamp in milliseconds (for quick expiry checks) */
+    expiration?: number;
+    /** When this delegation was created (milliseconds) */
+    createdAt: number;
+    /** Format indicator: 'car' for new format, 'legacy' for old JSON format */
+    format: 'car' | 'legacy';
+    /** CIDs of proof delegations in the chain */
+    proofCids: string[];
+}
+/**
+ * Stored invocation for audit trail and replay protection
+ */
+interface StoredInvocation {
+    /** CID of the invocation (content-addressed ID) */
+    cid: string;
+    /** Base64-encoded CAR bytes */
+    invocation: string;
+    /** DID of the invoker */
+    invokerDid: string;
+    /** Capability being invoked */
+    capability: UcanCapability;
+    /** When this invocation was executed (milliseconds) */
+    executedAt: number;
+    /** Flow ID context */
+    flowId: string;
+    /** Block ID if block-level execution */
+    blockId?: string;
+    /** Execution result */
+    result: 'success' | 'failure';
+    /** Error message if failed */
+    error?: string;
+    /** CIDs of the proof delegation chain */
+    proofCids: string[];
+    /** Linked claim ID if this invocation created a claim */
+    claimId?: string;
+    /** Transaction hash if submitted to blockchain */
+    transactionHash?: string;
+}
+
 /**
  * Capability types for UCAN-based authorization
+ *
+ * NOTE: This module contains legacy types for backward compatibility.
+ * For new code, prefer using types from './ucan.ts' which align with @ixo/ucan.
+ */
+
+/**
+ * @deprecated Use UcanCapability from './ucan' for new code
  */
 interface Capability {
     /** Action that can be performed, e.g., "flow/execute", "flow/block/execute" */
     can: string;
     /** Resource URI, e.g., "ixo:flow:abc123", "ixo:flow:abc123:blockId" */
     with: string;
-    /** Additional constraints (optional) */
-    nb?: Record<string, any>;
+    /** Additional constraints/caveats (optional) */
+    nb?: CapabilityCaveats;
 }
+/**
+ * @deprecated Use StoredDelegation from './ucan' for new code.
+ * SignedCapability uses JSON format; StoredDelegation uses CAR format.
+ */
 interface SignedCapability {
     /** Unique identifier (CID or generated ID) */
     id: string;
@@ -3746,6 +4045,61 @@ interface DelegationGrant {
     canDelegate?: boolean;
 }
 
+/**
+ * UCAN Delegation Store with dual-mode support for CAR and legacy JSON formats
+ */
+interface UcanDelegationStore {
+    get: (cid: string) => StoredDelegation | null;
+    set: (delegation: StoredDelegation) => void;
+    remove: (cid: string) => void;
+    has: (cid: string) => boolean;
+    getRoot: () => StoredDelegation | null;
+    setRootCid: (cid: string) => void;
+    getRootCid: () => string | null;
+    getAll: () => StoredDelegation[];
+    getByAudience: (audienceDid: string) => StoredDelegation[];
+    getByIssuer: (issuerDid: string) => StoredDelegation[];
+    findByCapability: (can: string, withUri: string) => StoredDelegation[];
+    getVersion: () => number;
+    setVersion: (version: number) => void;
+    getLegacy: (id: string) => SignedCapability | null;
+    hasLegacy: (id: string) => boolean;
+    getAllLegacy: () => SignedCapability[];
+    convertLegacyToStored: (legacy: SignedCapability) => StoredDelegation;
+}
+
+/**
+ * Invocation Store for storing and querying invocations
+ *
+ * Invocations are stored for:
+ * - Audit trail: Cryptographic proof of who did what, when, with what authority
+ * - Replay protection: Prevent same invocation being used twice
+ * - Dispute resolution: Evidence if actions are contested
+ * - Blockchain submission: Submit proofs to chain for immutable record
+ * - Analytics: Understand flow execution patterns
+ */
+interface InvocationStore {
+    add: (invocation: StoredInvocation) => void;
+    get: (cid: string) => StoredInvocation | null;
+    remove: (cid: string) => void;
+    getAll: () => StoredInvocation[];
+    getByInvoker: (invokerDid: string) => StoredInvocation[];
+    getByFlow: (flowId: string) => StoredInvocation[];
+    getByBlock: (flowId: string, blockId: string) => StoredInvocation[];
+    getByCapability: (can: string, withUri: string) => StoredInvocation[];
+    hasBeenInvoked: (cid: string) => boolean;
+    getInDateRange: (startMs: number, endMs: number) => StoredInvocation[];
+    getSuccessful: () => StoredInvocation[];
+    getFailures: () => StoredInvocation[];
+    getPendingSubmission: () => StoredInvocation[];
+    markSubmitted: (cid: string, transactionHash: string) => void;
+    getCount: () => number;
+    getCountByResult: () => {
+        success: number;
+        failure: number;
+    };
+}
+
 /**
  * The schema type for the IXO editor, derived from block specs
  */
@@ -3815,6 +4169,22 @@ interface IxoEditorType<BSchema extends IxoBlockSchema = IxoBlockSchema, ISchema
      * @internal
      */
     _yDelegations?: Map<any>;
+    /**
+     * Y.Map for storing invocations (audit trail)
+     * @internal
+     */
+    _yInvocations?: Map<any>;
+    /**
+     * UCAN delegation store (new @ixo/ucan integration)
+     * Supports both CAR format (new) and JSON format (legacy)
+     * @internal
+     */
+    _ucanDelegationStore?: UcanDelegationStore;
+    /**
+     * Invocation store for audit trail and replay protection
+     * @internal
+     */
+    _invocationStore?: InvocationStore;
     /**
      * Current editor mode (flow, template, readonly)
      */
@@ -3902,6 +4272,26 @@ interface IxoEditorType<BSchema extends IxoBlockSchema = IxoBlockSchema, ISchema
      * Remove a delegation (revoke)
      */
     removeDelegation?: (capabilityId: string) => void;
+    /**
+     * Add an invocation to the store (audit trail)
+     */
+    addInvocation?: (invocation: StoredInvocation) => void;
+    /**
+     * Get an invocation by CID
+     */
+    getInvocation?: (cid: string) => StoredInvocation | null;
+    /**
+     * Get all invocations
+     */
+    getAllInvocations?: () => StoredInvocation[];
+    /**
+     * Get invocations for a specific block
+     */
+    getInvocationsByBlock?: (flowId: string, blockId: string) => StoredInvocation[];
+    /**
+     * Check if an invocation has already been used (replay protection)
+     */
+    hasBeenInvoked?: (cid: string) => boolean;
     /**
      * Matrix metadata manager for page metadata (cover, icon)
      * @internal

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FlowNode, a as FlowNodeAuthzExtension, b as FlowNodeRuntimeState, I as IxoEditorType, S as SignedCapability, E as EvaluationStatus, C as Capability, c as CapabilityValidationResult } from './graphql-client-sR5y0LAb.mjs';
-export { a3 as Addr, J as ApiRequestBlockProps, t as ApiRequestBlockSpec, A as AuthorizationTab, i as AuthorizationTabState, U as AuthzExecActionTypes, Y as BlockRequirements, X as BlocknoteContextValue, W as BlocknoteHandlers, N as BlocknoteProvider, x as CheckboxBlockProps, s as CheckboxBlockSpec, aa as CosmosMsgForEmpty, g as CoverImage, h as CoverImageProps, D as DelegationGrant, ad as Entity, ae as EntityResponse, l as EntitySigningSetup, af as EntityVariables, j as EvaluationTab, k as EvaluationTabState, a6 as Expiration, m as FlowPermissionsPanel, G as GrantPermissionModal, ag as GraphQLClient, aj as GraphQLRequest, ai as GraphQLResponse, K as HttpMethod, r as IxoCollaborativeEditorOptions, q as IxoCollaborativeUser, e as IxoEditor, p as IxoEditorConfig, n as IxoEditorOptions, f as IxoEditorProps, o as IxoEditorTheme, M as KeyValuePair, z as ListBlockProps, y as ListBlockSettings, L as ListBlockSpec, O as OverviewBlock, B as OverviewBlockProps, ab as ProposalAction, H as ProposalBlockProps, P as ProposalBlockSpec, Z as ProposalResponse, _ as SingleChoiceProposal, T as StakeType, T as StakeTypeValue, a7 as Status, a8 as Threshold, a5 as Timestamp, a4 as Uint128, a2 as User, V as ValidatorActionType, a1 as Vote, a0 as VoteInfo, $ as VoteResponse, a9 as Votes, v as blockSpecs, ac as getEntity, w as getExtraSlashMenuItems, ah as ixoGraphQLClient, Q as useBlocknoteContext, R as useBlocknoteHandlers, d as useCreateCollaborativeIxoEditor, u as useCreateIxoEditor } from './graphql-client-sR5y0LAb.mjs';
+import { F as FlowNode, a as FlowNodeAuthzExtension, b as FlowNodeRuntimeState, I as IxoEditorType, S as SignedCapability, E as EvaluationStatus, C as Capability, c as CapabilityValidationResult } from './graphql-client-C6wosaS5.mjs';
+export { a3 as Addr, J as ApiRequestBlockProps, t as ApiRequestBlockSpec, A as AuthorizationTab, i as AuthorizationTabState, U as AuthzExecActionTypes, Y as BlockRequirements, X as BlocknoteContextValue, W as BlocknoteHandlers, N as BlocknoteProvider, x as CheckboxBlockProps, s as CheckboxBlockSpec, aa as CosmosMsgForEmpty, g as CoverImage, h as CoverImageProps, D as DelegationGrant, ad as Entity, ae as EntityResponse, l as EntitySigningSetup, af as EntityVariables, j as EvaluationTab, k as EvaluationTabState, a6 as Expiration, m as FlowPermissionsPanel, G as GrantPermissionModal, ag as GraphQLClient, aj as GraphQLRequest, ai as GraphQLResponse, K as HttpMethod, r as IxoCollaborativeEditorOptions, q as IxoCollaborativeUser, e as IxoEditor, p as IxoEditorConfig, n as IxoEditorOptions, f as IxoEditorProps, o as IxoEditorTheme, M as KeyValuePair, z as ListBlockProps, y as ListBlockSettings, L as ListBlockSpec, O as OverviewBlock, B as OverviewBlockProps, ab as ProposalAction, H as ProposalBlockProps, P as ProposalBlockSpec, Z as ProposalResponse, _ as SingleChoiceProposal, T as StakeType, T as StakeTypeValue, a7 as Status, a8 as Threshold, a5 as Timestamp, a4 as Uint128, a2 as User, V as ValidatorActionType, a1 as Vote, a0 as VoteInfo, $ as VoteResponse, a9 as Votes, v as blockSpecs, ac as getEntity, w as getExtraSlashMenuItems, ah as ixoGraphQLClient, Q as useBlocknoteContext, R as useBlocknoteHandlers, d as useCreateCollaborativeIxoEditor, u as useCreateIxoEditor } from './graphql-client-C6wosaS5.mjs';
 import { Map } from 'yjs';
 export { Block, BlockNoteEditor, BlockNoteSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from '@blocknote/core';
 import 'react';
@@ -71,6 +71,8 @@ interface ExecutionOutcome {
     error?: string;
     result?: NodeActionResult;
     capabilityId?: string;
+    /** Invocation CID (new @ixo/ucan) */
+    invocationCid?: string;
 }
 interface ExecuteNodeParams {
     node: FlowNode;
@@ -84,6 +86,8 @@ interface AuthorizationResult {
     authorized: boolean;
     reason?: string;
     capabilityId?: string;
+    /** Proof chain CIDs for creating invocations (new @ixo/ucan) */
+    proofCids?: string[];
     /** @deprecated */
     derived?: DerivedCapability;
 }

package/dist/index.mjs

@@ -34,7 +34,7 @@ import {
   useCreateCollaborativeIxoEditor,
   useCreateIxoEditor,
   validateCapabilityChain
-} from "./chunk-CZDCWQZR.mjs";
+} from "./chunk-HT2SFUTR.mjs";
 export {
   ApiRequestBlockSpec,
   AuthorizationTab,

package/dist/mantine/index.d.ts

@@ -1,5 +1,5 @@
-import { ak as IxoBlockProps } from '../graphql-client-sR5y0LAb.mjs';
-export { a3 as Addr, J as ApiRequestBlockProps, t as ApiRequestBlockSpec, A as AuthorizationTab, i as AuthorizationTabState, U as AuthzExecActionTypes, Y as BlockRequirements, X as BlocknoteContextValue, W as BlocknoteHandlers, N as BlocknoteProvider, x as CheckboxBlockProps, s as CheckboxBlockSpec, aa as CosmosMsgForEmpty, g as CoverImage, h as CoverImageProps, av as DomainCardData, au as DomainCardRenderer, am as DropPosition, ar as DynamicListData, as as DynamicListDataProvider, at as DynamicListPanelRenderer, ad as Entity, ae as EntityResponse, l as EntitySigningSetup, af as EntityVariables, j as EvaluationTab, k as EvaluationTabState, a6 as Expiration, al as ExternalDropZone, m as FlowPermissionsPanel, G as GrantPermissionModal, ag as GraphQLClient, aj as GraphQLRequest, ai as GraphQLResponse, K as HttpMethod, r as IxoCollaborativeEditorOptions, q as IxoCollaborativeUser, e as IxoEditor, p as IxoEditorConfig, n as IxoEditorOptions, f as IxoEditorProps, o as IxoEditorTheme, I as IxoEditorType, M as KeyValuePair, z as ListBlockProps, y as ListBlockSettings, L as ListBlockSpec, O as OverviewBlock, B as OverviewBlockProps, an as PageHeader, ap as PageHeaderMenuItem, ao as PageHeaderProps, ab as ProposalAction, H as ProposalBlockProps, P as ProposalBlockSpec, Z as ProposalResponse, _ as SingleChoiceProposal, T as StakeType, T as StakeTypeValue, a7 as Status, a8 as Threshold, a5 as Timestamp, a4 as Uint128, a2 as User, V as ValidatorActionType, aq as VisualizationRenderer, a1 as Vote, a0 as VoteInfo, $ as VoteResponse, a9 as Votes, v as blockSpecs, ac as getEntity, w as getExtraSlashMenuItems, ah as ixoGraphQLClient, Q as useBlocknoteContext, R as useBlocknoteHandlers, d as useCreateCollaborativeIxoEditor, u as useCreateIxoEditor } from '../graphql-client-sR5y0LAb.mjs';
+import { ak as IxoBlockProps, W as BlocknoteHandlers } from '../graphql-client-C6wosaS5.mjs';
+export { a3 as Addr, J as ApiRequestBlockProps, t as ApiRequestBlockSpec, A as AuthorizationTab, i as AuthorizationTabState, U as AuthzExecActionTypes, Y as BlockRequirements, X as BlocknoteContextValue, N as BlocknoteProvider, x as CheckboxBlockProps, s as CheckboxBlockSpec, aa as CosmosMsgForEmpty, g as CoverImage, h as CoverImageProps, av as DomainCardData, au as DomainCardRenderer, am as DropPosition, ar as DynamicListData, as as DynamicListDataProvider, at as DynamicListPanelRenderer, ad as Entity, ae as EntityResponse, l as EntitySigningSetup, af as EntityVariables, j as EvaluationTab, k as EvaluationTabState, a6 as Expiration, al as ExternalDropZone, m as FlowPermissionsPanel, G as GrantPermissionModal, ag as GraphQLClient, aj as GraphQLRequest, ai as GraphQLResponse, K as HttpMethod, r as IxoCollaborativeEditorOptions, q as IxoCollaborativeUser, e as IxoEditor, p as IxoEditorConfig, n as IxoEditorOptions, f as IxoEditorProps, o as IxoEditorTheme, I as IxoEditorType, M as KeyValuePair, z as ListBlockProps, y as ListBlockSettings, L as ListBlockSpec, O as OverviewBlock, B as OverviewBlockProps, an as PageHeader, ap as PageHeaderMenuItem, ao as PageHeaderProps, ab as ProposalAction, H as ProposalBlockProps, P as ProposalBlockSpec, Z as ProposalResponse, _ as SingleChoiceProposal, T as StakeType, T as StakeTypeValue, a7 as Status, a8 as Threshold, a5 as Timestamp, a4 as Uint128, a2 as User, V as ValidatorActionType, aq as VisualizationRenderer, a1 as Vote, a0 as VoteInfo, $ as VoteResponse, a9 as Votes, v as blockSpecs, ac as getEntity, w as getExtraSlashMenuItems, ah as ixoGraphQLClient, Q as useBlocknoteContext, R as useBlocknoteHandlers, d as useCreateCollaborativeIxoEditor, u as useCreateIxoEditor } from '../graphql-client-C6wosaS5.mjs';
 import React$1, { PropsWithChildren } from 'react';
 import * as zustand from 'zustand';
 import * as _blocknote_core from '@blocknote/core';
@@ -182,4 +182,158 @@ declare const useListBlocksUIStore: zustand.UseBoundStore<zustand.StoreApi<ListB
  */
 declare const useListBlocksUI: () => ListBlocksUIContextValue;
 
-export { BaseIconPicker, type CollapseEvent, type ColumnPosition, type DataSource, type DynamicListAction, type DynamicListBlockProps, DynamicListBlockSpec, type DynamicListColumn, type DynamicListPanelConfig, type ListBlocksUIContextValue, type Listener, useListBlocksUI, useListBlocksUIStore, usePanel, usePanelStore };
+/**
+ * Defines a payload field available from a block action
+ */
+interface PayloadField {
+    key: string;
+    label: string;
+    type: 'string' | 'number' | 'boolean' | 'object';
+    description?: string;
+}
+/**
+ * Defines an action that a block can perform and its resulting payload
+ */
+interface BlockActionDefinition {
+    actionId: string;
+    label: string;
+    description: string;
+    payloadSchema: PayloadField[];
+}
+/**
+ * Configuration field for a hooked action type
+ */
+interface HookedActionConfigField {
+    key: string;
+    label: string;
+    type: 'string' | 'select' | 'blockSelect' | 'templateSelect';
+    required: boolean;
+    description?: string;
+    placeholder?: string;
+    blockTypes?: string[];
+}
+/**
+ * Context provided to hooked action execute functions
+ */
+interface HookedActionContext {
+    handlers: BlocknoteHandlers;
+    editor: any;
+    sourceBlock: any;
+}
+/**
+ * Defines a type of hooked action (e.g., sendEmail, addLinkedEntity)
+ */
+interface HookedActionType {
+    type: string;
+    label: string;
+    description: string;
+    configSchema: HookedActionConfigField[];
+    /**
+     * Execute the hooked action
+     * @param config - The action configuration from block props
+     * @param payload - The payload from the triggering action
+     * @param context - Handlers, editor, and source block
+     */
+    execute: (config: HookedActionInstanceConfig, payload: Record<string, any>, context: HookedActionContext) => Promise<void>;
+}
+/**
+ * Configuration for a single hooked action instance on a block
+ */
+interface HookedActionInstanceConfig {
+    id: string;
+    type: string;
+    enabled: boolean;
+    config: Record<string, any>;
+    /**
+     * Maps action config fields to payload values
+     * e.g., { 'to': '{{payload.agentAddress}}', 'claimId': '{{payload.claimId}}' }
+     */
+    variableMappings: Record<string, string>;
+}
+/**
+ * Configuration for all hooked actions on a block, organized by action ID
+ */
+interface HookedActionsConfig {
+    [actionId: string]: HookedActionInstanceConfig[];
+}
+/**
+ * Result from executing hooked actions
+ */
+interface HookedActionsExecutionResult {
+    executed: number;
+    errors: string[];
+}
+
+/**
+ * Register a hooked action type
+ */
+declare function registerHookedActionType(actionType: HookedActionType): void;
+/**
+ * Get a hooked action type by its type ID
+ */
+declare function getHookedActionType(type: string): HookedActionType | undefined;
+/**
+ * Get all registered hooked action types
+ */
+declare function getAllHookedActionTypes(): HookedActionType[];
+/**
+ * Register block action definitions for a block type
+ */
+declare function registerBlockActions(blockType: string, actions: BlockActionDefinition[]): void;
+/**
+ * Get action definitions for a block type
+ */
+declare function getBlockActions(blockType: string): BlockActionDefinition[];
+
+interface UseHookedActionsProps {
+    block: any;
+    editor: any;
+}
+/**
+ * Hook for executing hooked actions on a block
+ *
+ * @example
+ * ```tsx
+ * const { executeHookedActions } = useHookedActions({ block, editor });
+ *
+ * // After main action completes
+ * const result = await handleCreate();
+ * executeHookedActions('create', {
+ *   coreAddress: result.coreAddress,
+ *   groupAddress: result.groupAddress,
+ *   transactionHash: result.transactionHash,
+ * });
+ * ```
+ */
+declare function useHookedActions({ block, editor }: UseHookedActionsProps): {
+    executeHookedActions: (actionId: string, payload: Record<string, any>) => void;
+    executeHookedActionsWithResults: (actionId: string, payload: Record<string, any>) => Promise<HookedActionsExecutionResult>;
+};
+
+/**
+ * Register all built-in hooked action types
+ * Call this at app initialization
+ */
+declare function registerBuiltInActionTypes(): void;
+
+/**
+ * Initialize the hooked actions system.
+ * This registers all built-in action types and block action definitions.
+ * Should be called once at app startup.
+ */
+declare function initializeHookedActions(): void;
+
+interface HookedActionsTabProps {
+    editor: any;
+    block: any;
+    /** Block action definitions - what actions this block exposes */
+    blockActions: BlockActionDefinition[];
+    /** Current hookedActions JSON string from block props */
+    hookedActions: string;
+    /** Callback when hookedActions config changes */
+    onHookedActionsChange: (value: string) => void;
+}
+
+declare const HookedActionsTab: React$1.FC<HookedActionsTabProps>;
+
+export { BaseIconPicker, type BlockActionDefinition, BlocknoteHandlers, type CollapseEvent, type ColumnPosition, type DataSource, type DynamicListAction, type DynamicListBlockProps, DynamicListBlockSpec, type DynamicListColumn, type DynamicListPanelConfig, type HookedActionInstanceConfig, type HookedActionType, type HookedActionsConfig, HookedActionsTab, type ListBlocksUIContextValue, type Listener, type PayloadField, getAllHookedActionTypes, getBlockActions, getHookedActionType, initializeHookedActions, registerBlockActions, registerBuiltInActionTypes, registerHookedActionType, useHookedActions, useListBlocksUI, useListBlocksUIStore, usePanel, usePanelStore };