@ixo/editor 6.33.0 → 6.34.0

package/dist/index-b9xxXGFs.d.ts

@@ -0,0 +1,1230 @@
+import './legacy-BpgIqaQ5.js';
+import * as Y from 'yjs';
+
+/** JSON values accepted by the Manifest v2 portable contract. */
+type ManifestV2JsonValue = null | boolean | number | string | ManifestV2JsonValue[] | {
+    [key: string]: ManifestV2JsonValue;
+};
+interface ActionManifestV2Package {
+    name: string;
+    version: string;
+    sourceCommit: string;
+    buildId?: string;
+    distributionUrl?: string;
+}
+interface ActionManifestV2Issuer {
+    did: string;
+    verificationMethod: string;
+}
+interface ActionManifestV2Compatibility {
+    engine: {
+        versionRange: string;
+    };
+    flowSchemaVersions: string[];
+    features: string[];
+}
+/**
+ * The complete action and primitive groups are introduced by the registry
+ * migration. Keeping their extension fields JSON-only prevents executable
+ * functions or class instances from crossing this portable boundary.
+ */
+type ActionManifestV2Action = {
+    type: string;
+    contractVersion: string;
+    aliases?: string[];
+} & Record<string, ManifestV2JsonValue>;
+type ActionManifestV2Primitive = {
+    type: string;
+    contractVersion: string;
+    aliases?: string[];
+} & Record<string, ManifestV2JsonValue>;
+/** The unsigned, portable portion of an Action Manifest v2 envelope. */
+interface ActionManifestV2Payload {
+    manifestVersion: '2.0';
+    manifestId: string;
+    generatedAt: string;
+    package: ActionManifestV2Package;
+    issuer: ActionManifestV2Issuer;
+    compatibility: ActionManifestV2Compatibility;
+    actions: ActionManifestV2Action[];
+    primitives: ActionManifestV2Primitive[];
+}
+interface ActionManifestV2Integrity {
+    canonicalization: 'RFC8785';
+    digest: {
+        algorithm: 'SHA-256';
+        value: `sha256:${string}`;
+    };
+    signature: {
+        algorithm: string;
+        verificationMethod: string;
+        value: string;
+    };
+}
+type SignedActionManifestV2 = ActionManifestV2Payload & {
+    integrity: ActionManifestV2Integrity;
+};
+declare const verifiedActionManifestV2: unique symbol;
+type DeepReadonly<T> = T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+/** A manifest that crossed the trust-policy boundary successfully. */
+type VerifiedActionManifestV2 = DeepReadonly<SignedActionManifestV2> & {
+    readonly [verifiedActionManifestV2]: true;
+};
+interface ActionManifestV2Signer {
+    issuerDid: string;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface ActionManifestV2SignatureVerificationInput {
+    issuerDid: string;
+    verificationMethod: string;
+    algorithm: string;
+    data: Uint8Array;
+    signature: string;
+}
+interface ActionManifestV2TrustPolicy {
+    trustedIssuerDids: readonly string[];
+    revokedIssuerDids?: readonly string[];
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: ActionManifestV2SignatureVerificationInput): Promise<boolean>;
+}
+type ActionManifestV2VerificationErrorCode = 'INVALID_MANIFEST' | 'UNSUPPORTED_MANIFEST_VERSION' | 'UNSIGNED_MANIFEST' | 'SIGNER_MISMATCH' | 'DUPLICATE_CONTRACT_TYPE' | 'AMBIGUOUS_ALIAS' | 'UNSORTED_CONTRACTS' | 'UNTRUSTED_ISSUER' | 'REVOKED_ISSUER' | 'VERIFICATION_METHOD_MISMATCH' | 'DISALLOWED_SIGNATURE_ALGORITHM' | 'DIGEST_MISMATCH' | 'INVALID_SIGNATURE';
+declare class ActionManifestV2VerificationError extends Error {
+    readonly code: ActionManifestV2VerificationErrorCode;
+    constructor(code: ActionManifestV2VerificationErrorCode, message: string);
+}
+/**
+ * Serialize a Manifest v2 payload using the RFC 8785 JSON Canonicalization
+ * Scheme. Invalid JSON-domain values are rejected rather than being silently
+ * omitted or coerced.
+ */
+declare function canonicalizeManifestV2Payload(payload: ActionManifestV2Payload): string;
+/** Compute the content address for the unsigned Manifest v2 payload. */
+declare function computeActionManifestV2Digest(payload: ActionManifestV2Payload): Promise<string>;
+/**
+ * Sign a portable Manifest v2 payload. The host owns key resolution and the
+ * concrete signature algorithm; this module owns canonical bytes and issuer
+ * binding.
+ */
+declare function signActionManifestV2(payload: ActionManifestV2Payload, signer: ActionManifestV2Signer): Promise<SignedActionManifestV2>;
+/**
+ * Load a signed manifest across the execution trust boundary. Every failure
+ * throws; this API never returns a partially trusted or downgraded contract.
+ */
+declare function verifyActionManifestV2(candidate: unknown, trustPolicy: ActionManifestV2TrustPolicy): Promise<VerifiedActionManifestV2>;
+
+type CanonicalJsonValue = null | boolean | number | string | CanonicalJsonValue[] | {
+    [key: string]: CanonicalJsonValue;
+};
+/** Recursively freeze canonical data after it crosses a signature boundary. */
+declare function deepFreezeJson<T>(value: T): T;
+/** RFC 8785 JSON canonicalization for portable Flow contracts. */
+declare function canonicalizeJson(value: CanonicalJsonValue): string;
+/** Compute a portable SHA-256 content address over RFC 8785 bytes. */
+declare function digestCanonicalJson(value: CanonicalJsonValue): Promise<`sha256:${string}`>;
+
+type Brand<Value, Name extends string> = Value & {
+    readonly __brand: Name;
+};
+type FlowId = Brand<string, 'FlowId'>;
+type FlowRevisionId = Brand<string, 'FlowRevisionId'>;
+type Sha256Digest = Brand<`sha256:${string}`, 'Sha256Digest'>;
+type RunId = Brand<string, 'RunId'>;
+type AttemptId = Brand<string, 'AttemptId'>;
+type EventId = Brand<string, 'EventId'>;
+type ReceiptId = Brand<string, 'ReceiptId'>;
+type IdempotencyKey = Brand<string, 'IdempotencyKey'>;
+type DID = Brand<string, 'DID'>;
+type FlowJsonValue = CanonicalJsonValue;
+type FlowJsonObject = {
+    [key: string]: FlowJsonValue;
+};
+type ActionSafety = 'pure' | 'provider_idempotent' | 'fenced' | 'approval_only';
+type EffectDisposition = 'not_started' | 'armed' | 'succeeded' | 'failed_before_effect' | 'needs_verification';
+type FlowDataClassification = 'public' | 'shared' | 'confidential' | 'restricted';
+interface FlowDefinitionRef {
+    flowId: FlowId;
+    revision: FlowRevisionId;
+    digest: Sha256Digest;
+}
+/** Identity fields copied from, and verified against, a signed Topic request. */
+interface TopicRequestRefV1 {
+    requestId: string;
+    requestKind: string;
+    requestDigest: Sha256Digest;
+}
+interface ActionContractRef {
+    type: string;
+    can: string;
+    contractVersion: string;
+    contractDigest: Sha256Digest;
+    manifestDigest: Sha256Digest;
+}
+interface ActionContractV1 extends ActionContractRef {
+    kind: 'qi.action.contract';
+    schemaVersion: '1.0';
+    inputSchema: FlowJsonObject;
+    outputSchema: FlowJsonObject;
+    safety: ActionSafety;
+    handlerVersion: string;
+    dataClassification: FlowDataClassification;
+    requiredServices: readonly string[];
+    idempotency: {
+        providerKey: boolean;
+        readback: 'required' | 'supported' | 'unavailable';
+        compensation: 'required' | 'supported' | 'unavailable';
+    };
+}
+type FlowTriggerV1 = {
+    kind: 'manual';
+} | {
+    kind: 'flow.start';
+} | {
+    kind: 'step.event';
+    sourceBlockId: string;
+    eventName: string;
+} | {
+    kind: 'step.event.all';
+    sources: readonly {
+        sourceBlockId: string;
+        eventName: string;
+        alias: string;
+        optional?: boolean;
+    }[];
+} | {
+    kind: 'schedule';
+    scheduleRef: string;
+    scheduleRevision?: number;
+} | {
+    kind: 'topic.request';
+    requestKind: string;
+};
+interface FlowStepTtlV1 {
+    absoluteDueDate?: string;
+    fromEnablement?: string;
+    fromCommitment?: string;
+}
+interface FlowStepDefinitionV1 {
+    stepId: string;
+    blockId: string;
+    title: string;
+    description?: string;
+    action: ActionContractRef;
+    resource: string;
+    configuration: FlowJsonObject;
+    inputs: FlowJsonObject;
+    trigger: FlowTriggerV1;
+    conditions: readonly FlowJsonObject[];
+    actor: FlowJsonObject;
+    ttlMs?: number;
+    ttl?: FlowStepTtlV1;
+}
+interface FlowDefinitionRevisionPayloadV1 {
+    kind: 'qi.flow.definition-revision';
+    schemaVersion: '1.0';
+    ref: Omit<FlowDefinitionRef, 'digest'>;
+    parent?: FlowDefinitionRef;
+    publishedAt: string;
+    publishedBy: DID;
+    actionManifestDigest: Sha256Digest;
+    title: string;
+    goal?: string;
+    steps: readonly FlowStepDefinitionV1[];
+    participantRequirements: readonly FlowJsonObject[];
+    connectionRequirements: readonly FlowJsonObject[];
+    source?: {
+        operation: 'republish-legacy' | 'instantiate-template' | 'fork';
+        ref: string;
+    };
+}
+interface FlowContractIntegrityV1 {
+    canonicalization: 'RFC8785';
+    digest: {
+        algorithm: 'SHA-256';
+        value: Sha256Digest;
+    };
+    signature: {
+        algorithm: string;
+        verificationMethod: string;
+        value: string;
+    };
+}
+type FlowDefinitionRevisionV1 = FlowDefinitionRevisionPayloadV1 & {
+    integrity: FlowContractIntegrityV1;
+};
+declare const verifiedFlowDefinitionRevision: unique symbol;
+type VerifiedFlowDefinitionRevisionV1 = Readonly<FlowDefinitionRevisionV1> & {
+    readonly [verifiedFlowDefinitionRevision]: true;
+};
+interface RuntimeContractV1 {
+    kind: 'qi.flow.runtime-contract';
+    protocolVersion: '1';
+    minimumPeerVersion: string;
+    definition: FlowDefinitionRef;
+    actionManifestDigest: Sha256Digest;
+    topicProtocolVersion: string;
+    enabledFeatures: readonly string[];
+}
+interface ExecutionPolicyPayloadV1 {
+    kind: 'qi.flow.execution-policy';
+    schemaVersion: '1.0';
+    definition: FlowDefinitionRef;
+    mode: 'enabled' | 'pause_new_effects';
+    issuedAt: string;
+    expiresAt?: string;
+    issuedBy: DID;
+    reason?: string;
+}
+type ExecutionPolicyV1 = ExecutionPolicyPayloadV1 & {
+    integrity: FlowContractIntegrityV1;
+};
+declare const verifiedExecutionPolicy: unique symbol;
+type VerifiedExecutionPolicyV1 = Readonly<ExecutionPolicyV1> & {
+    readonly [verifiedExecutionPolicy]: true;
+};
+interface ExecutionPolicySigner {
+    issuerDid: DID;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface ExecutionPolicyTrustPolicy {
+    trustedIssuerDids: readonly DID[];
+    revokedIssuerDids?: readonly DID[];
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: {
+        issuerDid: DID;
+        verificationMethod: string;
+        algorithm: string;
+        data: Uint8Array;
+        signature: string;
+    }): Promise<boolean>;
+}
+interface VerifiedInvocation {
+    cid: string;
+    issuer: DID;
+    audience: DID;
+    can: string;
+    with: string;
+    expiresAt?: string;
+    proofCids: readonly string[];
+    definitionDigest: Sha256Digest;
+    actionContractDigest?: Sha256Digest;
+    idempotencyKey?: IdempotencyKey;
+    /** Present only when the authorizer verified the signed Topic request caveat. */
+    topicRequest?: Readonly<TopicRequestRefV1>;
+}
+interface FlowDefinitionRevisionSigner {
+    issuerDid: DID;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface FlowDefinitionRevisionTrustPolicy {
+    trustedIssuerDids: readonly DID[];
+    revokedIssuerDids?: readonly DID[];
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: {
+        issuerDid: DID;
+        verificationMethod: string;
+        algorithm: string;
+        data: Uint8Array;
+        signature: string;
+    }): Promise<boolean>;
+}
+declare class FlowDefinitionVerificationError extends Error {
+    readonly code: 'INVALID_DEFINITION' | 'DIGEST_MISMATCH' | 'SIGNER_MISMATCH' | 'UNTRUSTED_ISSUER' | 'REVOKED_ISSUER' | 'DISALLOWED_SIGNATURE_ALGORITHM' | 'INVALID_SIGNATURE';
+    constructor(code: 'INVALID_DEFINITION' | 'DIGEST_MISMATCH' | 'SIGNER_MISMATCH' | 'UNTRUSTED_ISSUER' | 'REVOKED_ISSUER' | 'DISALLOWED_SIGNATURE_ALGORITHM' | 'INVALID_SIGNATURE', message: string);
+}
+declare function computeExecutionPolicyDigest(payload: ExecutionPolicyPayloadV1): Promise<Sha256Digest>;
+declare function signExecutionPolicy(payload: ExecutionPolicyPayloadV1, signer: ExecutionPolicySigner): Promise<ExecutionPolicyV1>;
+declare function verifyExecutionPolicy(candidate: ExecutionPolicyV1, policy: ExecutionPolicyTrustPolicy, now?: Date): Promise<VerifiedExecutionPolicyV1>;
+declare function computeFlowDefinitionDigest(payload: FlowDefinitionRevisionPayloadV1): Promise<Sha256Digest>;
+declare function signFlowDefinitionRevision(payload: FlowDefinitionRevisionPayloadV1, signer: FlowDefinitionRevisionSigner): Promise<FlowDefinitionRevisionV1>;
+declare function verifyFlowDefinitionRevision(candidate: FlowDefinitionRevisionV1, policy: FlowDefinitionRevisionTrustPolicy): Promise<VerifiedFlowDefinitionRevisionV1>;
+interface FlowDefinitionRevisionRepository {
+    get(ref: FlowDefinitionRef): Promise<VerifiedFlowDefinitionRevisionV1 | null>;
+    publish(revision: FlowDefinitionRevisionV1, expectedParent?: FlowDefinitionRef): Promise<'published' | 'exists' | 'parent_conflict'>;
+}
+interface VerifiedActionContractResolver {
+    resolve(ref: ActionContractRef): Promise<ActionContractV1>;
+}
+declare const FLOW_CAPABILITIES: {
+    readonly definitionRead: "flow/definition.read";
+    readonly definitionWrite: "flow/definition.write";
+    readonly definitionPublish: "flow/definition.publish";
+    readonly definitionClone: "flow/definition.clone";
+    readonly runStart: "flow/run.start";
+    readonly runClose: "flow/run.close";
+    readonly runCancel: "flow/run.cancel";
+    readonly actionExecute: "flow/action.execute";
+    readonly topicBindFlow: "topic/bind-flow";
+    readonly topicRequestAction: "topic/request-action";
+    readonly topicRecordAction: "topic/record-action";
+};
+declare function buildFlowResourceUri(definition: Pick<FlowDefinitionRef, 'flowId' | 'revision'>, target?: {
+    kind: 'run';
+    runId: RunId;
+} | {
+    kind: 'step';
+    stepId: string;
+    runId?: RunId;
+}): string;
+
+declare function deriveRunId(definition: FlowDefinitionRef, launchKind: string, launchNonce: string): Promise<RunId>;
+declare function deriveAttemptId(params: {
+    runId: RunId;
+    stepId: string;
+    idempotencyKey: IdempotencyKey;
+    inputDigest: Sha256Digest;
+}): Promise<AttemptId>;
+declare function deriveEventId(unsignedEvent: FlowJsonValue): Promise<EventId>;
+declare function deriveReceiptId(params: {
+    topicRequestId: string;
+    attemptId: AttemptId;
+    phase: string;
+    eventId: EventId;
+}): Promise<ReceiptId>;
+declare function deriveEffectClaimKey(params: {
+    definition: FlowDefinitionRef;
+    runId: RunId;
+    stepId: string;
+    attemptId: AttemptId;
+    actorDid: string;
+    inputDigest: Sha256Digest;
+    action: ActionContractRef;
+    topicBindingId?: string;
+}): Promise<Sha256Digest>;
+
+interface RunGenesisV1 {
+    kind: 'qi.flow.run-genesis';
+    schemaVersion: '1.0';
+    runId: RunId;
+    definition: FlowDefinitionRef;
+    launchKind: 'manual' | 'topic.request' | 'schedule' | 'event';
+    launchNonce: string;
+    requiredStepIds: readonly string[];
+    startedBy: DID;
+    startedAt: string;
+    topicBindingId?: string;
+}
+interface ActionOutcomeEvidenceV1 {
+    name: string;
+    payload: FlowJsonObject;
+    payloadDigest: Sha256Digest;
+}
+type RunTerminalStatusV1 = 'completed' | 'failed' | 'cancelled';
+interface RunFinalizationAttemptSummaryV1 {
+    attemptId: AttemptId;
+    stepId: string;
+    disposition: EffectDisposition;
+    receiptIds: readonly ReceiptId[];
+}
+interface RunFinalizationSummaryV1 {
+    kind: 'qi.flow.run-finalization-summary';
+    schemaVersion: '1.0';
+    status: RunTerminalStatusV1;
+    cancelRequested: boolean;
+    requiredStepIds: readonly string[];
+    frontierEventIds: readonly EventId[];
+    attempts: readonly RunFinalizationAttemptSummaryV1[];
+}
+type FlowEventPayloadV1 = {
+    kind: 'run.started';
+    genesis: RunGenesisV1;
+} | {
+    kind: 'run.cancel_requested';
+    reason?: string;
+} | {
+    kind: 'action.requested';
+    attemptId: AttemptId;
+    stepId: string;
+    inputDigest: Sha256Digest;
+} | {
+    kind: 'action.approval_proposed';
+    attemptId: AttemptId;
+    stepId: string;
+    proposalDigest: Sha256Digest;
+} | {
+    kind: 'action.started';
+    attemptId: AttemptId;
+    stepId: string;
+} | {
+    kind: 'action.effect_armed';
+    attemptId: AttemptId;
+    stepId: string;
+    claimKey: Sha256Digest;
+    fencingEpoch: number;
+} | {
+    kind: 'action.succeeded';
+    attemptId: AttemptId;
+    stepId: string;
+    outputDigest: Sha256Digest;
+    outcomes?: readonly ActionOutcomeEvidenceV1[];
+    providerCorrelation?: string;
+    claimKey?: Sha256Digest;
+    fencingEpoch?: number;
+} | ({
+    kind: 'action.outcome_emitted';
+    attemptId: AttemptId;
+    stepId: string;
+} & ActionOutcomeEvidenceV1) | {
+    kind: 'action.failed_before_effect';
+    attemptId: AttemptId;
+    stepId: string;
+    error: FlowJsonObject;
+} | {
+    kind: 'action.needs_verification';
+    attemptId: AttemptId;
+    stepId: string;
+    providerCorrelation?: string;
+    reason: string;
+} | {
+    kind: 'receipt.persisted';
+    attemptId: AttemptId;
+    receiptId: ReceiptId;
+    receiptDigest: Sha256Digest;
+} | {
+    kind: 'run.finalized';
+    status: RunTerminalStatusV1;
+    summary: RunFinalizationSummaryV1;
+    summaryDigest: Sha256Digest;
+} | {
+    kind: 'log';
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    data?: FlowJsonValue;
+};
+interface UnsignedFlowEventEnvelopeV1 {
+    kind: 'qi.flow.event';
+    schemaVersion: '1.0';
+    runId: RunId;
+    definition: FlowDefinitionRef;
+    producer: DID;
+    actor: DID;
+    occurredAt: string;
+    parents: readonly EventId[];
+    causationId?: EventId;
+    correlationId: string;
+    idempotencyKey: IdempotencyKey;
+    commandFingerprint: Sha256Digest;
+    /** Content references for verified UCAN invocations/delegations; never raw credentials. */
+    proofReferences: readonly string[];
+    payload: FlowEventPayloadV1;
+}
+type FlowEventEnvelopeV1 = UnsignedFlowEventEnvelopeV1 & {
+    eventId: EventId;
+    signature: {
+        algorithm: string;
+        verificationMethod: string;
+        value: string;
+    };
+};
+declare const verifiedFlowEvent: unique symbol;
+type VerifiedFlowEventEnvelopeV1 = Readonly<FlowEventEnvelopeV1> & {
+    readonly [verifiedFlowEvent]: true;
+};
+interface FlowEventSigner {
+    producerDid: DID;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface FlowEventTrustPolicy {
+    isTrustedProducer(did: DID, verificationMethod: string): Promise<boolean>;
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: {
+        producerDid: DID;
+        verificationMethod: string;
+        algorithm: string;
+        data: Uint8Array;
+        signature: string;
+    }): Promise<boolean>;
+}
+/** A deterministic carrier-content failure. Infrastructure failures from trust services are intentionally not wrapped. */
+declare class FlowEventValidationError extends Error {
+    constructor(message: string);
+}
+declare function signFlowEvent(unsigned: UnsignedFlowEventEnvelopeV1, signer: FlowEventSigner): Promise<FlowEventEnvelopeV1>;
+declare function verifyFlowEvent(event: FlowEventEnvelopeV1, policy: FlowEventTrustPolicy): Promise<VerifiedFlowEventEnvelopeV1>;
+interface FlowEventAppendResult {
+    outcome: 'appended' | 'duplicate' | 'conflict';
+    eventId: EventId;
+    streamVersion: number;
+}
+interface RejectedMatrixFlowEventV1 {
+    /** Matrix room-event identity of the rejected carrier, never the producer-claimed Flow event ID. */
+    carrierEventId: string;
+    event: FlowEventEnvelopeV1;
+    reason: string;
+}
+interface MatrixFlowEventObservationV1 {
+    acceptedEvents: readonly VerifiedFlowEventEnvelopeV1[];
+    rejectedEvents: readonly RejectedMatrixFlowEventV1[];
+}
+interface MatrixFlowEventStore {
+    append(event: FlowEventEnvelopeV1, transactionId: string): Promise<FlowEventAppendResult>;
+    /** Observe authenticated events and rejected carrier payloads separately. */
+    inspect(runId: RunId, options?: {
+        after?: EventId;
+        limit?: number;
+    }): Promise<MatrixFlowEventObservationV1>;
+    /** Convenience replay view containing authenticated events only. */
+    read(runId: RunId, options?: {
+        after?: EventId;
+        limit?: number;
+    }): Promise<readonly VerifiedFlowEventEnvelopeV1[]>;
+}
+declare function matrixFlowEventTransactionId(event: Pick<FlowEventEnvelopeV1, 'eventId'>): string;
+interface ReducedAttemptV1 {
+    attemptId: AttemptId;
+    stepId: string;
+    disposition: EffectDisposition;
+    outputDigest?: Sha256Digest;
+    providerCorrelation?: string;
+    receiptIds: readonly ReceiptId[];
+    outcomes: readonly ActionOutcomeEvidenceV1[];
+}
+interface ReducedFlowRunV1 {
+    runId: RunId;
+    definition: FlowDefinitionRef;
+    status: 'queued' | 'running' | 'cancelling' | 'needs_verification' | 'completed' | 'failed' | 'cancelled';
+    attempts: Readonly<Record<string, ReducedAttemptV1>>;
+    cancelRequested: boolean;
+    frontierEventIds: readonly EventId[];
+    finalizationCandidate?: {
+        status: RunTerminalStatusV1;
+        summary: RunFinalizationSummaryV1;
+    };
+    finalizedEventIds: readonly EventId[];
+    acceptedEventIds: readonly EventId[];
+    invalidEvents: readonly {
+        eventId: EventId;
+        reason: string;
+    }[];
+}
+/** Order-independent fold over structurally valid, already-authenticated events. */
+declare function reduceFlowEvents(genesis: RunGenesisV1, input: readonly FlowEventEnvelopeV1[]): ReducedFlowRunV1;
+declare function fingerprintFlowCommand(command: FlowJsonValue): Promise<Sha256Digest>;
+
+type EffectClaimStatus = 'claimed' | 'armed' | 'success_prepared' | 'succeeded' | 'failed_before_effect' | 'needs_verification';
+interface EffectClaimRecordV1 {
+    kind: 'qi.flow.effect-claim';
+    schemaVersion: '1.0';
+    claimKey: Sha256Digest;
+    fingerprint: Sha256Digest;
+    status: EffectClaimStatus;
+    leaseOwner: DID;
+    fencingEpoch: number;
+    leaseExpiresAt: number;
+    providerIdempotencyKey: IdempotencyKey;
+    providerCorrelation?: string;
+    /** Opaque result evidence retained so Matrix append can be replayed after a crash. */
+    outputDigest?: Sha256Digest;
+    /** Opaque digest of the normalized declared outcome set; never outcome payloads. */
+    outcomesDigest?: Sha256Digest;
+    successEventId?: EventId;
+    policyDigest: Sha256Digest;
+    updatedAt: number;
+}
+interface EffectClaimAdmissionV1 {
+    /** Raw authorization material for the remote admission boundary. Never persisted by the ledger. */
+    authorization: CanonicalJsonValue;
+    /** Process-local verified view used by in-process ledgers and remote-client expectations. */
+    invocation: VerifiedInvocation;
+    /** Signed execution policy. Never persisted; only its digest is retained. */
+    policy: ExecutionPolicyV1;
+    commandFingerprint: Sha256Digest;
+}
+interface EffectClaimRequestV1 {
+    claimKey: Sha256Digest;
+    leaseOwner: DID;
+    leaseTtlMs: number;
+    providerIdempotencyKey: IdempotencyKey;
+    policyDigest: Sha256Digest;
+    admission: EffectClaimAdmissionV1;
+}
+type EffectClaimResultV1 = {
+    outcome: 'claimed' | 'existing';
+    record: EffectClaimRecordV1;
+} | {
+    outcome: 'conflict' | 'paused';
+    record?: EffectClaimRecordV1;
+    reason: string;
+};
+interface EffectClaimLedger {
+    claim(request: EffectClaimRequestV1): Promise<EffectClaimResultV1>;
+    renew(claimKey: Sha256Digest, leaseOwner: DID, fencingEpoch: number, leaseTtlMs: number, admission: EffectClaimAdmissionV1): Promise<EffectClaimRecordV1>;
+    arm(claimKey: Sha256Digest, leaseOwner: DID, fencingEpoch: number, admission: EffectClaimAdmissionV1, providerCorrelation?: string): Promise<EffectClaimRecordV1>;
+    prepareSuccess(claimKey: Sha256Digest, leaseOwner: DID, fencingEpoch: number, outputDigest: Sha256Digest, outcomesDigest: Sha256Digest, admission: EffectClaimAdmissionV1, providerCorrelation?: string): Promise<EffectClaimRecordV1>;
+    resolve(claimKey: Sha256Digest, leaseOwner: DID, fencingEpoch: number, outcome: 'succeeded' | 'failed_before_effect', admission: EffectClaimAdmissionV1, providerCorrelation?: string, successEventId?: EventId): Promise<EffectClaimRecordV1>;
+    markNeedsVerification(claimKey: Sha256Digest, leaseOwner: DID, fencingEpoch: number, admission: EffectClaimAdmissionV1, providerCorrelation?: string): Promise<EffectClaimRecordV1>;
+    read(claimKey: Sha256Digest, admission: EffectClaimAdmissionV1): Promise<EffectClaimRecordV1 | null>;
+}
+declare class EffectClaimTransitionError extends Error {
+    readonly code: 'FINGERPRINT_CONFLICT' | 'POLICY_PAUSED' | 'LEASE_HELD' | 'STALE_FENCE' | 'INVALID_TRANSITION';
+    constructor(code: 'FINGERPRINT_CONFLICT' | 'POLICY_PAUSED' | 'LEASE_HELD' | 'STALE_FENCE' | 'INVALID_TRANSITION', message: string);
+}
+/** Pure state transition used by the Durable Object and conformance tests. */
+declare function claimEffect(existing: EffectClaimRecordV1 | null, request: EffectClaimRequestV1, now: number): EffectClaimResultV1;
+declare function renewEffectClaim(record: EffectClaimRecordV1, owner: DID, epoch: number, leaseTtlMs: number, now: number): EffectClaimRecordV1;
+declare function armEffectClaim(record: EffectClaimRecordV1, owner: DID, epoch: number, now: number, providerCorrelation?: string): EffectClaimRecordV1;
+declare function prepareEffectSuccess(record: EffectClaimRecordV1, owner: DID, epoch: number, outputDigest: Sha256Digest, outcomesDigest: Sha256Digest, now: number, providerCorrelation?: string): EffectClaimRecordV1;
+declare function resolveEffectClaim(record: EffectClaimRecordV1, owner: DID, epoch: number, outcome: 'succeeded' | 'failed_before_effect', now: number, providerCorrelation?: string, successEventId?: EventId): EffectClaimRecordV1;
+declare function markEffectNeedsVerification(record: EffectClaimRecordV1, owner: DID, epoch: number, now: number, providerCorrelation?: string): EffectClaimRecordV1;
+
+interface HistoricalActionManifestRepository {
+    getByDigest(digest: Sha256Digest): Promise<SignedActionManifestV2 | null>;
+}
+type ActionContractResolutionErrorCode = 'MANIFEST_NOT_FOUND' | 'MANIFEST_DIGEST_MISMATCH' | 'ACTION_NOT_FOUND' | 'ACTION_VERSION_MISMATCH' | 'INVALID_ACTION_CONTRACT' | 'ACTION_CONTRACT_DIGEST_MISMATCH';
+declare class ActionContractResolutionError extends Error {
+    readonly code: ActionContractResolutionErrorCode;
+    constructor(code: ActionContractResolutionErrorCode, message: string);
+}
+declare function computeActionContractDigest(contract: Omit<ActionContractV1, 'contractDigest'>): Promise<Sha256Digest>;
+/**
+ * Resolve a contract only from a signed historical manifest pinned by digest.
+ * The live registry is deliberately not an input to this execution boundary.
+ */
+declare class HistoricalManifestActionContractResolver implements VerifiedActionContractResolver {
+    private readonly repository;
+    private readonly trustPolicy;
+    private readonly verifiedManifests;
+    constructor(repository: HistoricalActionManifestRepository, trustPolicy: ActionManifestV2TrustPolicy);
+    resolve(ref: ActionContractRef): Promise<ActionContractV1>;
+    private loadManifest;
+    private verifyManifest;
+}
+
+interface VerifiedAttemptAuthorization {
+    flow: VerifiedInvocation;
+    action: VerifiedInvocation;
+    topic?: VerifiedInvocation;
+    provider?: VerifiedInvocation;
+    /** Peer-issued, ledger-addressed invocation derived from the command proof chain. */
+    effectClaim?: {
+        authorization: CanonicalJsonValue;
+        invocation: VerifiedInvocation;
+    };
+}
+/** Host-specific UCAN verification lives behind this fail-closed boundary. */
+interface InvocationAuthorizer {
+    authorizeRunStart(request: {
+        authorization: CanonicalJsonValue;
+        executorDid: DID;
+        definition: FlowDefinitionRef;
+        runId: RunId;
+        actor: DID;
+        issuedAt: string;
+        idempotencyKey: IdempotencyKey;
+    }): Promise<VerifiedInvocation>;
+    authorizeRunControl(request: {
+        authorization: CanonicalJsonValue;
+        executorDid: DID;
+        definition: FlowDefinitionRef;
+        runId: RunId;
+        actor: DID;
+        issuedAt: string;
+        idempotencyKey: IdempotencyKey;
+        can: typeof FLOW_CAPABILITIES.runCancel | typeof FLOW_CAPABILITIES.runClose;
+    }): Promise<VerifiedInvocation>;
+    authorizeAttempt(request: {
+        authorization: CanonicalJsonValue;
+        executorDid: DID;
+        definition: FlowDefinitionRef;
+        runId: RunId;
+        stepId: string;
+        action: ActionContractV1;
+        actor: DID;
+        idempotencyKey: IdempotencyKey;
+        effectClaimAudience?: DID;
+        topicBinding?: {
+            bindingId: string;
+            topicResource: string;
+        };
+        /** The authorizer must bind this reference to signed Topic request evidence. */
+        topicRequest?: TopicRequestRefV1;
+    }): Promise<VerifiedAttemptAuthorization>;
+}
+type ProviderInvocationResult = {
+    outcome: 'succeeded';
+    output: FlowJsonObject;
+    outcomes?: readonly ActionOutcomeInputV1[];
+    providerCorrelation?: string;
+} | {
+    outcome: 'failed_before_effect';
+    error: FlowJsonObject;
+} | {
+    outcome: 'ambiguous';
+    providerCorrelation?: string;
+    reason: string;
+};
+type ProviderReadbackResult = {
+    outcome: 'succeeded';
+    output: FlowJsonObject;
+    outcomes?: readonly ActionOutcomeInputV1[];
+    providerCorrelation?: string;
+} | {
+    outcome: 'not_found';
+} | {
+    outcome: 'unknown';
+    providerCorrelation?: string;
+    reason: string;
+};
+interface ActionOutcomeInputV1 {
+    name: string;
+    payload: FlowJsonObject;
+}
+declare const UNIVERSAL_ACTION_COMPLETED_OUTCOME = "step.completed";
+interface ManifestBoundActionAdapter {
+    invoke(request: {
+        contract: ActionContractV1;
+        inputs: FlowJsonObject;
+        providerIdempotencyKey: IdempotencyKey;
+        invocation: VerifiedAttemptAuthorization;
+        /** Must be called immediately before the adapter starts an external effect. */
+        assertEffectAllowed: () => void;
+    }): Promise<ProviderInvocationResult>;
+    readback(request: {
+        contract: ActionContractV1;
+        inputs: FlowJsonObject;
+        providerIdempotencyKey: IdempotencyKey;
+        providerCorrelation?: string;
+        invocation: VerifiedAttemptAuthorization;
+    }): Promise<ProviderReadbackResult>;
+}
+interface StartPeerRunCommandV1 {
+    definition: VerifiedFlowDefinitionRevisionV1;
+    launchKind: RunGenesisV1['launchKind'];
+    launchNonce: string;
+    actor: DID;
+    issuedAt: string;
+    idempotencyKey: IdempotencyKey;
+    authorization: CanonicalJsonValue;
+    topicBindingId?: string;
+}
+interface ExecutePeerAttemptCommandV1 {
+    definition: VerifiedFlowDefinitionRevisionV1;
+    genesis: RunGenesisV1;
+    stepId: string;
+    actor: DID;
+    issuedAt: string;
+    idempotencyKey: IdempotencyKey;
+    inputs: FlowJsonObject;
+    authorization: CanonicalJsonValue;
+    policy: VerifiedExecutionPolicyV1;
+    topicBinding?: {
+        bindingId: string;
+        topicResource: string;
+    };
+    topicRequest?: TopicRequestRefV1;
+}
+interface CancelPeerRunCommandV1 {
+    definition: VerifiedFlowDefinitionRevisionV1;
+    genesis: RunGenesisV1;
+    actor: DID;
+    issuedAt: string;
+    idempotencyKey: IdempotencyKey;
+    authorization: CanonicalJsonValue;
+    reason?: string;
+}
+interface FinalizePeerRunCommandV1 {
+    definition: VerifiedFlowDefinitionRevisionV1;
+    genesis: RunGenesisV1;
+    actor: DID;
+    issuedAt: string;
+    idempotencyKey: IdempotencyKey;
+    authorization: CanonicalJsonValue;
+}
+type PeerAttemptResult = {
+    outcome: 'succeeded';
+    attemptId: AttemptId;
+    outputDigest: Sha256Digest;
+    providerCorrelation?: string;
+} | {
+    outcome: 'failed_before_effect';
+    attemptId: AttemptId;
+} | {
+    outcome: 'needs_verification';
+    attemptId: AttemptId;
+    providerCorrelation?: string;
+} | {
+    outcome: 'approval_required';
+    attemptId: AttemptId;
+    proposalDigest: Sha256Digest;
+} | {
+    outcome: 'deferred';
+    attemptId: AttemptId;
+    reason: string;
+};
+interface PeerExecutor {
+    startRun(command: StartPeerRunCommandV1): Promise<RunGenesisV1>;
+    cancelRun(command: CancelPeerRunCommandV1): Promise<FlowEventEnvelopeV1>;
+    finalizeRun(command: FinalizePeerRunCommandV1): Promise<FlowEventEnvelopeV1>;
+    executeAttempt(command: ExecutePeerAttemptCommandV1): Promise<PeerAttemptResult>;
+}
+declare class PeerExecutionError extends Error {
+    readonly code: 'DEFINITION_MISMATCH' | 'STEP_NOT_FOUND' | 'POLICY_MISMATCH' | 'POLICY_PAUSED' | 'AUTHORIZATION_MISMATCH' | 'EVENT_CONFLICT' | 'EVENT_UNAVAILABLE' | 'CLAIM_CONFLICT' | 'STEP_EXPIRED' | 'POLICY_EXPIRED' | 'COMMAND_TIME_INVALID' | 'TOPIC_BINDING_REQUIRED' | 'ELIGIBILITY_EVIDENCE_REQUIRED' | 'ACTION_CONTRACT_INVALID' | 'INPUT_SCHEMA_INVALID' | 'OUTPUT_SCHEMA_INVALID' | 'RUN_CANCELLING' | 'RUN_FINALIZED' | 'RUN_NOT_FINALIZABLE';
+    constructor(code: 'DEFINITION_MISMATCH' | 'STEP_NOT_FOUND' | 'POLICY_MISMATCH' | 'POLICY_PAUSED' | 'AUTHORIZATION_MISMATCH' | 'EVENT_CONFLICT' | 'EVENT_UNAVAILABLE' | 'CLAIM_CONFLICT' | 'STEP_EXPIRED' | 'POLICY_EXPIRED' | 'COMMAND_TIME_INVALID' | 'TOPIC_BINDING_REQUIRED' | 'ELIGIBILITY_EVIDENCE_REQUIRED' | 'ACTION_CONTRACT_INVALID' | 'INPUT_SCHEMA_INVALID' | 'OUTPUT_SCHEMA_INVALID' | 'RUN_CANCELLING' | 'RUN_FINALIZED' | 'RUN_NOT_FINALIZABLE', message: string);
+}
+interface CreatePeerExecutorOptions {
+    executorDid: DID;
+    signer: FlowEventSigner;
+    events: MatrixFlowEventStore;
+    contracts: VerifiedActionContractResolver;
+    authorizer: InvocationAuthorizer;
+    actions: ManifestBoundActionAdapter;
+    effectClaims: EffectClaimLedger;
+    effectClaimAudience?: DID;
+    now?: () => number;
+}
+declare function createPeerExecutor(options: CreatePeerExecutorOptions): PeerExecutor;
+
+interface TopicReceiptOutboxRecordV1 {
+    kind: 'qi.flow.topic-receipt-outbox-record';
+    schemaVersion: '1.0';
+    receiptId: ReceiptId;
+    receiptDigest: Sha256Digest;
+    topicRequestId: string;
+    attemptId: AttemptId;
+    phase: string;
+    eventId: EventId;
+    /** Exact RFC 8785 bytes, encoded as UTF-8 text, replayed without reconstruction. */
+    canonicalReceipt: string;
+    persistedAt: string;
+    delivery?: {
+        deliveredAt: string;
+        operationId: string;
+        topicRevision: string;
+    };
+}
+interface TopicReceiptOutbox {
+    persist(record: TopicReceiptOutboxRecordV1): Promise<'persisted' | 'duplicate' | 'conflict'>;
+    pending(limit?: number): Promise<readonly TopicReceiptOutboxRecordV1[]>;
+    markDelivered(receiptId: ReceiptId, receiptDigest: Sha256Digest, delivery: {
+        deliveredAt: string;
+        operationId: string;
+        topicRevision: string;
+    }): Promise<void>;
+}
+interface TopicReceiptDelivery {
+    deliver(request: {
+        receiptId: ReceiptId;
+        receiptDigest: Sha256Digest;
+        canonicalReceipt: string;
+    }): Promise<{
+        operationId: string;
+        topicRevision: string;
+    }>;
+}
+declare function persistSignedTopicReceipt(params: {
+    outbox: TopicReceiptOutbox;
+    topicRequestId: string;
+    attemptId: AttemptId;
+    phase: string;
+    eventId: EventId;
+    signedReceipt: CanonicalJsonValue;
+    persistedAt: string;
+}): Promise<TopicReceiptOutboxRecordV1>;
+/** Replay only bytes that were durably persisted before delivery. */
+declare function drainTopicReceiptOutbox(outbox: TopicReceiptOutbox, delivery: TopicReceiptDelivery, now?: () => Date, limit?: number): Promise<Array<{
+    receiptId: ReceiptId;
+    outcome: 'delivered' | 'failed';
+    error?: string;
+}>>;
+
+declare const MATRIX_FLOW_EVENT_TYPE = "ixo.qi.flow.event.v1";
+declare const MATRIX_FLOW_DEFINITION_ANCHOR_TYPE = "ixo.qi.flow.definition-anchor.v1";
+interface MatrixRunEventCarrierV1 {
+    carrierEventId: string;
+    event: FlowEventEnvelopeV1;
+}
+interface MatrixRunEventPageV1 {
+    carriers: readonly MatrixRunEventCarrierV1[];
+    /** Opaque Matrix pagination cursor. Omit only when the transport is exhausted. */
+    nextCursor?: string;
+}
+interface MatrixRunEventTransport {
+    append(params: {
+        roomId: string;
+        eventType: typeof MATRIX_FLOW_EVENT_TYPE;
+        transactionId: string;
+        content: {
+            event: FlowEventEnvelopeV1;
+        };
+    }): Promise<FlowEventAppendResult>;
+    read(params: {
+        roomId: string;
+        runId: string;
+        afterEventId?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<MatrixRunEventPageV1>;
+}
+/** Thin Matrix carrier adapter; protocol validation remains in the shared kernel. */
+declare class MatrixRoomFlowEventStore implements MatrixFlowEventStore {
+    private readonly roomId;
+    private readonly transport;
+    private readonly trust;
+    constructor(roomId: string, transport: MatrixRunEventTransport, trust: FlowEventTrustPolicy);
+    append(event: FlowEventEnvelopeV1, transactionId: string): Promise<FlowEventAppendResult>;
+    inspect(runId: FlowEventEnvelopeV1['runId'], options?: {
+        after?: FlowEventEnvelopeV1['eventId'];
+        limit?: number;
+    }): Promise<MatrixFlowEventObservationV1>;
+    read(runId: FlowEventEnvelopeV1['runId'], options?: {
+        after?: FlowEventEnvelopeV1['eventId'];
+        limit?: number;
+    }): Promise<readonly VerifiedFlowEventEnvelopeV1[]>;
+}
+interface RevisionCipher {
+    algorithm: string;
+    keyReference: string;
+    encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+}
+interface MatrixDefinitionAnchorPayloadV1 {
+    kind: 'qi.flow.definition-anchor';
+    schemaVersion: '1.0';
+    definition: FlowDefinitionRef;
+    mediaUri: string;
+    ciphertextDigest: Sha256Digest;
+    encryption: {
+        algorithm: string;
+        keyReference: string;
+    };
+    anchoredAt: string;
+    anchoredBy: DID;
+}
+type MatrixDefinitionAnchorV1 = MatrixDefinitionAnchorPayloadV1 & {
+    integrity: {
+        canonicalization: 'RFC8785';
+        digest: {
+            algorithm: 'SHA-256';
+            value: Sha256Digest;
+        };
+        signature: {
+            algorithm: string;
+            verificationMethod: string;
+            value: string;
+        };
+    };
+};
+interface MatrixDefinitionAnchorSigner {
+    issuerDid: DID;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface MatrixDefinitionAnchorTrustPolicy {
+    trustedIssuerDids: readonly DID[];
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: {
+        issuerDid: DID;
+        verificationMethod: string;
+        algorithm: string;
+        data: Uint8Array;
+        signature: string;
+    }): Promise<boolean>;
+}
+interface MatrixDefinitionTransport {
+    putMedia(params: {
+        ciphertext: Uint8Array;
+        ciphertextDigest: Sha256Digest;
+        contentType: 'application/vnd.ixo.qi-flow-revision+json';
+    }): Promise<string>;
+    getMedia(mediaUri: string): Promise<Uint8Array>;
+    publishAnchor(params: {
+        roomId: string;
+        eventType: typeof MATRIX_FLOW_DEFINITION_ANCHOR_TYPE;
+        transactionId: string;
+        anchor: MatrixDefinitionAnchorV1;
+        expectedParent?: FlowDefinitionRef;
+    }): Promise<'published' | 'exists' | 'parent_conflict'>;
+    getAnchor(roomId: string, flowId: string, revision: FlowRevisionId): Promise<MatrixDefinitionAnchorV1 | null>;
+}
+declare function signMatrixDefinitionAnchor(payload: MatrixDefinitionAnchorPayloadV1, signer: MatrixDefinitionAnchorSigner): Promise<MatrixDefinitionAnchorV1>;
+declare function verifyMatrixDefinitionAnchor(anchor: MatrixDefinitionAnchorV1, trust: MatrixDefinitionAnchorTrustPolicy): Promise<MatrixDefinitionAnchorV1>;
+declare class EncryptedMatrixFlowDefinitionRevisionRepository implements FlowDefinitionRevisionRepository {
+    private readonly roomId;
+    private readonly transport;
+    private readonly cipher;
+    private readonly anchorSigner;
+    private readonly anchorTrust;
+    private readonly definitionTrust;
+    private readonly now;
+    constructor(roomId: string, transport: MatrixDefinitionTransport, cipher: RevisionCipher, anchorSigner: MatrixDefinitionAnchorSigner, anchorTrust: MatrixDefinitionAnchorTrustPolicy, definitionTrust: FlowDefinitionRevisionTrustPolicy, now?: () => Date);
+    publish(revision: FlowDefinitionRevisionV1, expectedParent?: FlowDefinitionRef): Promise<'published' | 'exists' | 'parent_conflict'>;
+    get(ref: FlowDefinitionRef): Promise<VerifiedFlowDefinitionRevisionV1 | null>;
+}
+
+interface ComposioActionAvailabilityPayloadV1 {
+    kind: 'qi.composio.action-availability';
+    schemaVersion: '1.0';
+    issuedBy: DID;
+    actionContractDigest: Sha256Digest;
+    handlerIdentity: string;
+    handlerVersion: string;
+    inputSchemaDigest: Sha256Digest;
+    outputSchemaDigest: Sha256Digest;
+    toolkit: string;
+    toolSlug: string;
+    readbackToolSlug?: string;
+    accountBinding: {
+        bindingId: string;
+        connectedAccountReference: string;
+    };
+    ucanAudience: string;
+    providerIdempotency: boolean;
+    readback: 'required' | 'supported' | 'unavailable';
+    compensation: 'required' | 'supported' | 'unavailable';
+    redaction: {
+        inputPaths: readonly string[];
+        outputPaths: readonly string[];
+    };
+    receiptCorrelation: {
+        field: string;
+    };
+    status: 'available' | 'unavailable';
+    unavailableReasons: readonly string[];
+    checkedAt: string;
+    expiresAt: string;
+}
+type ComposioActionAvailabilityV1 = ComposioActionAvailabilityPayloadV1 & {
+    integrity: FlowContractIntegrityV1;
+};
+declare const verifiedComposioAvailability: unique symbol;
+type VerifiedComposioActionAvailabilityV1 = Readonly<ComposioActionAvailabilityV1> & {
+    readonly [verifiedComposioAvailability]: true;
+};
+interface ComposioAvailabilitySigner {
+    issuerDid: DID;
+    verificationMethod: string;
+    algorithm: string;
+    sign(data: Uint8Array): Promise<string>;
+}
+interface ComposioAvailabilityTrustPolicy {
+    trustedIssuerDids: readonly DID[];
+    revokedIssuerDids?: readonly DID[];
+    allowedSignatureAlgorithms: readonly string[];
+    verifySignature(input: {
+        issuerDid: DID;
+        verificationMethod: string;
+        algorithm: string;
+        data: Uint8Array;
+        signature: string;
+    }): Promise<boolean>;
+}
+interface ComposioAvailabilityResolver {
+    resolve(actionContractDigest: Sha256Digest): Promise<VerifiedComposioActionAvailabilityV1>;
+}
+interface ExplicitComposioGateway {
+    execute(request: {
+        toolSlug: string;
+        bindingId: string;
+        connectedAccountReference: string;
+        arguments: FlowJsonObject;
+        providerIdempotencyKey: IdempotencyKey;
+        providerInvocationReference: string;
+    }): Promise<ProviderInvocationResult>;
+    readback(request: {
+        toolSlug: string;
+        bindingId: string;
+        connectedAccountReference: string;
+        arguments: FlowJsonObject;
+        providerIdempotencyKey: IdempotencyKey;
+        providerCorrelation?: string;
+        providerInvocationReference: string;
+    }): Promise<ProviderReadbackResult>;
+}
+declare class ComposioContractMismatchError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+declare function computeComposioAvailabilityDigest(payload: ComposioActionAvailabilityPayloadV1): Promise<Sha256Digest>;
+declare function signComposioActionAvailability(payload: ComposioActionAvailabilityPayloadV1, signer: ComposioAvailabilitySigner): Promise<ComposioActionAvailabilityV1>;
+declare function verifyComposioActionAvailability(candidate: ComposioActionAvailabilityV1, policy: ComposioAvailabilityTrustPolicy, now?: Date): Promise<VerifiedComposioActionAvailabilityV1>;
+/**
+ * Executes only the tool slug and account binding declared by the signed
+ * availability contract. No dynamic discovery result can reach execution.
+ */
+declare class ManifestBoundComposioActionAdapter implements ManifestBoundActionAdapter {
+    private readonly availability;
+    private readonly gateway;
+    private readonly now;
+    constructor(availability: ComposioAvailabilityResolver, gateway: ExplicitComposioGateway, now?: () => Date);
+    invoke(request: {
+        contract: ActionContractV1;
+        inputs: FlowJsonObject;
+        providerIdempotencyKey: IdempotencyKey;
+        invocation: VerifiedAttemptAuthorization;
+        assertEffectAllowed: () => void;
+    }): Promise<ProviderInvocationResult>;
+    readback(request: {
+        contract: ActionContractV1;
+        inputs: FlowJsonObject;
+        providerIdempotencyKey: IdempotencyKey;
+        providerCorrelation?: string;
+        invocation: VerifiedAttemptAuthorization;
+    }): Promise<ProviderReadbackResult>;
+}
+
+declare const FLOW_RUN_PROJECTIONS_MAP_KEY = "qi.flow.runProjections";
+interface FlowRunAttemptProjectionV1 {
+    attemptId: AttemptId;
+    stepId: string;
+    disposition: EffectDisposition;
+    outputDigest?: Sha256Digest;
+    providerCorrelation?: string;
+    receiptIds: readonly ReceiptId[];
+    outcomes: readonly ActionOutcomeEvidenceV1[];
+}
+interface FlowRunTimelineEntryV1 {
+    eventId: EventId;
+    kind: FlowEventEnvelopeV1['payload']['kind'];
+    occurredAt: string;
+    actor: DID;
+    producer: DID;
+    parents: readonly EventId[];
+    attemptId?: AttemptId;
+    stepId?: string;
+}
+interface FlowRunProjectionV1 {
+    kind: 'qi.flow.run-projection';
+    schemaVersion: '1.0';
+    runId: RunId;
+    definition: FlowDefinitionRef;
+    sourceEventIds: readonly EventId[];
+    sourceEventSetDigest: Sha256Digest;
+    headEventIds: readonly EventId[];
+    status: ReturnType<typeof reduceFlowEvents>['status'];
+    cancelRequested: boolean;
+    attempts: Readonly<Record<string, FlowRunAttemptProjectionV1>>;
+    timeline: readonly FlowRunTimelineEntryV1[];
+    invalidEvents: readonly {
+        eventId: EventId;
+        reason: string;
+    }[];
+}
+type FlowRunProjectionRepairResult = {
+    outcome: 'unchanged';
+} | {
+    outcome: 'stale';
+    currentSourceEventSetDigest: Sha256Digest;
+} | {
+    outcome: 'repaired';
+    previousSourceEventSetDigest?: Sha256Digest;
+};
+declare function projectFlowRun(genesis: RunGenesisV1, events: readonly VerifiedFlowEventEnvelopeV1[]): Promise<FlowRunProjectionV1>;
+declare function flowRunProjectionStorageKey(runId: RunId, sourceEventSetDigest: Sha256Digest): string;
+/**
+ * Reads a rebuildable projection only when every stored field matches the
+ * projection derived from the caller's verified Matrix event set.
+ */
+declare function readFlowRunProjection(doc: Y.Doc, genesis: RunGenesisV1, events: readonly VerifiedFlowEventEnvelopeV1[]): Promise<FlowRunProjectionV1 | null>;
+declare function repairFlowRunProjection(doc: Y.Doc, genesis: RunGenesisV1, events: readonly VerifiedFlowEventEnvelopeV1[], verifiedEvidence?: readonly VerifiedFlowEventEnvelopeV1[]): Promise<FlowRunProjectionRepairResult>;
+
+export { type FlowId as $, type ActionContractRef as A, type Brand as B, type CancelPeerRunCommandV1 as C, type DID as D, type EffectClaimAdmissionV1 as E, type ExecutionPolicySigner as F, type ExecutionPolicyTrustPolicy as G, type ExecutionPolicyV1 as H, type ExplicitComposioGateway as I, FLOW_CAPABILITIES as J, FLOW_RUN_PROJECTIONS_MAP_KEY as K, type FinalizePeerRunCommandV1 as L, type FlowContractIntegrityV1 as M, type FlowDataClassification as N, type FlowDefinitionRef as O, type FlowDefinitionRevisionPayloadV1 as P, type FlowDefinitionRevisionRepository as Q, type FlowDefinitionRevisionSigner as R, type FlowDefinitionRevisionTrustPolicy as S, type FlowDefinitionRevisionV1 as T, FlowDefinitionVerificationError as U, type FlowEventAppendResult as V, type FlowEventEnvelopeV1 as W, type FlowEventPayloadV1 as X, type FlowEventSigner as Y, type FlowEventTrustPolicy as Z, FlowEventValidationError as _, ActionContractResolutionError as a, claimEffect as a$, type FlowJsonObject as a0, type FlowJsonValue as a1, type FlowRevisionId as a2, type FlowRunAttemptProjectionV1 as a3, type FlowRunProjectionRepairResult as a4, type FlowRunProjectionV1 as a5, type FlowRunTimelineEntryV1 as a6, type FlowStepDefinitionV1 as a7, type FlowStepTtlV1 as a8, type FlowTriggerV1 as a9, type ReducedFlowRunV1 as aA, type RejectedMatrixFlowEventV1 as aB, type RevisionCipher as aC, type RunFinalizationAttemptSummaryV1 as aD, type RunFinalizationSummaryV1 as aE, type RunGenesisV1 as aF, type RunId as aG, type RunTerminalStatusV1 as aH, type RuntimeContractV1 as aI, type Sha256Digest as aJ, type StartPeerRunCommandV1 as aK, type TopicReceiptDelivery as aL, type TopicReceiptOutbox as aM, type TopicReceiptOutboxRecordV1 as aN, type TopicRequestRefV1 as aO, UNIVERSAL_ACTION_COMPLETED_OUTCOME as aP, type UnsignedFlowEventEnvelopeV1 as aQ, type VerifiedActionContractResolver as aR, type VerifiedAttemptAuthorization as aS, type VerifiedComposioActionAvailabilityV1 as aT, type VerifiedExecutionPolicyV1 as aU, type VerifiedFlowDefinitionRevisionV1 as aV, type VerifiedFlowEventEnvelopeV1 as aW, type VerifiedInvocation as aX, armEffectClaim as aY, buildFlowResourceUri as aZ, canonicalizeJson as a_, type HistoricalActionManifestRepository as aa, HistoricalManifestActionContractResolver as ab, type IdempotencyKey as ac, type InvocationAuthorizer as ad, MATRIX_FLOW_DEFINITION_ANCHOR_TYPE as ae, MATRIX_FLOW_EVENT_TYPE as af, type ManifestBoundActionAdapter as ag, ManifestBoundComposioActionAdapter as ah, type MatrixDefinitionAnchorPayloadV1 as ai, type MatrixDefinitionAnchorSigner as aj, type MatrixDefinitionAnchorTrustPolicy as ak, type MatrixDefinitionAnchorV1 as al, type MatrixDefinitionTransport as am, type MatrixFlowEventObservationV1 as an, type MatrixFlowEventStore as ao, MatrixRoomFlowEventStore as ap, type MatrixRunEventCarrierV1 as aq, type MatrixRunEventPageV1 as ar, type MatrixRunEventTransport as as, type PeerAttemptResult as at, PeerExecutionError as au, type PeerExecutor as av, type ProviderInvocationResult as aw, type ProviderReadbackResult as ax, type ReceiptId as ay, type ReducedAttemptV1 as az, type ActionContractResolutionErrorCode as b, computeActionContractDigest as b0, computeComposioAvailabilityDigest as b1, computeExecutionPolicyDigest as b2, computeFlowDefinitionDigest as b3, createPeerExecutor as b4, deepFreezeJson as b5, deriveAttemptId as b6, deriveEffectClaimKey as b7, deriveEventId as b8, deriveReceiptId as b9, type ActionManifestV2Compatibility as bA, type ActionManifestV2Integrity as bB, type ActionManifestV2Issuer as bC, type ActionManifestV2Package as bD, type ActionManifestV2Payload as bE, type ActionManifestV2Primitive as bF, type ActionManifestV2SignatureVerificationInput as bG, type ActionManifestV2Signer as bH, type ActionManifestV2TrustPolicy as bI, ActionManifestV2VerificationError as bJ, type ActionManifestV2VerificationErrorCode as bK, type ManifestV2JsonValue as bL, type SignedActionManifestV2 as bM, type VerifiedActionManifestV2 as bN, canonicalizeManifestV2Payload as bO, computeActionManifestV2Digest as bP, signActionManifestV2 as bQ, verifyActionManifestV2 as bR, deriveRunId as ba, digestCanonicalJson as bb, drainTopicReceiptOutbox as bc, fingerprintFlowCommand as bd, flowRunProjectionStorageKey as be, markEffectNeedsVerification as bf, matrixFlowEventTransactionId as bg, persistSignedTopicReceipt as bh, prepareEffectSuccess as bi, projectFlowRun as bj, readFlowRunProjection as bk, reduceFlowEvents as bl, renewEffectClaim as bm, repairFlowRunProjection as bn, resolveEffectClaim as bo, signComposioActionAvailability as bp, signExecutionPolicy as bq, signFlowDefinitionRevision as br, signFlowEvent as bs, signMatrixDefinitionAnchor as bt, verifyComposioActionAvailability as bu, verifyExecutionPolicy as bv, verifyFlowDefinitionRevision as bw, verifyFlowEvent as bx, verifyMatrixDefinitionAnchor as by, type ActionManifestV2Action as bz, type ActionContractV1 as c, type ActionOutcomeEvidenceV1 as d, type ActionOutcomeInputV1 as e, type ActionSafety as f, type AttemptId as g, type CanonicalJsonValue as h, type ComposioActionAvailabilityPayloadV1 as i, type ComposioActionAvailabilityV1 as j, type ComposioAvailabilityResolver as k, type ComposioAvailabilitySigner as l, type ComposioAvailabilityTrustPolicy as m, ComposioContractMismatchError as n, type CreatePeerExecutorOptions as o, type EffectClaimLedger as p, type EffectClaimRecordV1 as q, type EffectClaimRequestV1 as r, type EffectClaimResultV1 as s, type EffectClaimStatus as t, EffectClaimTransitionError as u, type EffectDisposition as v, EncryptedMatrixFlowDefinitionRevisionRepository as w, type EventId as x, type ExecutePeerAttemptCommandV1 as y, type ExecutionPolicyPayloadV1 as z };