@ixo/editor 6.27.0 → 6.28.0

package/dist/{index-CfkeGZGU.d.ts → index-BCR-Vx-S.d.ts}

@@ -1691,6 +1691,353 @@ interface IntegrationsHandlers {
         bindingId: string;
     }) => Promise<void>;
 }
+/** Pipeline row (`claim_ingests`): has the engine picked the claim up yet? */
+interface EngineIngest {
+    status: 'queued' | 'processed' | 'failed';
+    instanceId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One member check's outcome inside a compound gate — identifiers only, never answer values. */
+interface EngineGateMember {
+    index: number;
+    /** The member's own field ref (`$question`), its forEach target, or its compound keyword. */
+    ref: string;
+    ok: boolean;
+}
+interface EngineGateOutcome {
+    code: string;
+    outcome: 'passed' | 'failed' | 'skipped' | 'unevaluated' | 'not_reached';
+    /** Present iff the gate's check is compound (linked rules) — recorded pass or fail alike. */
+    members?: EngineGateMember[];
+}
+interface EngineCriterionOutcome {
+    code: string;
+    scoreBps: number | null;
+    pending: boolean;
+    capped: boolean;
+}
+interface EngineDecisionReason {
+    code: string;
+    reason: string;
+    class: string;
+}
+/** The engine's authoritative decision jsonb — codes, scores and outcomes only. */
+interface EngineDecision {
+    status: 'decided' | 'pending_review' | 'unusable';
+    verdict: 'approve' | 'partial' | 'reject' | 'review';
+    class: string;
+    evaluationStatus: number;
+    action: string;
+    totalBps: number | null;
+    gates: EngineGateOutcome[];
+    criteria: EngineCriterionOutcome[];
+    pendingTasks: string[];
+    reasons: EngineDecisionReason[];
+}
+/** One frozen ext/AI call record — request, response, attempts, token usage. */
+interface EngineTranscript {
+    request: {
+        url: string;
+        body: unknown;
+        headers: Record<string, string>;
+    };
+    response: {
+        status: number;
+        body: unknown;
+    } | null;
+    attempts: number;
+    elapsedMs: number;
+    latencyMs?: number;
+    genId?: string | null;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        cachedTokens: number;
+        costUsd: number;
+    } | null;
+}
+type EngineExtFact = {
+    status: 'ok';
+    value: boolean | number;
+    reason: string | null;
+    transcript: EngineTranscript;
+} | {
+    status: 'error';
+    onError: 'review' | 'reject';
+    detail: string;
+    transcript: EngineTranscript;
+};
+type EngineAiFact = {
+    status: 'ok';
+    value: boolean;
+    reason: string | null;
+    failedRules: string[];
+    score: number;
+    transcript: EngineTranscript;
+} | {
+    status: 'error';
+    onError: 'review' | 'reject';
+    detail: string;
+    transcript: EngineTranscript;
+};
+/** The frozen evaluation trace — everything the engine saw or produced. */
+interface EngineTrace {
+    attachments: Array<{
+        question: string;
+        name: string;
+        mediaType: string;
+        cid: string | null;
+        size: number | null;
+    }>;
+    ctx: {
+        now: string;
+        collection: {
+            startDate: string | null;
+            endDate: string | null;
+        };
+        claim: {
+            submitter: string | null;
+            submissionDate: string | null;
+        };
+    };
+    derived: Record<string, number | null>;
+    ext: Record<string, EngineExtFact>;
+    ai: Record<string, EngineAiFact>;
+    formProof: {
+        pinned: string;
+        live: string | null;
+        drifted: boolean;
+    };
+    /** The check settings in effect for the run (§B.2) — why AI did or didn't run. */
+    settings?: {
+        allowAiChecks: boolean;
+        allowImageChecks: boolean;
+    };
+}
+/** The billing receipt (§B.5) — the owner's charges, never the engine's costs. */
+interface EngineBilling {
+    /** The engine receipt's lines carry usd + the frozen credits figure; the UI shows USD only. */
+    base?: {
+        usd: number;
+        credits: number;
+    };
+    aiChecks?: {
+        count: number;
+        usd: number;
+        credits: number;
+    };
+    imageChecks?: {
+        count: number;
+        usd: number;
+        credits: number;
+    };
+    /** The PRICING snapshot in effect when the run was charged. */
+    model?: Record<string, number>;
+    /** Present on free runs (`no_rubric` / `unusable`) with the reason. */
+    free?: string;
+}
+interface EngineEvaluation {
+    collectionId: string;
+    rubricId: string | null;
+    status: 'decided' | 'pending_review' | 'unusable' | 'no_rubric';
+    verdict: 'approve' | 'partial' | 'reject' | 'review' | null;
+    verdictClass: string | null;
+    action: string | null;
+    totalBps: number | null;
+    decision: EngineDecision | null;
+    explanation: string | null;
+    trace: EngineTrace | null;
+    revenueUsd: number;
+    billing: EngineBilling | null;
+    resultDigest: string;
+    createdAt: string;
+}
+/** Human-review completion row (§A.10) — null until a person has answered. */
+interface EngineReview {
+    status: 'received' | 'completed' | 'failed';
+    reviewerDid: string;
+    answers: Record<string, boolean | string>;
+    createdAt: string;
+    finalVerdict: string | null;
+    finalVerdictClass: string | null;
+    finalAction: string | null;
+    finalTotalBps: number | null;
+    finalDecision: EngineDecision | null;
+    finalExplanation: string | null;
+    finalDigest: string | null;
+    completedAt: string | null;
+}
+/**
+ * The engine's duplicate case for one claim (duplicate-detection spec §6),
+ * derived server-side from the frozen `trace.unique` — `reason` is a finished
+ * sentence the UI renders VERBATIM, never re-derived here. Null when the run
+ * had no duplicate rule (or predates the feature).
+ */
+interface EngineDuplicate {
+    ruleId: string;
+    /** Similarity in basis points (0–10000) — `/100` for the percent shown. */
+    scoreBps: number;
+    band: 'pass' | 'review' | 'reject';
+    /** "Same attachment as claim X (different submitter)", "72% similar to claim X", … */
+    reason: string;
+    winnerKind: string | null;
+    /** The prior claims it matched — `verdict` is theirs, not this claim's. */
+    candidates: Array<{
+        claimId: string;
+        verdict: string | null;
+        sameAgent: boolean;
+    }>;
+}
+/**
+ * What the reader must DO — the one thing every surface routes on (eval-ui
+ * humanization design §3.1). Cross-repo contract with eval-engine's
+ * `decision-summary.ts`: field names and members are transcribed verbatim,
+ * never re-derived here. Deliberately no `canAnswer` member — the review
+ * lane's assignee gate is uniform (design §3.5), so a boolean that would
+ * always be true for every reader who can see it is not a field.
+ */
+type Disposition = 'settled' | 'engine_signing' | 'sign_to_settle' | 'your_call_on_chain' | 'answer_questions' | 'decide_yourself' | 'nothing_ran';
+/**
+ * The engine's read-time decision projection (design §3.1) — derived
+ * server-side from the stored `decision` jsonb + `trace` + the chain row on
+ * every read, never a stored column. The UI renders `headline`/`detail`
+ * verbatim; it does not compose prose from `decision`/`trace` itself.
+ */
+interface DecisionSummary {
+    /**
+     * Sentence case. Never an id, code, or score. Two shapes only: a bare subject, ≤ 4 words
+     * ("Rejected as a duplicate", "Needs your answer"), or a subject ≤ 4 words + the §14
+     * disposition suffix " — your call" (load-bearing, does NOT count toward the limit — a §14
+     * hold must never read as a decision that landed on chain, so it is never shortened).
+     */
+    headline: string;
+    /**
+     * At most TWO short sentences, ≤ 140 chars total, second person, no ids. When there are two,
+     * the split is deliberate and always the same: what the engine found, then what you do about
+     * it — "All 10 checks passed. Approve it below to write that on chain."
+     */
+    detail: string;
+    disposition: Disposition;
+    /**
+     * True iff this claim still owes SOMEONE a decision — a property of the record, not of the
+     * caller (spec §3.1, corrected). `settled`, `engine_signing` and `nothing_ran` are always
+     * false. It deliberately does NOT account for a review assigned to a different person: the
+     * producer has no caller identity, so it cannot — an earlier version of this comment said it
+     * did, which left the rule split three ways (spec, producer, consumer each holding a
+     * different version; Important 2, coordinator review round 3).
+     *
+     * **The consumer narrows it, in exactly one place.** "An assigned review is that person's
+     * queue, and being able to step in is not the same as owing it" is a client-side judgement,
+     * because only the client knows who is looking. That narrowing happens once, in the row
+     * view-model (`engineRowViewOf` / `rowViewByClaimId` in `EvaluateClaimFlowDetail.tsx`), and
+     * the rail, the "Owed by you" filter and its count all read the narrowed value — reading raw
+     * `owed` in any of the three puts a claim in the count that shows no rail.
+     */
+    owed: boolean;
+    /** How the chain stands, in the reader's words. Null when there is no chain row yet. */
+    chainState: {
+        label: string;
+        written: boolean;
+    } | null;
+    /** Max 3. Rendered as quiet neutral chips — never coloured, never the signal. */
+    facts: Array<{
+        kind: 'checks' | 'score' | 'match' | 'window' | 'cost';
+        text: string;
+    }>;
+    /** Ids pulled OUT of prose so the client can truncate, copy, and link them. */
+    refs: Array<{
+        kind: 'claim';
+        id: string;
+        label: string;
+    }>;
+    /** Drives the "Why this result?" default state — open only when worth reading. */
+    expandByDefault: boolean;
+}
+/** GET /v1/claims/:claimId — the full engine record for one claim. */
+interface ClaimEvaluationRecord {
+    claimId: string;
+    ingest: EngineIngest | null;
+    evaluation: EngineEvaluation | null;
+    review: EngineReview | null;
+    /** The duplicate case (§6) — a sibling of `evaluation`, not part of the decision. */
+    duplicate?: EngineDuplicate | null;
+    /** The full decision summary (design §3.1) — presentation only, derived at read time. */
+    summary?: DecisionSummary | null;
+}
+/** Typed 403 — the reader lacks evaluate rights; rendered as copy, never a toast. */
+interface ClaimEvaluationForbidden {
+    forbidden: true;
+}
+/** GET /v1/claims?collectionId= item — drives the list view's engine badges. */
+interface ClaimEvaluationSummary {
+    claimId: string;
+    ingestStatus: 'queued' | 'processed' | 'failed';
+    evalStatus: string | null;
+    verdict: string | null;
+    totalBps: number | null;
+    evaluatedAt: string | null;
+    /**
+     * The raw ledger/review columns the list route still returns alongside `summary` — kept on
+     * the wire, but no longer read by `EngineBadge`/`engineRowViewOf`, which derive the row's one
+     * status word from `summary` exclusively (design §3.1). This comment used to claim the badge
+     * read these directly; it never has since the humanization pass (stale comment fixed,
+     * coordinator review round 3).
+     */
+    reviewStatus?: 'received' | 'completed' | 'failed' | null;
+    finalVerdict?: string | null;
+    finalTotalBps?: number | null;
+    /**
+     * The duplicate case (§6) — a sibling fact, not read by the row anymore. The separate
+     * "Duplicate 92%" chip this used to drive is gone (design §4.7): a flagged duplicate now folds
+     * into `summary.headline` ("Duplicate — your call") like every other disposition. Kept on the
+     * wire for `VerdictBlock`'s detail-view use of the equivalent `ClaimEvaluationRecord.duplicate`
+     * (a different field on a different response), not this one.
+     */
+    duplicate?: EngineDuplicate | null;
+    /** Reduced projection of the full summary (design §3.2) — one status word without re-deriving anything client-side. */
+    summary?: Pick<DecisionSummary, 'headline' | 'disposition' | 'owed' | 'chainState'> | null;
+}
+/** One published price card. Prices are per relayer node, so which card applies depends on the collection. */
+interface EngineRateCard {
+    name?: string;
+    /** Base fee per evaluated claim. */
+    baseUsd: number;
+    /** Top-up per AI rule run per claim. */
+    aiRuleUsd: number;
+    /** Top-up per photo screened. */
+    photoUsd: number;
+    /** Top-up per agent-submitted claim. */
+    agentClaimUsd?: number;
+}
+/**
+ * GET /v1/pricing?collectionId= — what a claim actually costs ONE collection's
+ * owner (per-claim billing guide §11). `estimate.ownerPaysUsd` is the number
+ * that matters: the card MINUS what the collection's own on-chain evaluation
+ * payment already credits back, which is why a well-funded collection can owe
+ * nothing. `aiRules` is counted off the pinned rubric, so the estimate is real.
+ */
+interface EnginePricing {
+    /** The relayer node the collection's entity sits on — it selects the card. */
+    relayerNode: {
+        label: string;
+        isIxo: boolean;
+    };
+    rateCard: EngineRateCard;
+    /** The collection's on-chain evaluation payment — what funds the offset. */
+    evaluationPayment: {
+        amount: string;
+        denom: string;
+        usd: number;
+        allowlisted: boolean;
+    } | null;
+    estimate: {
+        aiRules: number;
+        cardUsd: number;
+        chainCreditUsd: number;
+        ownerPaysUsd: number;
+    } | null;
+}
 interface BlocknoteHandlers {
     getVote: (proposalContractAddress: string, proposalId: string, userAddress: string) => Promise<VoteResponse>;
     getProposal: (proposalContractAddress: string, proposalId: string) => Promise<ProposalResponse>;
@@ -1951,9 +2298,18 @@ interface BlocknoteHandlers {
     getBalanceDetails?: (id: string) => Promise<BalanceDetails>;
     getDeedSubscriptionDetails?: (id: string) => Promise<DeedSubscriptionDetails>;
     getClaimDetails?: (id: string) => Promise<ClaimDetails>;
+    /**
+     * Resolve a collection's claim form (`#vct`). `proof` and `resourceId`
+     * describe the LinkedResource the content was read from — the rubric builder
+     * pins them as its form binding (§A.3). Both are OPTIONAL: a host that does
+     * not supply them leaves the pin blank, which stays valid (nothing enforces
+     * it yet), and `qi/claim.submit` never reads them.
+     */
     getDeedSurveyTemplate: (deedDid: string, claimCollectionId?: string) => Promise<{
         surveyTemplate: any;
         claimCollectionId: string;
+        proof?: string;
+        resourceId?: string;
     } | null>;
     submitClaim: (params: {
         surveyData: any;
@@ -2172,6 +2528,58 @@ interface BlocknoteHandlers {
         /** Base64-encoded CAR bytes */
         delegation: string;
     }>;
+    /**
+     * Mint the `owner → oracle` enrolment delegation host-side and return its
+     * serialized base64-CAR `token` (to deposit into the UCAN Store). The host owns
+     * the oracle-DID default (devnet `did:ixo:ixo1fyc0…`), the `issuerType:'user'`
+     * signing, medium TTL, and revocability — the editor passes nothing, or only the
+     * optional overrides.
+     *
+     * Both capabilities are REQUIRED: `{ can:'*', with:'ixo:matrix-claims-bot' }`
+     * (read the claims) and `{ can:'subscriptions/read', with:'ixo:subscriptions' }`
+     * (let the engine resolve the owner's oracle claim collection, the only account
+     * a per-claim fee can be billed to). See `EvalRegisterService.mintBotDelegation`.
+     */
+    mintBotDelegation?: (params: {
+        ttlDays?: number;
+        oracleDid?: string;
+        pin?: string;
+        evalEngineUrl?: string;
+    }) => Promise<{
+        token: string;
+    }>;
+    /**
+     * Deposit a delegation CAR into the UCAN Store
+     * (`POST {ucanStoreUrl}/api/delegations { token }`), authorized by a
+     * self-signed `store/add` invocation the host mints. `ucanStoreUrl` is
+     * optional — resolve it from the host's configured network when omitted.
+     * Returns the stored delegation's CID.
+     */
+    depositDelegation?: (params: {
+        token: string;
+        note?: string;
+        ucanStoreUrl?: string;
+    }) => Promise<{
+        cid: string;
+    }>;
+    /**
+     * Register a collection with the Evaluation Engine
+     * (`POST {evalEngineUrl}/v1/collections/register
+     * { collectionId, deedDid, ownerDid, rubricId? }`), authorized by a host-minted
+     * UCAN invocation on `ixo:eval-engine`. `evalEngineUrl` is optional — resolve
+     * it from the host's configured network when omitted. Idempotent upsert on
+     * `collectionId`; returns the engine's registration `id`.
+     */
+    registerEvalCollection?: (params: {
+        collectionId: string;
+        deedDid: string;
+        ownerDid: string;
+        rubricId?: string;
+        evalEngineUrl?: string;
+    }) => Promise<{
+        id: string;
+        collectionId?: string;
+    }>;
     /**
      * Create an invocation using @ixo/ucan (CAR format)
      */
@@ -2485,6 +2893,96 @@ interface BlocknoteHandlers {
         rubric: any;
         claimCollectionId: string;
     } | null>;
+    /**
+     * Fetch the evaluation engine's canonical rubric JSON Schema — a public GET of
+     * `/v1/rubric-schema` (rubric-spec §A.12). The rubric builder compiles it with
+     * Ajv and validates the rules' shape against it, so the editor can never
+     * publish a shape the engine will reject. `evalEngineUrl` is optional — the
+     * host resolves it from its configured network when omitted.
+     */
+    getRubricSchema?: (evalEngineUrl?: string) => Promise<object>;
+    /**
+     * Ask the engine to check a rubric BEFORE it is anchored (eval-engine §C.7).
+     * Stronger than `getRubricSchema`'s local Ajv pass: the engine re-parses the
+     * envelope, re-binds against the LIVE claim form, and checks the collection's
+     * engine settings — the last of which the editor cannot see at all (AI rules
+     * on a collection with AI checks off are publishable but never run). The
+     * publish step blocks on any error, so the owner never signs an anchor
+     * transaction for rules that cannot work. Read-only.
+     */
+    previewRubric?: (params: {
+        collectionId: string;
+        rubric: unknown;
+        evalEngineUrl?: string;
+        /**
+         * True only on a user gesture that is ALREADY collecting a PIN (the publish step). The
+         * builder re-checks on every edit, so by default the host mints SILENTLY and resolves `null`
+         * when the wallet is locked, rather than interrupting authoring with the PIN modal.
+         */
+        interactive?: boolean;
+        /**
+         * The engine settings the author INTENDS to enrol with — lets the engine judge AI rules
+         * truthfully before the collection is enrolled (the stored row doesn't exist yet, or is stale
+         * against the block's unexecuted toggles). Absent = the engine falls back to its stored row.
+         */
+        settings?: {
+            allowAiChecks: boolean;
+            allowImageChecks: boolean;
+            allowChainEvaluation: boolean;
+        };
+    }) => Promise<{
+        ok: boolean;
+        problems: {
+            code: string;
+            severity: 'error' | 'warning';
+            path: string;
+            message: string;
+        }[];
+        settings: {
+            allowAiChecks: boolean;
+            allowImageChecks: boolean;
+            allowChainEvaluation: boolean;
+        };
+    } | null>;
+    /**
+     * Test a single §A.14 external source live for the rubric builder's Test
+     * button (rubric-spec §B.5). The host makes the real UCAN-signed HTTP call to
+     * `source.audience` with the author's `sampleValues` (one per `send` key) and
+     * returns what happened. Optional — the builder disables Test and shows a hint
+     * when a host has not wired it.
+     */
+    testExternalSource?: (params: {
+        source: object;
+        sampleValues?: Record<string, string | number | boolean>;
+    }) => Promise<SourcePreviewResult>;
+    /**
+     * Resolve a §A.14 external source's `did:web:` audience from its endpoint, so
+     * the rubric builder can auto-fill it instead of asking the author to paste a
+     * DID (rubric-spec §B.5). Public host read — no signing, no PIN.
+     * `resolved:false` (or no handler) makes the builder reveal a manual audience
+     * box; `audience` stays required in the format.
+     */
+    resolveSourceDid?: (params: {
+        endpoint: string;
+    }) => Promise<{
+        did: string | null;
+        resolved: boolean;
+        error: string | null;
+    }>;
+    /**
+     * The protocol entity's existing `#rub` LinkedResource — its on-chain `id`
+     * EXACTLY as stored (may be the literal template `{id}#rub`) and `proof`, or
+     * `null` when the entity carries none. The publish path reads it to compose a
+     * replace-in-place (delete + add in ONE transaction, delete first) — IID has
+     * no update, and a bare second add is rejected as a duplicated resource id
+     * (x/iid). Throws on a genuine query failure; the publish must then stop.
+     */
+    getRubricResource?: (params: {
+        protocolDid: string;
+    }) => Promise<{
+        id: string;
+        proof: string;
+    } | null>;
     /**
      * Evaluate a claim using a rubric via the rubric engine
      */
@@ -2523,6 +3021,73 @@ interface BlocknoteHandlers {
         };
         error?: string;
     }>;
+    /**
+     * The engine's full record for one claim (GET /v1/claims/:claimId, signed
+     * UCAN like `pinRubric`). Resolves `null` on 404 — the UI's "engine hasn't
+     * seen this claim yet" state, never an error toast — and `{forbidden: true}`
+     * on 403 (the reader lacks evaluate rights on the collection).
+     */
+    getClaimEvaluation?: (params: {
+        claimId: string;
+        evalEngineUrl?: string;
+    }) => Promise<ClaimEvaluationRecord | ClaimEvaluationForbidden | null>;
+    /**
+     * Engine summaries for a collection's claims (GET /v1/claims?collectionId=),
+     * merged into the block's list view by claimId for the per-row badges.
+     */
+    /**
+     * `notEnrolled: true` = the collection isn't registered with the engine (a normal state —
+     * the block shows its "try the Evaluation Engine" promo, never an error).
+     */
+    listClaimEvaluations?: (params: {
+        collectionId: string;
+        evalEngineUrl?: string;
+    }) => Promise<{
+        items: ClaimEvaluationSummary[];
+        nextCursor: string | null;
+        notEnrolled?: boolean;
+    }>;
+    /**
+     * Send a human review's answers (POST /v1/claims/:claimId/review, §A.10).
+     * All-or-nothing: `answers` must cover exactly the decision's pendingTasks.
+     * Idempotent until completed — re-sending the same answers is the recovery
+     * path; the host maps 409s to plain copy ("Someone already reviewed this
+     * claim" / "This claim's evaluation changed — refresh and look again").
+     */
+    submitClaimReview?: (params: {
+        claimId: string;
+        resultDigest: string;
+        answers: Record<string, boolean | string>;
+        evalEngineUrl?: string;
+    }) => Promise<{
+        status: 'completing';
+    } | {
+        status: 'conflict';
+        message: string;
+    }>;
+    /**
+     * The engine's live price for one collection (GET /v1/pricing?collectionId=,
+     * per-claim billing guide §11). Public and unauthenticated on the engine, but
+     * the block still asks the host rather than fetching a URL itself. Resolves
+     * `null` when the engine is unreachable or doesn't know the collection — the
+     * pricing surface then falls back to its static card, because a price read
+     * must never be the reason someone cannot enrol.
+     */
+    getEnginePricing?: (params: {
+        collectionId: string;
+        evalEngineUrl?: string;
+    }) => Promise<EnginePricing | null>;
+    /**
+     * The signed-in owner's notification email, for PREFILLING the eval.register
+     * block's required "Billing email" field (engine billing guide §10; owner,
+     * 2026-07-30). The host owns where it comes from (the portal reads auth-hub's
+     * `GET /api/user/email` with a self-signed user UCAN, session-cached — the
+     * endpoint is rate-limited per user). MUST resolve `null` on any failure —
+     * signed-out, no email on file, rate-limited — and never throw into a block
+     * render; the block then leaves the field empty for the owner to type.
+     * Absent handler (an older host) means no prefill, nothing else breaks.
+     */
+    getNotificationEmail?: () => Promise<string | null>;
     /**
      * Create a Universal Decentralized Identifier (UDID) for an evaluation result
      */
@@ -2628,6 +3193,30 @@ interface BlocknoteHandlers {
     sourceDomainSpaces?: (params?: {
         entityDid?: string;
     }) => Promise<MatrixSpaceStructure>;
+    /**
+     * The domain's LIVE channel list (joined, named chat rooms under its main
+     * space — a client-side `m.space.child` walk on the host). Preferred by the
+     * rubric reviewer picker over flattening `sourceDomainSpaces`, whose `rooms`
+     * arrays are the space skeleton rather than the channels.
+     */
+    listDomainChannels?: (params?: {
+        entityDid?: string;
+    }) => Promise<Array<{
+        roomId: string;
+        name: string;
+    }>>;
+    /**
+     * Let the evaluation engine into a review channel, so it can post the claims
+     * that need a person. Called the moment the author routes reviews to a channel
+     * — the engine can only post where it is a member, and that is part of picking
+     * a channel rather than a step the author has to remember. The host owns the
+     * chat client and the engine's identity; the block only reports the outcome.
+     */
+    inviteEvalEngineToChannel?: (params: {
+        roomId: string;
+    }) => Promise<{
+        status: 'invited' | 'already-there' | 'not-configured';
+    }>;
     /**
      * Create a Cosmos governance group from explicit members and decision policy.
      * Used by the POD setup flow after domain entity creation.
@@ -6185,11 +6774,14 @@ interface ActionHandlers {
     createProposal?: (...args: any[]) => any;
     getUserRoles?: (...args: any[]) => any;
     getClaimData?: (...args: any[]) => any;
+    getDeedSurveyTemplate?: (...args: any[]) => any;
+    getDeedRubric?: (...args: any[]) => any;
     requestPin?: (...args: any[]) => any;
     signCredential?: (...args: any[]) => any;
     publicFileUpload?: (...args: any[]) => any;
     createDomain?: (...args: any[]) => any;
     createAddLinkedResourceMessage?: (...args: any[]) => any;
+    createDeleteLinkedResourceMessage?: (...args: any[]) => any;
     executeTransaction?: (...args: any[]) => any;
     createGovernanceGroup?: (...args: any[]) => any;
     getEntityDid?: (...args: any[]) => any;
@@ -7177,6 +7769,266 @@ interface FlowRunLifecycleService {
         cancelledAt?: number;
     }>;
 }
+/**
+ * Evaluation-Engine enrollment service (qi/eval.register — pull-claim-spec §6).
+ * The editor declares the contract only; the consumer app implements each
+ * method. All three signing/HTTP steps live host-side (the portal owns the
+ * oracle-DID default, the delegation's capability list, the UCAN mints, and the
+ * HTTP). The editor only orchestrates the calls. See the
+ * module comment in `actions/evalRegister/evalRegister.ts` for the one-signed-step
+ * flow. All-or-nothing group (see adapters.ts).
+ */
+interface EvalRegisterService {
+    /**
+     * Prompt the user for their verification PIN — the user-authorization gate for
+     * the host-signed enrollment (primes the host signer session the delegation
+     * mint uses). Same primitive as `ClaimService.requestPin`; declared here so
+     * the composite action depends on this one service group.
+     */
+    requestPin: (config?: {
+        title?: string;
+        description?: string;
+        submitText?: string;
+    }) => Promise<string>;
+    /**
+     * Mint the `owner → oracle` enrolment delegation host-side and return its
+     * serialized base64-CAR `token` (deposited into the UCAN Store). The host owns
+     * the oracle-DID default, the `issuerType:'user'` signing, and revocability —
+     * so the block passes nothing, or only the optional overrides
+     * (`oracleDid`, `ttlDays`).
+     *
+     * The host MUST grant BOTH capabilities — one delegation, two things the
+     * engine does on the owner's behalf:
+     *   - `{ can: '*',                 with: 'ixo:matrix-claims-bot' }`
+     *       read the collection's claim bodies out of Matrix.
+     *   - `{ can: 'subscriptions/read', with: 'ixo:subscriptions'    }`
+     *       ask subscriptions-api for the owner's ORACLE CLAIM COLLECTION, which
+     *       is the only account a per-claim fee can be billed to. subscriptions-api
+     *       resolves the acting user as the delegation ROOT, so an engine-signed
+     *       invocation proved by this delegation returns the OWNER's subscription.
+     *       Omit it and enrolment succeeds but the collection can never be billed —
+     *       the engine 403s the register with a "re-register" message rather than
+     *       recording that silently.
+     *
+     * Hosts SHOULD echo back the resolved `oracleDid` (the delegation audience) —
+     * the standard submit-authz grant derives the engine's grantee address from it
+     * when the block carries no explicit `oracleDid`/`oracleAddress` override.
+     */
+    mintBotDelegation: (params: {
+        ttlDays?: number;
+        oracleDid?: string;
+        pin?: string;
+        evalEngineUrl?: string;
+    }) => Promise<{
+        token: string;
+        oracleDid?: string;
+    }>;
+    /**
+     * Deposit a delegation CAR into the UCAN Store
+     * (`POST {ucanStoreUrl}/api/delegations { token }`), authorized by a
+     * self-signed `store/add` invocation the host mints. `ucanStoreUrl` is
+     * optional — the host resolves it from its configured network when omitted.
+     */
+    depositDelegation: (params: {
+        token: string;
+        note?: string;
+        ucanStoreUrl?: string;
+    }) => Promise<{
+        cid: string;
+    }>;
+    /**
+     * Register the collection with the Evaluation Engine
+     * (`POST {evalEngineUrl}/v1/collections/register
+     * { collectionId, deedDid, ownerDid, rubricId?, settings? }`), authorized
+     * host-side by a UCAN invocation on `ixo:eval-engine`. `evalEngineUrl` is
+     * optional — the host resolves it from its configured network when omitted.
+     * Idempotent upsert on `collectionId` (re-registering updates `settings` —
+     * that is the v1 "change my mind" path); returns the engine's registration
+     * `id`. `settings` gates the engine's paid check lanes per collection
+     * (eval-dashboard spec §B.1); the host forwards it verbatim.
+     */
+    registerCollection: (params: {
+        collectionId: string;
+        deedDid: string;
+        ownerDid: string;
+        rubricId?: string;
+        evalEngineUrl?: string;
+        /**
+         * Owner-typed collection name — the engine renders its billing notices as
+         * `Name (collection 913)` when set. Forwarded verbatim; the engine trims
+         * and caps it (120).
+         */
+        displayName?: string;
+        /**
+         * Owner-written description of what this collection collects — the context the engine's
+         * duplicate-claim judge is missing when it compares two submissions. Composed by the block
+         * from three plain questions (`evalRegister/description.ts`); the engine stores it as ONE
+         * opaque string (max 1000, never parsed). Same "no opinion" semantics as `displayName`:
+         * OMITTED leaves any stored description alone, an explicit `''` erases it — so hosts must
+         * forward the key only when it is actually present.
+         */
+        description?: string;
+        /**
+         * The address the engine sends this collection's billing notices to.
+         * Client-supplied on purpose — the owner naming their own notification
+         * address, not an authorization input. The action REQUIRES it before
+         * signing (owner, 2026-07-30), so hosts always receive one; the param
+         * stays optional only so older callers keep compiling.
+         */
+        notifyEmail?: string;
+        settings?: {
+            allowAiChecks: boolean;
+            allowImageChecks: boolean;
+            allowChainEvaluation: boolean;
+        };
+    }) => Promise<{
+        id: string;
+        collectionId?: string;
+    }>;
+}
+/**
+ * Rubric publishing service (qi/eval.rubric — rubric-spec §C.1). The editor
+ * declares the contract only; the consumer app implements it. `uploadRubric`
+ * uploads the serialized JSON-LD document to Matrix media (the portal's
+ * `publicUploadToMatrix`: public HTTP media URL + sha256 content proof — NOT
+ * the generic `publicFileUpload`, which returns an empty proof). `pinRubric`
+ * is the optional best-effort engine notification: the host forwards the new
+ * `rubricId` to the evaluation engine's register upsert; the engine re-resolves
+ * from chain regardless, so failures never fail a run.
+ */
+/**
+ * The result of a live §A.14 external-source test — the host makes the real
+ * HTTP call (UCAN-signed to the source's `audience`) with the author's sample
+ * values and reports back what happened, so the builder can show ✅/❌ without
+ * ever judging a claim itself. `reachable`/`httpStatus` describe the transport,
+ * `contractOk`/`value`/`reason` the answer, `error` any failure in the author's
+ * words, and `sent` the exact payload that went on the wire.
+ */
+interface SourcePreviewResult {
+    ok: boolean;
+    reachable: boolean;
+    httpStatus: number | null;
+    contractOk: boolean;
+    expect: 'boolean' | 'score';
+    value: boolean | number | null;
+    reason: string | null;
+    error: string | null;
+    sent: Record<string, unknown>;
+    audience: string;
+    elapsedMs: number;
+}
+/**
+ * The engine's verdict on a rubric BEFORE it is anchored (§C.7). `problems` carries schema
+ * violations, binder issues against the LIVE claim form, and the one thing the editor cannot
+ * check for itself — whether the collection's engine settings actually permit these rules.
+ */
+interface RubricPreviewResult {
+    ok: boolean;
+    problems: {
+        code: string;
+        severity: 'error' | 'warning';
+        path: string;
+        message: string;
+    }[];
+    settings: {
+        allowAiChecks: boolean;
+        allowImageChecks: boolean;
+        allowChainEvaluation: boolean;
+    };
+}
+interface RubricService {
+    /**
+     * Upload the exact rubric bytes; returns the public media URL and the sha256
+     * hex OF THOSE BYTES — which IS the rubric's id and its on-chain proof
+     * (§A.10). An implementation must hash exactly what it stores and pass the
+     * pre-serialized `json` string through untouched (no re-encoding, no
+     * re-serialization), or the id stops identifying the document.
+     */
+    uploadRubric(params: {
+        json: string;
+        fileName?: string;
+    }): Promise<{
+        url: string;
+        sha256: string;
+    }>;
+    /** Best-effort: tell the engine about the newly anchored rubric. Optional; never proof-bearing. */
+    pinRubric?(params: {
+        collectionId: string;
+        rubricId: string;
+        evalEngineUrl?: string;
+    }): Promise<void>;
+    /**
+     * Ask the engine to check a rubric it has not seen yet (§C.7). Read-only — writes nothing and
+     * anchors nothing. Optional: a host without it falls back to the local Ajv shape gate, which is
+     * strictly weaker (no form binding, no settings check).
+     */
+    previewRubric?(params: {
+        collectionId: string;
+        rubric: unknown;
+        evalEngineUrl?: string;
+        /**
+         * True only on a user gesture that is ALREADY collecting a PIN (the publish step). Otherwise
+         * the host mints silently and returns `null` rather than interrupting authoring with a modal.
+         */
+        interactive?: boolean;
+        /**
+         * The engine settings the author INTENDS to enrol with — lets the engine judge AI rules
+         * truthfully before the collection is enrolled (the stored row doesn't exist yet, or is stale
+         * against the block's unexecuted toggles). Absent = the engine falls back to its stored row.
+         */
+        settings?: {
+            allowAiChecks: boolean;
+            allowImageChecks: boolean;
+            allowChainEvaluation: boolean;
+        };
+    }): Promise<RubricPreviewResult | null>;
+    /**
+     * Fetch the engine's canonical rubric JSON Schema — a public GET of
+     * `/v1/rubric-schema` (§A.12). `run()` compiles it once with Ajv and validates
+     * the built envelope's SHAPE against it (the defense that the editor can never
+     * publish a shape the engine rejects). `evalEngineUrl` is optional — the host
+     * resolves it from its configured network when omitted.
+     */
+    getRubricSchema?: (evalEngineUrl?: string) => Promise<object>;
+    /**
+     * Test a single §A.14 external source live (§B.5): the host makes the real
+     * UCAN-signed HTTP call to `source.audience` with the author's `sampleValues`
+     * (one per `send` key) and returns what happened. Optional — the builder
+     * disables the Test button and shows a hint when a host hasn't wired it.
+     */
+    testExternalSource?: (params: {
+        source: object;
+        sampleValues?: Record<string, string | number | boolean>;
+    }) => Promise<SourcePreviewResult>;
+    /**
+     * Resolve a §A.14 source's `did:web:` audience from its endpoint — a public
+     * host read (no signing, no PIN), so the builder can auto-fill `audience`
+     * instead of asking the author to paste a DID. `resolved:false` (or an absent
+     * handler) falls back to a manual `audience` box; `audience` stays REQUIRED.
+     */
+    resolveSourceDid?: (params: {
+        endpoint: string;
+    }) => Promise<{
+        did: string | null;
+        resolved: boolean;
+        error: string | null;
+    }>;
+    /**
+     * The protocol entity's existing `#rub` LinkedResource — its on-chain `id`
+     * EXACTLY as stored (may be the literal template `{id}#rub`) and `proof` —
+     * or `null` when the entity carries none. Read by `run()` before anchoring:
+     * IID has no update, so republishing must DELETE the existing resource and
+     * add the new one in the SAME transaction (delete first), or the chain
+     * rejects the add as a duplicated resource id (x/iid). THROWS on a genuine
+     * query failure — the publish must stop rather than add-and-fail on chain.
+     */
+    getRubricResource?: (params: {
+        protocolDid: string;
+    }) => Promise<{
+        id: string;
+        proof: string;
+    } | null>;
+}
 /**
  * The full service contract an action execution context can carry. Composed
  * from the per-domain service interfaces above so consumers can implement and
@@ -7199,6 +8051,8 @@ interface ActionServices {
     carbon?: CarbonService;
     entity?: EntityService;
     kyc?: KycService;
+    evalRegister?: EvalRegisterService;
+    rubric?: RubricService;
 }
 interface OutputSchemaField {
     path: string;
@@ -8394,4 +9248,4 @@ interface IxoEditorConfig {
     tableHandles: boolean;
 }
 
-export { type ImportProtocolTemplateResult as $, AuthzExecActionTypes as A, BlocknoteProvider as B, type SingleChoiceProposal as C, type DelegationChainValidationResult as D, type VoteResponse as E, type FlowRuntimeStateManager as F, type VoteInfo as G, type Vote as H, type InvocationStore as I, type User as J, type Addr as K, type Uint128 as L, type Expiration as M, type Status as N, type Threshold as O, type ProposalResponse as P, type Votes as Q, type CosmosMsgForEmpty as R, type StoredDelegation as S, type Timestamp as T, type UcanDelegationStore as U, ValidatorActionType as V, type ProposalAction as W, type ListProtocolDeedsWithTemplatesParams as X, type ProtocolDeedWithTemplates as Y, type ProtocolTemplateSummary as Z, type ImportProtocolTemplatesToSpaceParams as _, createUcanDelegationStore as a, assertRunActionExecutionAllowed as a$, type MatrixPrivacySettings as a0, type MatrixRoom as a1, type MatrixSpace as a2, type MatrixSubspace as a3, type MatrixSpaceStructure as a4, type Translate as a5, type FlowNode as a6, type FlowNodeAuthzExtension as a7, type EvaluationStatus as a8, type IxoEditorType as a9, type FlowMetadata as aA, createYDocRuntimeManager as aB, clearRuntimeForTemplateClone as aC, LEGACY_RUN_STORAGE_VERSION as aD, MULTI_RUN_STORAGE_VERSION as aE, RUNS_TERMINAL_MAP_KEY as aF, RUN_STORAGE_VERSION_KEY as aG, adoptLegacyRuntime as aH, clearAllActionState as aI, collectPhantomLegacyRun as aJ, createRunRuntimeReader as aK, createRunRuntimeReaderWithDoc as aL, createRunScopedRuntimeManager as aM, deleteActionState as aN, enableMultiRunStorage as aO, ensureRun as aP, getRunActionsMap as aQ, getRunMeta as aR, getRunsMap as aS, getRunsTerminalMap as aT, getRunStorageVersion as aU, hasLegacyRuntimeHistory as aV, isLegacyRuntimeAdoptionEnabled as aW, isRecordInRun as aX, readActionState as aY, readActionStates as aZ, resetActionState as a_, type PendingInvocation as aa, type ActionServices as ab, type ActionHandlers as ac, type RunEventAppender as ad, type ActionResult as ae, type ActionDefinition as af, type FlowNodeRuntimeState as ag, type IxoBlockProps as ah, type VisualizationRenderer as ai, type DynamicListData as aj, type DynamicListDataProvider as ak, type DynamicListPanelRenderer as al, type DomainCardRenderer as am, type DomainCardData as an, type UnlMapConfig as ao, type ActionDoneContract as ap, type ActionEventDefinition as aq, type OutputSchemaField as ar, type RunEventInput as as, type RunJsonValue as at, type ActionRunContext as au, type CompletionCheck as av, type ActionReadBackMetadata as aw, type ReadBackTerminalState as ax, type ActionProofDeclaration as ay, type RunRecordDetails as az, createMemoryUcanDelegationStore as b, type CollectionService as b$, isBelowTheLineBlock as b0, resolveActiveRunId as b1, resolveRecordRunId as b2, resolveRunIdForExecution as b3, resolveRunIdForRead as b4, seedRunFromLegacyRuntime as b5, setMultiRunStorage as b6, subscribeToActionState as b7, usesLegacyRuntimeCompatibility as b8, writeActionState as b9, RunNotReadyError as bA, type CancelRunParams as bB, type CloseRunParams as bC, type ActionRunEventInput as bD, type FinishRunResult as bE, type MigrateFlowParams as bF, type MigrateFlowResult as bG, type LifecycleRunEventInput as bH, type RunDefinitionBlock as bI, type RunDefinitionDrift as bJ, type RunDefinitionSnapshot as bK, type RunJsonObject as bL, type RunLogEventInput as bM, type RunLifecycleAuthorizationDecision as bN, type RunLifecycleAuthorizationRequest as bO, type RunLifecycleAuthorizer as bP, type RunLifecycleCapability as bQ, type RunManifest as bR, type RunSnapshot as bS, type StartRunParams as bT, type StartRunResult as bU, type ActionContext as bV, type HttpService as bW, type EmailService as bX, type NotifyService as bY, type BidService as bZ, type ClaimService as b_, ExplicitRunRequiredError as ba, TerminalRunExecutionError as bb, UnknownRunError as bc, type RunMeta as bd, type MultiRunMigrationResult as be, type RunStorageVersion as bf, type RunTerminalRecord as bg, buildRunDefinitionSnapshot as bh, cancelRun as bi, closeRun as bj, computeRunDefinitionHash as bk, computeRunSummary as bl, createRunId as bm, createRunUlid as bn, detectRunDefinitionDrift as bo, listOpenRuns as bp, listRuns as bq, migrateFlowToSessions as br, readRunActionStates as bs, recordRunDefinitionDrift as bt, setAdvisoryActiveRunId as bu, startRun as bv, toRunJsonValue as bw, FlowNotMigratedError as bx, RunLifecycleAuthorizationError as by, RunNotMigratedError as bz, createRuntimeStateManager as c, type CollectionUsersService as c0, type MatrixCredentialService as c1, type IntegrationsService as c2, type OracleService as c3, type CarbonService as c4, type EntityService as c5, type FlowRunLifecycleService as c6, appendRunRecord as c7, readRunRecords as c8, getPendingInvocationsMap as c9, countPendingInvocations as ca, getOrCreateBlockPendingMap as cb, readPendingInvocations as cc, queuePendingInvocation as cd, removePendingInvocation as ce, findFailedListenersForSourceRun as cf, replayFailedListenerRun as cg, snapshotInputRefs as ch, computePendingInvocationId as ci, RUN_RECORD_AUDIT_TYPE as cj, type FailedListenerRun as ck, type DID as cl, type ClaimCollectionURI as cm, type LinkedClaim as cn, type NodeServiceReport as co, type NodeState as cp, type FlowNodeBase as cq, type InvocationRequest as cr, type InvocationResult as cs, type ExecutionWithInvocationResult as ct, type FindProofsResult as cu, type CreateRootDelegationParams as cv, type CreateDelegationParams as cw, type CreateInvocationParams as cx, createInvocationStore as d, createMemoryInvocationStore as e, createUcanService as f, type UcanService as g, type UcanServiceConfig as h, type UcanServiceHandlers as i, type UcanCapability as j, type StoredInvocation as k, type DelegationGrant as l, type IxoEditorOptions as m, type IxoEditorTheme as n, type IxoEditorConfig as o, type IxoCollaborativeUser as p, type IxoCollaborativeEditorOptions as q, blockSpecs as r, getExtraSlashMenuItems as s, useBlocknoteHandlers as t, useBlocknoteContext as u, useTranslate as v, StakeType as w, type BlocknoteHandlers as x, type BlocknoteContextValue as y, type BlockRequirements as z };
+export { type ImportProtocolTemplateResult as $, AuthzExecActionTypes as A, BlocknoteProvider as B, type SingleChoiceProposal as C, type DelegationChainValidationResult as D, type VoteResponse as E, type FlowRuntimeStateManager as F, type VoteInfo as G, type Vote as H, type InvocationStore as I, type User as J, type Addr as K, type Uint128 as L, type Expiration as M, type Status as N, type Threshold as O, type ProposalResponse as P, type Votes as Q, type CosmosMsgForEmpty as R, type StoredDelegation as S, type Timestamp as T, type UcanDelegationStore as U, ValidatorActionType as V, type ProposalAction as W, type ListProtocolDeedsWithTemplatesParams as X, type ProtocolDeedWithTemplates as Y, type ProtocolTemplateSummary as Z, type ImportProtocolTemplatesToSpaceParams as _, createUcanDelegationStore as a, assertRunActionExecutionAllowed as a$, type MatrixPrivacySettings as a0, type MatrixRoom as a1, type MatrixSpace as a2, type MatrixSubspace as a3, type MatrixSpaceStructure as a4, type Translate as a5, type FlowNode as a6, type FlowNodeAuthzExtension as a7, type EvaluationStatus as a8, type IxoEditorType as a9, type FlowMetadata as aA, createYDocRuntimeManager as aB, clearRuntimeForTemplateClone as aC, LEGACY_RUN_STORAGE_VERSION as aD, MULTI_RUN_STORAGE_VERSION as aE, RUNS_TERMINAL_MAP_KEY as aF, RUN_STORAGE_VERSION_KEY as aG, adoptLegacyRuntime as aH, clearAllActionState as aI, collectPhantomLegacyRun as aJ, createRunRuntimeReader as aK, createRunRuntimeReaderWithDoc as aL, createRunScopedRuntimeManager as aM, deleteActionState as aN, enableMultiRunStorage as aO, ensureRun as aP, getRunActionsMap as aQ, getRunMeta as aR, getRunsMap as aS, getRunsTerminalMap as aT, getRunStorageVersion as aU, hasLegacyRuntimeHistory as aV, isLegacyRuntimeAdoptionEnabled as aW, isRecordInRun as aX, readActionState as aY, readActionStates as aZ, resetActionState as a_, type PendingInvocation as aa, type ActionServices as ab, type ActionHandlers as ac, type RunEventAppender as ad, type ActionResult as ae, type ActionDefinition as af, type FlowNodeRuntimeState as ag, type IxoBlockProps as ah, type VisualizationRenderer as ai, type DynamicListData as aj, type DynamicListDataProvider as ak, type DynamicListPanelRenderer as al, type DomainCardRenderer as am, type DomainCardData as an, type UnlMapConfig as ao, type ActionDoneContract as ap, type ActionEventDefinition as aq, type OutputSchemaField as ar, type RunEventInput as as, type RunJsonValue as at, type ActionRunContext as au, type CompletionCheck as av, type ActionReadBackMetadata as aw, type ReadBackTerminalState as ax, type ActionProofDeclaration as ay, type RunRecordDetails as az, createMemoryUcanDelegationStore as b, type CollectionService as b$, isBelowTheLineBlock as b0, resolveActiveRunId as b1, resolveRecordRunId as b2, resolveRunIdForExecution as b3, resolveRunIdForRead as b4, seedRunFromLegacyRuntime as b5, setMultiRunStorage as b6, subscribeToActionState as b7, usesLegacyRuntimeCompatibility as b8, writeActionState as b9, RunNotReadyError as bA, type CancelRunParams as bB, type CloseRunParams as bC, type ActionRunEventInput as bD, type FinishRunResult as bE, type MigrateFlowParams as bF, type MigrateFlowResult as bG, type LifecycleRunEventInput as bH, type RunDefinitionBlock as bI, type RunDefinitionDrift as bJ, type RunDefinitionSnapshot as bK, type RunJsonObject as bL, type RunLogEventInput as bM, type RunLifecycleAuthorizationDecision as bN, type RunLifecycleAuthorizationRequest as bO, type RunLifecycleAuthorizer as bP, type RunLifecycleCapability as bQ, type RunManifest as bR, type RunSnapshot as bS, type StartRunParams as bT, type StartRunResult as bU, type ActionContext as bV, type HttpService as bW, type EmailService as bX, type NotifyService as bY, type BidService as bZ, type ClaimService as b_, ExplicitRunRequiredError as ba, TerminalRunExecutionError as bb, UnknownRunError as bc, type RunMeta as bd, type MultiRunMigrationResult as be, type RunStorageVersion as bf, type RunTerminalRecord as bg, buildRunDefinitionSnapshot as bh, cancelRun as bi, closeRun as bj, computeRunDefinitionHash as bk, computeRunSummary as bl, createRunId as bm, createRunUlid as bn, detectRunDefinitionDrift as bo, listOpenRuns as bp, listRuns as bq, migrateFlowToSessions as br, readRunActionStates as bs, recordRunDefinitionDrift as bt, setAdvisoryActiveRunId as bu, startRun as bv, toRunJsonValue as bw, FlowNotMigratedError as bx, RunLifecycleAuthorizationError as by, RunNotMigratedError as bz, createRuntimeStateManager as c, type CollectionUsersService as c0, type MatrixCredentialService as c1, type IntegrationsService as c2, type OracleService as c3, type CarbonService as c4, type EntityService as c5, type EvalRegisterService as c6, type RubricService as c7, type FlowRunLifecycleService as c8, appendRunRecord as c9, readRunRecords as ca, getPendingInvocationsMap as cb, countPendingInvocations as cc, getOrCreateBlockPendingMap as cd, readPendingInvocations as ce, queuePendingInvocation as cf, removePendingInvocation as cg, findFailedListenersForSourceRun as ch, replayFailedListenerRun as ci, snapshotInputRefs as cj, computePendingInvocationId as ck, RUN_RECORD_AUDIT_TYPE as cl, type FailedListenerRun as cm, type DID as cn, type ClaimCollectionURI as co, type LinkedClaim as cp, type NodeServiceReport as cq, type NodeState as cr, type FlowNodeBase as cs, type InvocationRequest as ct, type InvocationResult as cu, type ExecutionWithInvocationResult as cv, type FindProofsResult as cw, type CreateRootDelegationParams as cx, type CreateDelegationParams as cy, type CreateInvocationParams as cz, createInvocationStore as d, createMemoryInvocationStore as e, createUcanService as f, type UcanService as g, type UcanServiceConfig as h, type UcanServiceHandlers as i, type UcanCapability as j, type StoredInvocation as k, type DelegationGrant as l, type IxoEditorOptions as m, type IxoEditorTheme as n, type IxoEditorConfig as o, type IxoCollaborativeUser as p, type IxoCollaborativeEditorOptions as q, blockSpecs as r, getExtraSlashMenuItems as s, useBlocknoteHandlers as t, useBlocknoteContext as u, useTranslate as v, StakeType as w, type BlocknoteHandlers as x, type BlocknoteContextValue as y, type BlockRequirements as z };