@axtary/ledger 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,16 +1,31 @@
-import { type LedgerExecutionOutcome, type LedgerRecord, type NormalizedAction, type PolicyDecision } from "@axtary/actionpass";
+import { type ActionPassRevocation, type LocalActionPassTrustStore, type BudgetLedgerEvent, type LedgerExecutionOutcome, type DelegationLedgerEdge, type LedgerRecord, type NormalizedAction, type PolicyDecision, type SigningAlgorithm, type SigningKey, type VerificationKey, type VerificationKeyResolver, type VerificationKeySet, type StatusListFetch } from "@axtary/actionpass";
 import { z } from "zod";
+import { merkleConsistencyProof, merkleInclusionProof, merkleLeafHash, merkleNodeHash, merkleTreeRoot, verifyMerkleConsistency, verifyMerkleInclusion } from "./merkle.js";
+export { merkleConsistencyProof, merkleInclusionProof, merkleLeafHash, merkleNodeHash, merkleTreeRoot, verifyMerkleConsistency, verifyMerkleInclusion, };
+export { BEHAVIOR_STORE_VERSION, BehaviorStoreSchema, InMemoryBehaviorStore, FileBehaviorStore, deriveBehaviorSignals, recordBehaviorObservation, type BehaviorStore, type BehaviorStoreData, type BehaviorSignals, type FileBehaviorStoreOptions, } from "./behavior.js";
+export { LEDGER_FORENSICS_VERSION, analyzeForensics, reconstructIncident, type ForensicExecution, type ForensicIncident, type ForensicNode, type ForensicProperty, type ForensicReport, type ForensicTimelineEntry, } from "./forensics.js";
 export declare const LOCAL_LEDGER_SCHEMA_VERSION = "axtary.local-ledger.v0";
+export declare const LOCAL_LEDGER_HEAD_SCHEMA_VERSION = "axtary.local-ledger-head.v0";
 export declare const LEDGER_EXPORT_SCHEMA_VERSION = "axtary.ledger_export.v0";
 export declare const LEDGER_SYNC_SCHEMA_VERSION = "axtary.ledger_sync.v0";
 export declare const LEDGER_SIEM_EVENT_SCHEMA_VERSION = "axtary.siem_event.v0";
+export declare const LEDGER_OTEL_EXPORT_SCHEMA_VERSION = "axtary.otel_trace_export.v0";
 export declare const LedgerAppendResultSchema: z.ZodObject<{
     record: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"axtary.ledger.v0">;
         id: z.ZodString;
         occurredAt: z.ZodString;
+        auditContext: z.ZodOptional<z.ZodObject<{
+            tenant: z.ZodNullable<z.ZodString>;
+            agentId: z.ZodString;
+            humanOwner: z.ZodString;
+            taskId: z.ZodString;
+            tool: z.ZodString;
+            resource: z.ZodString;
+        }, z.core.$strip>>;
         actionHash: z.ZodString;
         payloadHash: z.ZodString;
+        provenanceHash: z.ZodOptional<z.ZodString>;
         decision: z.ZodEnum<{
             allow: "allow";
             deny: "deny";
@@ -30,10 +45,12 @@ export declare const LedgerAppendResultSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>;
             tool: z.ZodString;
             operation: z.ZodString;
@@ -43,10 +60,12 @@ export declare const LedgerAppendResultSchema: z.ZodObject<{
                     slack: "slack";
                     linear: "linear";
                     docs: "docs";
+                    drive: "drive";
                     mcp: "mcp";
                     aws: "aws";
                     gcp: "gcp";
                     jira: "jira";
+                    postgres: "postgres";
                 }>;
                 kind: z.ZodString;
                 id: z.ZodString;
@@ -65,10 +84,12 @@ export declare const LedgerAppendResultSchema: z.ZodObject<{
                     slack: "slack";
                     linear: "linear";
                     docs: "docs";
+                    drive: "drive";
                     mcp: "mcp";
                     aws: "aws";
                     gcp: "gcp";
                     jira: "jira";
+                    postgres: "postgres";
                 }>;
                 summary: z.ZodOptional<z.ZodString>;
                 files: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -109,10 +130,12 @@ export declare const LedgerAppendResultSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>>;
             resultId: z.ZodOptional<z.ZodString>;
             resultUrl: z.ZodOptional<z.ZodString>;
@@ -120,10 +143,34 @@ export declare const LedgerAppendResultSchema: z.ZodObject<{
             resourceLabel: z.ZodOptional<z.ZodString>;
             failureReason: z.ZodOptional<z.ZodString>;
             errorClass: z.ZodOptional<z.ZodString>;
+            approvedPayloadHash: z.ZodOptional<z.ZodString>;
+            executedPayloadHash: z.ZodOptional<z.ZodString>;
             sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("@axtary/actionpass").JsonValue, unknown, z.core.$ZodTypeInternals<import("@axtary/actionpass").JsonValue, unknown>>>>;
         }, z.core.$strict>>;
         traceId: z.ZodOptional<z.ZodString>;
         actionPassId: z.ZodNullable<z.ZodString>;
+        delegation: z.ZodOptional<z.ZodObject<{
+            parentPassId: z.ZodString;
+            childPassId: z.ZodString;
+            depth: z.ZodNumber;
+            rootPassId: z.ZodString;
+        }, z.core.$strip>>;
+        budget: z.ZodOptional<z.ZodObject<{
+            reservationId: z.ZodNullable<z.ZodString>;
+            scope: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                committed: "committed";
+                rolled_back: "rolled_back";
+                denied: "denied";
+            }>;
+            expiresAt: z.ZodNullable<z.ZodString>;
+            cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>>;
         correlationId: z.ZodOptional<z.ZodString>;
         previousLedgerHash: z.ZodNullable<z.ZodString>;
         ledgerHash: z.ZodString;
@@ -135,6 +182,14 @@ export type AppendDecisionInput = {
     action: NormalizedAction;
     decision: PolicyDecision;
     actionPassId?: string | null;
+    delegation?: DelegationLedgerEdge;
+    budget?: BudgetLedgerEvent;
+    occurredAt?: Date;
+};
+export type AppendRevocationInput = {
+    revokedRecord: LedgerRecord;
+    revokedBy?: string;
+    reason?: string;
     occurredAt?: Date;
 };
 export type AppendExecutionOutcomeInput = AppendDecisionInput & {
@@ -183,8 +238,17 @@ export declare const LedgerExportSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"axtary.ledger.v0">;
         id: z.ZodString;
         occurredAt: z.ZodString;
+        auditContext: z.ZodOptional<z.ZodObject<{
+            tenant: z.ZodNullable<z.ZodString>;
+            agentId: z.ZodString;
+            humanOwner: z.ZodString;
+            taskId: z.ZodString;
+            tool: z.ZodString;
+            resource: z.ZodString;
+        }, z.core.$strip>>;
         actionHash: z.ZodString;
         payloadHash: z.ZodString;
+        provenanceHash: z.ZodOptional<z.ZodString>;
         decision: z.ZodEnum<{
             allow: "allow";
             deny: "deny";
@@ -204,10 +268,12 @@ export declare const LedgerExportSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>;
             tool: z.ZodString;
             operation: z.ZodString;
@@ -217,10 +283,12 @@ export declare const LedgerExportSchema: z.ZodObject<{
                     slack: "slack";
                     linear: "linear";
                     docs: "docs";
+                    drive: "drive";
                     mcp: "mcp";
                     aws: "aws";
                     gcp: "gcp";
                     jira: "jira";
+                    postgres: "postgres";
                 }>;
                 kind: z.ZodString;
                 id: z.ZodString;
@@ -239,10 +307,12 @@ export declare const LedgerExportSchema: z.ZodObject<{
                     slack: "slack";
                     linear: "linear";
                     docs: "docs";
+                    drive: "drive";
                     mcp: "mcp";
                     aws: "aws";
                     gcp: "gcp";
                     jira: "jira";
+                    postgres: "postgres";
                 }>;
                 summary: z.ZodOptional<z.ZodString>;
                 files: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -283,10 +353,12 @@ export declare const LedgerExportSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>>;
             resultId: z.ZodOptional<z.ZodString>;
             resultUrl: z.ZodOptional<z.ZodString>;
@@ -294,10 +366,34 @@ export declare const LedgerExportSchema: z.ZodObject<{
             resourceLabel: z.ZodOptional<z.ZodString>;
             failureReason: z.ZodOptional<z.ZodString>;
             errorClass: z.ZodOptional<z.ZodString>;
+            approvedPayloadHash: z.ZodOptional<z.ZodString>;
+            executedPayloadHash: z.ZodOptional<z.ZodString>;
             sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("@axtary/actionpass").JsonValue, unknown, z.core.$ZodTypeInternals<import("@axtary/actionpass").JsonValue, unknown>>>>;
         }, z.core.$strict>>;
         traceId: z.ZodOptional<z.ZodString>;
         actionPassId: z.ZodNullable<z.ZodString>;
+        delegation: z.ZodOptional<z.ZodObject<{
+            parentPassId: z.ZodString;
+            childPassId: z.ZodString;
+            depth: z.ZodNumber;
+            rootPassId: z.ZodString;
+        }, z.core.$strip>>;
+        budget: z.ZodOptional<z.ZodObject<{
+            reservationId: z.ZodNullable<z.ZodString>;
+            scope: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                committed: "committed";
+                rolled_back: "rolled_back";
+                denied: "denied";
+            }>;
+            expiresAt: z.ZodNullable<z.ZodString>;
+            cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>>;
         correlationId: z.ZodOptional<z.ZodString>;
         previousLedgerHash: z.ZodNullable<z.ZodString>;
         ledgerHash: z.ZodString;
@@ -355,10 +451,12 @@ export declare const LedgerSiemEventSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>;
             tool: z.ZodString;
             operation: z.ZodString;
@@ -397,19 +495,583 @@ export type SyncLedgerExportInput = {
     fetch?: typeof fetch;
     timeoutMs?: number;
 };
+export type LedgerTelemetryExporter = {
+    exportRecord(record: LedgerRecord): Promise<void>;
+};
+export type OtlpHttpTraceExporterOptions = {
+    endpoint: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+};
+export type ExportOtelTracesInput = OtlpHttpTraceExporterOptions & {
+    records: LedgerRecord[];
+};
+export type OtelTraceExportResult = {
+    schemaVersion: typeof LEDGER_OTEL_EXPORT_SCHEMA_VERSION;
+    endpoint: string;
+    exportedAt: string;
+    records: number;
+    spans: number;
+    status: number;
+};
+export type LocalJsonlLedgerOptions = {
+    lock?: {
+        staleMs?: number;
+        updateMs?: number;
+        retries?: number;
+        minTimeoutMs?: number;
+        maxTimeoutMs?: number;
+    };
+    telemetry?: LedgerTelemetryExporter;
+};
 export declare class LocalJsonlLedger {
     readonly filePath: string;
-    constructor(filePath: string);
+    readonly headPath: string;
+    private readonly options;
+    constructor(filePath: string, options?: LocalJsonlLedgerOptions);
     appendDecision(input: AppendDecisionInput): Promise<LedgerAppendResult>;
     appendExecutionOutcome(input: AppendExecutionOutcomeInput): Promise<LedgerAppendResult>;
+    appendRevocation(input: AppendRevocationInput): Promise<LedgerAppendResult>;
     appendRecord(recordInput: LedgerRecord): Promise<LedgerAppendResult>;
     readRecords(): Promise<LedgerRecord[]>;
     verify(): Promise<VerifyLedgerResult>;
+    private withAppendLock;
+    private appendLocked;
+    private exportTelemetry;
+}
+export declare class OtlpHttpTraceExporter implements LedgerTelemetryExporter {
+    private readonly options;
+    constructor(options: OtlpHttpTraceExporterOptions);
+    exportRecord(record: LedgerRecord): Promise<void>;
 }
 export declare function readLedgerRecords(filePath: string): Promise<LedgerRecord[]>;
+export type RevokeActionPassResult = {
+    revocation: ActionPassRevocation;
+    ledgerEvent: LedgerAppendResult | null;
+    revokedRecordId: string | null;
+};
+/**
+ * Revoke a pass through the single honest path used by both the CLI and the
+ * dashboard: first write the durable trust-store revocation (the enforcement
+ * authority the proxy/adapters/MCP check), then append a tamper-evident
+ * revocation event to the hash-chained ledger bound to the most recent record
+ * naming that pass. Enforcement is written first so a later audit-append
+ * failure still leaves the pass actually revoked. When no ledger record names
+ * the pass (e.g. it never ran locally), the revocation is still authoritative
+ * and `ledgerEvent` is null — never faked.
+ */
+export declare function revokeActionPassWithLedgerEvent(input: {
+    trustStore: LocalActionPassTrustStore;
+    ledger: LocalJsonlLedger;
+    passId: string;
+    revokedBy?: string;
+    reason?: string;
+    occurredAt?: Date;
+}): Promise<RevokeActionPassResult>;
 export declare function verifyLedgerFile(filePath: string): Promise<VerifyLedgerResult>;
 export declare function exportLedgerRecords(input: ExportLedgerRecordsInput): Promise<LedgerExport>;
+export declare function exportLedgerRecordsToOtlp(input: ExportOtelTracesInput): Promise<OtelTraceExportResult>;
 export declare function syncLedgerExport(input: SyncLedgerExportInput): Promise<LedgerSyncResult>;
 export declare function formatLedgerExport(input: FormatLedgerExportInput): string;
 export declare function computeLedgerHash(record: Omit<LedgerRecord, "ledgerHash">): string;
+export declare const LEDGER_ATTESTATION_VERSION = "axtary.ledger_attestation.v0";
+export declare const LedgerAttestationClaimsSchema: z.ZodObject<{
+    lav: z.ZodLiteral<"axtary.ledger_attestation.v0">;
+    iss: z.ZodString;
+    iat: z.ZodNumber;
+    tenant: z.ZodOptional<z.ZodString>;
+    exportDigest: z.ZodString;
+    recordCount: z.ZodNumber;
+    firstLedgerHash: z.ZodNullable<z.ZodString>;
+    segmentHead: z.ZodNullable<z.ZodString>;
+    sourceLastLedgerHash: z.ZodNullable<z.ZodString>;
+    range: z.ZodObject<{
+        from: z.ZodNullable<z.ZodString>;
+        to: z.ZodNullable<z.ZodString>;
+        decisions: z.ZodNullable<z.ZodArray<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            step_up: "step_up";
+        }>>>;
+    }, z.core.$strip>;
+    merkleRoot: z.ZodOptional<z.ZodString>;
+    treeSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type LedgerAttestationClaims = z.infer<typeof LedgerAttestationClaimsSchema>;
+export type LedgerAttestation = {
+    schemaVersion: typeof LEDGER_ATTESTATION_VERSION;
+    token: string;
+    claims: LedgerAttestationClaims;
+};
+export type AttestLedgerExportInput = {
+    export: LedgerExport;
+    issuer: string;
+    signingKey: SigningKey;
+    keyId?: string;
+    algorithm?: SigningAlgorithm;
+    tenant?: string;
+    now?: Date;
+};
+export type VerifyLedgerAttestationInput = {
+    export: LedgerExport;
+    attestation: string | LedgerAttestation;
+    verificationKey?: VerificationKey;
+    verificationKeys?: VerificationKeySet | VerificationKeyResolver;
+    issuer?: string;
+    algorithms?: SigningAlgorithm[];
+    currentDate?: Date;
+};
+export type VerifyLedgerAttestationResult = {
+    valid: true;
+    claims: LedgerAttestationClaims;
+    recomputedDigest: string;
+} | {
+    valid: false;
+    reason: string;
+};
+/** SHA-256 digest of the canonical (JCS) ledger export — the content binding. */
+export declare function computeLedgerExportDigest(exportInput: LedgerExport): string;
+/**
+ * RFC 6962 leaves for an export: one leaf per record, committing to that
+ * record's `ledgerHash`. Because a verifier recomputes each `ledgerHash` from
+ * record content (spec §9.1), binding leaves to `ledgerHash` transitively binds
+ * the full record content — a one-byte rewrite changes the leaf and the root.
+ */
+export declare function ledgerExportLeafHashes(exportInput: LedgerExport): Buffer[];
+/** Merkle Tree Hash (RFC 6962) over the export's record leaves, as `sha256:hex`. */
+export declare function computeLedgerExportMerkleRoot(exportInput: LedgerExport): string;
+export declare function attestLedgerExport(input: AttestLedgerExportInput): Promise<LedgerAttestation>;
+/**
+ * Standalone verifier: confirm a ledger export carries a valid issuer signature
+ * and has not been altered. Needs only the export, the attestation token, and
+ * the issuer public key — re-derivable from the spec alone.
+ */
+export declare function verifyLedgerAttestation(input: VerifyLedgerAttestationInput): Promise<VerifyLedgerAttestationResult>;
+type OtlpAnyValue = {
+    stringValue: string;
+} | {
+    boolValue: boolean;
+} | {
+    intValue: string;
+} | {
+    arrayValue: {
+        values: OtlpAnyValue[];
+    };
+};
+type OtlpAttribute = {
+    key: string;
+    value: OtlpAnyValue;
+};
+type BuildOtlpTraceRequestInput = {
+    records: LedgerRecord[];
+    serviceName?: string;
+    serviceVersion?: string;
+};
+export declare function buildOtlpTraceRequest(input: BuildOtlpTraceRequestInput): {
+    resourceSpans: {
+        resource: {
+            attributes: OtlpAttribute[];
+        };
+        scopeSpans: {
+            scope: {
+                name: string;
+                version: string;
+            };
+            spans: {
+                status?: {
+                    code: string;
+                    message: string;
+                } | {
+                    code: string;
+                    message?: undefined;
+                } | undefined;
+                traceId: string;
+                spanId: string;
+                name: string;
+                kind: string;
+                startTimeUnixNano: string;
+                endTimeUnixNano: string;
+                attributes: OtlpAttribute[];
+            }[];
+        }[];
+    }[];
+};
+/**
+ * Re-verify the exported records from the records alone: every record's own hash
+ * must recompute, and — for a full (unfiltered) export — `previousLedgerHash` must
+ * chain. Filtered exports are not contiguous, so only the per-record hash is
+ * asserted; reorder/truncation is still caught by the signed export digest.
+ */
+export declare const LEDGER_EQUIVALENCE_REPORT_VERSION = "axtary.ledger_equivalence_report.v0";
+export type LedgerEquivalenceEntry = {
+    /** 1-based position among the evaluated records. */
+    line: number;
+    recordId: string;
+    occurredAt: string;
+    tool: string | null;
+    decision: LedgerRecord["decision"];
+    approvedPayloadHash: string | null;
+    executedPayloadHash: string | null;
+    /** The hash-chained record's own payload hash — the executed truth. */
+    recordPayloadHash: string;
+    status: "proved" | "failed" | "unproven";
+    failure: "equivalence_pair_incomplete" | "equivalence_executed_hash_mismatch" | "approval_execution_equivalence_failed" | null;
+};
+export type LedgerEquivalenceReport = {
+    schemaVersion: typeof LEDGER_EQUIVALENCE_REPORT_VERSION;
+    executions: number;
+    proved: number;
+    failed: number;
+    unproven: number;
+    entries: LedgerEquivalenceEntry[];
+};
+/**
+ * The approval↔execution equivalence proof over execution-outcome records.
+ *
+ * `proved` means the record carries both hashes, the executed hash agrees
+ * with the record's own hash-chained `payloadHash`, and approved == executed.
+ * `unproven` means the execution carries no pair (no approval evidence, or a
+ * record written before the pair existed) — truthfully absent, never
+ * fake-proved. Any inconsistency is `failed`: an incomplete pair, an executed
+ * hash that disagrees with the record itself (a forged outcome block), or
+ * approved != executed (an execution that escaped enforcement).
+ */
+export declare function evaluateLedgerEquivalence(records: LedgerRecord[]): LedgerEquivalenceReport;
+export declare const LEDGER_ATTESTATION_BUNDLE_VERSION = "axtary.ledger_attestation_bundle.v0";
+export declare const LedgerAttestationBundleSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.ledger_attestation_bundle.v0">;
+    export: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"axtary.ledger_export.v0">;
+        exportedAt: z.ZodString;
+        source: z.ZodObject<{
+            filePath: z.ZodString;
+            totalRecords: z.ZodNumber;
+            lastLedgerHash: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        filters: z.ZodObject<{
+            from: z.ZodNullable<z.ZodString>;
+            to: z.ZodNullable<z.ZodString>;
+            decisions: z.ZodNullable<z.ZodArray<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                step_up: "step_up";
+            }>>>;
+        }, z.core.$strip>;
+        records: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"axtary.ledger.v0">;
+            id: z.ZodString;
+            occurredAt: z.ZodString;
+            auditContext: z.ZodOptional<z.ZodObject<{
+                tenant: z.ZodNullable<z.ZodString>;
+                agentId: z.ZodString;
+                humanOwner: z.ZodString;
+                taskId: z.ZodString;
+                tool: z.ZodString;
+                resource: z.ZodString;
+            }, z.core.$strip>>;
+            actionHash: z.ZodString;
+            payloadHash: z.ZodString;
+            provenanceHash: z.ZodOptional<z.ZodString>;
+            decision: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                step_up: "step_up";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            policy: z.ZodObject<{
+                nativeRule: z.ZodString;
+                version: z.ZodString;
+                cedarCompatible: z.ZodBoolean;
+                opaCompatible: z.ZodBoolean;
+            }, z.core.$strip>;
+            providerEvidence: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"axtary.ledger_provider_evidence.v0">;
+                provider: z.ZodEnum<{
+                    github: "github";
+                    slack: "slack";
+                    linear: "linear";
+                    docs: "docs";
+                    drive: "drive";
+                    mcp: "mcp";
+                    aws: "aws";
+                    gcp: "gcp";
+                    jira: "jira";
+                    postgres: "postgres";
+                }>;
+                tool: z.ZodString;
+                operation: z.ZodString;
+                resource: z.ZodObject<{
+                    provider: z.ZodEnum<{
+                        github: "github";
+                        slack: "slack";
+                        linear: "linear";
+                        docs: "docs";
+                        drive: "drive";
+                        mcp: "mcp";
+                        aws: "aws";
+                        gcp: "gcp";
+                        jira: "jira";
+                        postgres: "postgres";
+                    }>;
+                    kind: z.ZodString;
+                    id: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                normalized: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("@axtary/actionpass").JsonValue, unknown, z.core.$ZodTypeInternals<import("@axtary/actionpass").JsonValue, unknown>>>>;
+                fieldChanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    before: z.ZodOptional<z.ZodType<import("@axtary/actionpass").JsonValue, unknown, z.core.$ZodTypeInternals<import("@axtary/actionpass").JsonValue, unknown>>>;
+                    after: z.ZodOptional<z.ZodType<import("@axtary/actionpass").JsonValue, unknown, z.core.$ZodTypeInternals<import("@axtary/actionpass").JsonValue, unknown>>>;
+                }, z.core.$strip>>>;
+                diff: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodEnum<{
+                        github: "github";
+                        slack: "slack";
+                        linear: "linear";
+                        docs: "docs";
+                        drive: "drive";
+                        mcp: "mcp";
+                        aws: "aws";
+                        gcp: "gcp";
+                        jira: "jira";
+                        postgres: "postgres";
+                    }>;
+                    summary: z.ZodOptional<z.ZodString>;
+                    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        path: z.ZodString;
+                        oldPath: z.ZodOptional<z.ZodString>;
+                        status: z.ZodEnum<{
+                            added: "added";
+                            modified: "modified";
+                            deleted: "deleted";
+                            renamed: "renamed";
+                        }>;
+                        additions: z.ZodDefault<z.ZodNumber>;
+                        deletions: z.ZodDefault<z.ZodNumber>;
+                        hunks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            header: z.ZodString;
+                            lines: z.ZodArray<z.ZodObject<{
+                                type: z.ZodEnum<{
+                                    context: "context";
+                                    addition: "addition";
+                                    deletion: "deletion";
+                                }>;
+                                content: z.ZodString;
+                                oldLine: z.ZodOptional<z.ZodNumber>;
+                                newLine: z.ZodOptional<z.ZodNumber>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            executionOutcome: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"axtary.ledger_execution_outcome.v0">;
+                status: z.ZodEnum<{
+                    succeeded: "succeeded";
+                    failed: "failed";
+                }>;
+                provider: z.ZodOptional<z.ZodEnum<{
+                    github: "github";
+                    slack: "slack";
+                    linear: "linear";
+                    docs: "docs";
+                    drive: "drive";
+                    mcp: "mcp";
+                    aws: "aws";
+                    gcp: "gcp";
+                    jira: "jira";
+                    postgres: "postgres";
+                }>>;
+                resultId: z.ZodOptional<z.ZodString>;
+                resultUrl: z.ZodOptional<z.ZodString>;
+                resourceId: z.ZodOptional<z.ZodString>;
+                resourceLabel: z.ZodOptional<z.ZodString>;
+                failureReason: z.ZodOptional<z.ZodString>;
+                errorClass: z.ZodOptional<z.ZodString>;
+                approvedPayloadHash: z.ZodOptional<z.ZodString>;
+                executedPayloadHash: z.ZodOptional<z.ZodString>;
+                sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("@axtary/actionpass").JsonValue, unknown, z.core.$ZodTypeInternals<import("@axtary/actionpass").JsonValue, unknown>>>>;
+            }, z.core.$strict>>;
+            traceId: z.ZodOptional<z.ZodString>;
+            actionPassId: z.ZodNullable<z.ZodString>;
+            delegation: z.ZodOptional<z.ZodObject<{
+                parentPassId: z.ZodString;
+                childPassId: z.ZodString;
+                depth: z.ZodNumber;
+                rootPassId: z.ZodString;
+            }, z.core.$strip>>;
+            budget: z.ZodOptional<z.ZodObject<{
+                reservationId: z.ZodNullable<z.ZodString>;
+                scope: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    committed: "committed";
+                    rolled_back: "rolled_back";
+                    denied: "denied";
+                }>;
+                expiresAt: z.ZodNullable<z.ZodString>;
+                cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            }, z.core.$strip>>;
+            correlationId: z.ZodOptional<z.ZodString>;
+            previousLedgerHash: z.ZodNullable<z.ZodString>;
+            ledgerHash: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    attestation: z.ZodObject<{
+        token: z.ZodString;
+        claims: z.ZodObject<{
+            lav: z.ZodLiteral<"axtary.ledger_attestation.v0">;
+            iss: z.ZodString;
+            iat: z.ZodNumber;
+            tenant: z.ZodOptional<z.ZodString>;
+            exportDigest: z.ZodString;
+            recordCount: z.ZodNumber;
+            firstLedgerHash: z.ZodNullable<z.ZodString>;
+            segmentHead: z.ZodNullable<z.ZodString>;
+            sourceLastLedgerHash: z.ZodNullable<z.ZodString>;
+            range: z.ZodObject<{
+                from: z.ZodNullable<z.ZodString>;
+                to: z.ZodNullable<z.ZodString>;
+                decisions: z.ZodNullable<z.ZodArray<z.ZodEnum<{
+                    allow: "allow";
+                    deny: "deny";
+                    step_up: "step_up";
+                }>>>;
+            }, z.core.$strip>;
+            merkleRoot: z.ZodOptional<z.ZodString>;
+            treeSize: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    publicJwk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    keyId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type LedgerAttestationBundle = z.infer<typeof LedgerAttestationBundleSchema>;
+/** Bundle an export, its attestation, and the public key into one artifact. */
+export declare function buildLedgerAttestationBundle(input: {
+    export: LedgerExport;
+    attestation: LedgerAttestation;
+    publicJwk: Record<string, unknown>;
+    keyId?: string | null;
+}): LedgerAttestationBundle;
+/** Verify a self-contained attestation bundle (export + token + embedded public key). */
+export declare function verifyLedgerAttestationBundle(bundleInput: unknown, options?: {
+    issuer?: string;
+    algorithms?: SigningAlgorithm[];
+    currentDate?: Date;
+}): Promise<VerifyLedgerAttestationResult>;
+export declare const LEDGER_INCLUSION_PROOF_VERSION = "axtary.ledger_inclusion_proof.v0";
+export declare const LedgerInclusionProofSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.ledger_inclusion_proof.v0">;
+    recordId: z.ZodString;
+    ledgerHash: z.ZodString;
+    leafIndex: z.ZodNumber;
+    treeSize: z.ZodNumber;
+    merkleRoot: z.ZodString;
+    auditPath: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LedgerInclusionProof = z.infer<typeof LedgerInclusionProofSchema>;
+export declare const LEDGER_CONSISTENCY_PROOF_VERSION = "axtary.ledger_consistency_proof.v0";
+export declare const LedgerConsistencyProofSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.ledger_consistency_proof.v0">;
+    firstSize: z.ZodNumber;
+    secondSize: z.ZodNumber;
+    firstRoot: z.ZodString;
+    secondRoot: z.ZodString;
+    proof: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LedgerConsistencyProof = z.infer<typeof LedgerConsistencyProofSchema>;
+export type ProofVerificationResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+};
+/** Build an inclusion proof for one record (by id or 0-based index). */
+export declare function proveLedgerInclusion(input: {
+    export: LedgerExport;
+    recordId?: string;
+    index?: number;
+}): LedgerInclusionProof;
+/**
+ * Verify an inclusion proof against a Merkle root. Pass `expectedRoot` (e.g. a
+ * signed attestation's `merkleRoot`) to bind the proof to a signed tree head.
+ * Pass `record` to additionally recompute the leaf from record content so a
+ * proof cannot smuggle a `ledgerHash` that does not match the record.
+ */
+export declare function verifyLedgerInclusionProof(input: {
+    proof: unknown;
+    expectedRoot?: string;
+    record?: LedgerRecord;
+}): ProofVerificationResult;
+/**
+ * Build a consistency proof showing the `second` export append-only-extends the
+ * `first`. Roots are computed from each export independently; if `first` is not
+ * a genuine prefix, verification fails (the honest, fail-closed outcome).
+ */
+export declare function proveLedgerConsistency(input: {
+    first: LedgerExport;
+    second: LedgerExport;
+}): LedgerConsistencyProof;
+/**
+ * Verify a consistency proof. Pass `firstExpectedRoot`/`secondExpectedRoot`
+ * (the two signed heads' `merkleRoot`s) to bind the proof to signed tree heads.
+ */
+export declare function verifyLedgerConsistencyProof(input: {
+    proof: unknown;
+    firstExpectedRoot?: string;
+    secondExpectedRoot?: string;
+}): ProofVerificationResult;
+export declare const CROSS_ISSUER_TRUST_ROOT_VERSION = "axtary.cross_issuer_trust_root.v0";
+export declare const CROSS_ISSUER_VERIFICATION_REPORT_VERSION = "axtary.cross_issuer_verification_report.v0";
+export declare const CrossIssuerTrustRootSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.cross_issuer_trust_root.v0">;
+    issuer: z.ZodString;
+    jwks: z.ZodObject<{
+        keys: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    statusListUri: z.ZodString;
+    federationProfile: z.ZodOptional<z.ZodObject<{
+        profile: z.ZodLiteral<"axtary.openid-federation-anchor.v0">;
+        entityStatementTyp: z.ZodLiteral<"entity-statement+jwt">;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CrossIssuerTrustRoot = z.infer<typeof CrossIssuerTrustRootSchema>;
+export type VerifyCrossIssuerInput = {
+    trustRoot: unknown;
+    action: unknown;
+    actionPassToken: string;
+    ledgerAttestationBundle: unknown;
+    inclusionProof: unknown;
+    statusFetch: StatusListFetch;
+    currentDate?: Date;
+};
+export type CrossIssuerVerificationReport = {
+    schemaVersion: typeof CROSS_ISSUER_VERIFICATION_REPORT_VERSION;
+    issuer: string;
+    passId: string;
+    recordId: string;
+    payloadHash: string;
+    actionHash: string;
+    ledgerHash: string;
+    merkleRoot: string;
+    statusListUri: string;
+    verifiedAt: string;
+};
+export type VerifyCrossIssuerResult = {
+    valid: true;
+    report: CrossIssuerVerificationReport;
+} | {
+    valid: false;
+    reason: string;
+};
+export declare function verifyCrossIssuerActionPass(input: VerifyCrossIssuerInput): Promise<VerifyCrossIssuerResult>;
 //# sourceMappingURL=index.d.ts.map