@hasna/infinity 0.1.0

package/dist/types/authority/effect-journal.d.ts

@@ -0,0 +1,205 @@
+import { type Int64 } from "../core/int64";
+import { type AuthenticatedFenceContext, type BrokerFence, type BrokerFenceInput } from "../contracts/fence";
+export declare const OPERATION_STEP_SCHEMA_VERSION: "infinity.operation-step/v1";
+export declare const EFFECT_JOURNAL_RECORD_SCHEMA_VERSION: "infinity.effect-journal-record/v1";
+export declare const EFFECT_JOURNAL_OUTCOME_SCHEMA_VERSION: "infinity.effect-journal-outcome/v1";
+export declare const EFFECT_JOURNAL_ANCHOR_SCHEMA_VERSION: "infinity.effect-journal-anchor/v1";
+export declare const EFFECT_JOURNAL_RANGE_SCHEMA_VERSION: "infinity.effect-journal-range/v1";
+export declare const EFFECT_JOURNAL_HEAD_SCHEMA_VERSION: "infinity.effect-journal-head/v1";
+export declare const EFFECT_JOURNAL_PROTECTION_SCHEMA_VERSION: "infinity.effect-journal-protection/v1";
+export declare const EFFECT_JOURNAL_OUTCOME_KINDS: readonly ["succeeded", "failed_effect", "failed_no_effect", "reconciliation_blocked"];
+export type EffectJournalOutcomeKind = typeof EFFECT_JOURNAL_OUTCOME_KINDS[number];
+export type EffectJournalRecordKind = "DISPATCHED" | "OUTCOME";
+export declare const EFFECT_JOURNAL_OUTCOME_SCHEMA: {
+    schema_version: "infinity.effect-journal-outcome/v1";
+    record_kind: string;
+    outcome_kinds: ("succeeded" | "failed_effect" | "failed_no_effect" | "reconciliation_blocked")[];
+    ambiguity_outcome: string;
+    unknown_representation: string;
+};
+export declare const EFFECT_JOURNAL_OUTCOME_SCHEMA_DIGEST: string;
+export interface OperationStepInput {
+    schema_version: typeof OPERATION_STEP_SCHEMA_VERSION;
+    operation_id: string;
+    operation_step_id: string;
+    step_ordinal: number;
+    operation_digest: string;
+    request_digest: string;
+    target_digest: string;
+    resource_id: string;
+    resource_lifecycle_generation: Int64;
+    predecessor_receipt_digest: string | null;
+    provider_idempotency_token: string;
+}
+export type OperationStep = Readonly<OperationStepInput>;
+export interface EffectJournalRecordInput {
+    schema_version: typeof EFFECT_JOURNAL_RECORD_SCHEMA_VERSION;
+    operation_id: string;
+    operation_step_id: string;
+    operation_execution_epoch: Int64;
+    record_kind: EffectJournalRecordKind;
+    outcome_kind: EffectJournalOutcomeKind | null;
+    outcome_schema_version: typeof EFFECT_JOURNAL_OUTCOME_SCHEMA_VERSION;
+    outcome_schema_digest: string;
+    operation_digest: string;
+    operation_step_digest: string;
+    request_digest: string;
+    target_digest: string;
+    resource_id: string;
+    resource_lifecycle_generation: Int64;
+    predecessor_receipt_digest: string | null;
+    provider_idempotency_token: string;
+    fence: BrokerFenceInput;
+    outcome_receipt_digest: string | null;
+}
+export interface EffectJournalRecord extends Omit<EffectJournalRecordInput, "fence"> {
+    fence: BrokerFence;
+}
+export interface StoredEffectJournalRecord {
+    anchor_schema_version: typeof EFFECT_JOURNAL_ANCHOR_SCHEMA_VERSION;
+    journal_sequence: Int64;
+    prior_frontier_digest: string | null;
+    record_digest: string;
+    frontier_digest: string;
+    signer_principal: string;
+    signing_key_id: string;
+    signature: string;
+    operation_step: OperationStep;
+    record: Readonly<EffectJournalRecord>;
+}
+export interface EffectJournalProtection {
+    protection_schema_version: typeof EFFECT_JOURNAL_PROTECTION_SCHEMA_VERSION;
+    restore_domain_id: string;
+    encrypted_at_rest: boolean;
+}
+export interface EffectJournalHeadReceipt {
+    head_schema_version: typeof EFFECT_JOURNAL_HEAD_SCHEMA_VERSION;
+    challenge: string;
+    journal_sequence: Int64;
+    frontier_digest: string | null;
+    restore_domain_id: string;
+    encrypted_at_rest: true;
+    observed_at: string;
+    signer_principal: string;
+    signing_key_id: string;
+    signature: string;
+}
+export interface EffectJournalRange {
+    range_schema_version: typeof EFFECT_JOURNAL_RANGE_SCHEMA_VERSION;
+    from_sequence: Int64;
+    through_sequence: Int64;
+    prior_frontier_digest: string | null;
+    anchors: Readonly<StoredEffectJournalRecord>[];
+    head: Readonly<EffectJournalHeadReceipt>;
+    signer_principal: string;
+    signing_key_id: string;
+    signature: string;
+}
+export interface EffectJournalPort {
+    describe(): Readonly<EffectJournalProtection> | Promise<Readonly<EffectJournalProtection>>;
+    readRange(fromSequence: Int64, limit: number, challenge: string): Readonly<EffectJournalRange> | Promise<Readonly<EffectJournalRange>>;
+    head(challenge: string): Readonly<EffectJournalHeadReceipt> | Promise<Readonly<EffectJournalHeadReceipt>>;
+}
+export interface SynchronousEffectJournalPort extends EffectJournalPort {
+    describe(): Readonly<EffectJournalProtection>;
+    readRange(fromSequence: Int64, limit: number, challenge: string): Readonly<EffectJournalRange>;
+    head(challenge: string): Readonly<EffectJournalHeadReceipt>;
+}
+export interface EffectJournalReceiptVerifier {
+    verifyStoredAnchor(value: unknown): Readonly<StoredEffectJournalRecord>;
+    verifyHead(value: unknown): Readonly<EffectJournalHeadReceipt>;
+    verifyRange(value: unknown): Readonly<EffectJournalRange>;
+}
+export interface EffectJournalSigner {
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    sign(canonicalPayload: string): string;
+    verify(canonicalPayload: string, signature: string): boolean;
+}
+export declare class Ed25519EffectJournalSigner implements EffectJournalSigner {
+    private readonly privateKey;
+    private readonly publicKey;
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    private constructor();
+    static generate(signerPrincipal: string, signingKeyId: string): Ed25519EffectJournalSigner;
+    publicKeySpki(): string;
+    sign(canonicalPayload: string): string;
+    verify(canonicalPayload: string, signature: string): boolean;
+}
+export declare class Ed25519EffectJournalVerifier {
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    private readonly publicKey;
+    private constructor();
+    static fromSpki(signerPrincipal: string, signingKeyId: string, publicKeySpki: string): Ed25519EffectJournalVerifier;
+    verifyStoredAnchor(value: unknown): Readonly<StoredEffectJournalRecord>;
+    verifyHead(value: unknown): Readonly<EffectJournalHeadReceipt>;
+    verifyRange(value: unknown): Readonly<EffectJournalRange>;
+}
+export interface EffectJournalAppendAuthorization {
+    readonly currentFence: BrokerFenceInput;
+    readonly authenticated: AuthenticatedFenceContext;
+    readonly verifiedOutcomeReceiptDigest: string | null;
+}
+export interface EffectJournalAppendAuthorizer {
+    /**
+     * Trusted boundary hook. Implementations authenticate transport identity,
+     * read the current fence independently, and verify typed outcome evidence.
+     */
+    authorize(record: Readonly<EffectJournalRecord>): EffectJournalAppendAuthorization;
+}
+export declare const RECONCILIATION_BLOCKED_MAPPING_FIXTURE: {
+    readonly mapping_schema_version: "infinity.effect-outcome-mapping/v1";
+    readonly source_outcome_schema_version: "infinity.effect-journal-outcome/v1";
+    readonly source_outcome_schema_digest: string;
+    readonly external_outcome_kind: "reconciliation_blocked";
+    readonly infinity_operation_state: "quarantined";
+    readonly infinity_resource_state: "quarantined";
+};
+export declare function parseOperationStep(value: unknown): OperationStep;
+export declare function operationStepDigest(step: OperationStep): string;
+export declare function auditEffectJournalTransitions(stepsInput: readonly OperationStep[], anchorsInput: readonly Readonly<StoredEffectJournalRecord>[]): void;
+export declare function parseEffectJournalRecord(value: unknown): Readonly<EffectJournalRecord>;
+export declare class InMemoryEffectJournal implements SynchronousEffectJournalPort, EffectJournalReceiptVerifier {
+    private readonly signer;
+    private readonly authorizer;
+    private readonly steps;
+    private readonly stepOwners;
+    private readonly stepOrdinals;
+    private readonly records;
+    private readonly recordsBySequence;
+    private readonly latestExecutionEpoch;
+    private journalFrontier;
+    private journalFrontierDigest;
+    private available;
+    private readonly protection;
+    constructor(signer: EffectJournalSigner, authorizer: EffectJournalAppendAuthorizer, protection: {
+        restore_domain_id: string;
+        encrypted_at_rest: boolean;
+    });
+    setAvailable(available: boolean): void;
+    describe(): Readonly<EffectJournalProtection>;
+    registerStep(value: unknown): OperationStep;
+    append(value: unknown): Readonly<StoredEffectJournalRecord>;
+    frontier(): Int64;
+    frontierDigest(): string | null;
+    verifyAnchor(value: unknown): Readonly<StoredEffectJournalRecord>;
+    verifyStoredAnchor(value: unknown): Readonly<StoredEffectJournalRecord>;
+    verifyHead(value: unknown): Readonly<EffectJournalHeadReceipt>;
+    verifyRange(value: unknown): Readonly<EffectJournalRange>;
+    readRange(fromSequenceInput: Int64, limitInput: number, challengeInput: string): Readonly<EffectJournalRange>;
+    head(challengeInput: string): Readonly<EffectJournalHeadReceipt>;
+    verifyContiguousFrontier(): void;
+    mapAuthenticatedReconciliationBlocked(value: unknown, currentFence: BrokerFence, authenticated: AuthenticatedFenceContext): typeof RECONCILIATION_BLOCKED_MAPPING_FIXTURE;
+    execution(operationId: string, operationStepId: string, executionEpoch: Int64): {
+        state: "unresolved" | "resolved";
+        dispatched: Readonly<StoredEffectJournalRecord>;
+        outcome: Readonly<StoredEffectJournalRecord> | null;
+    };
+    private assertAppendAuthorized;
+    private verifyStoredMembership;
+    private assertDispatchEpoch;
+    private requireAvailable;
+}
+export declare function assertEffectJournalSeparated(authorityRestoreDomainIdInput: string, protectionInput: EffectJournalProtection): Readonly<EffectJournalProtection>;

package/dist/types/authority/mutation-journal.d.ts

@@ -0,0 +1,163 @@
+import { type Int64 } from "../core/int64";
+import { type JsonValue } from "../core/strict-json";
+export declare const AUTHORITY_MUTATION_ENVELOPE_SCHEMA_VERSION: "infinity.authority-mutation-reconstruction/v1";
+export declare const AUTHORITY_MUTATION_ANCHOR_SCHEMA_VERSION: "infinity.authority-mutation-journal-anchor/v1";
+export declare const AUTHORITY_MUTATION_ACK_SCHEMA_VERSION: "infinity.authority-mutation-journal-ack/v1";
+export declare const AUTHORITY_MUTATION_RANGE_SCHEMA_VERSION: "infinity.authority-mutation-journal-range/v1";
+export declare const AUTHORITY_MUTATION_PROTECTION_SCHEMA_VERSION: "infinity.authority-mutation-journal-protection/v1";
+export type AuthorityMutationKind = "INSERT" | "UPDATE" | "DELETE";
+export interface AuthorityMutationChange {
+    change_ordinal: number;
+    table_name: string;
+    mutation_kind: AuthorityMutationKind;
+    row_digest: string;
+    row: Readonly<Record<string, JsonValue>>;
+}
+export interface AuthorityMutationEnvelope {
+    schema_version: typeof AUTHORITY_MUTATION_ENVELOPE_SCHEMA_VERSION;
+    storage_schema_version: string;
+    authority_epoch: Int64;
+    commit_sequence: Int64;
+    operation_id: string;
+    operation_digest: string;
+    command: string;
+    actor_principal: string;
+    database_time: string;
+    changes: AuthorityMutationChange[];
+}
+export interface StoredAuthorityMutationAnchor {
+    anchor_schema_version: typeof AUTHORITY_MUTATION_ANCHOR_SCHEMA_VERSION;
+    journal_sequence: Int64;
+    prior_frontier_digest: string | null;
+    record_digest: string;
+    frontier_digest: string;
+    signer_principal: string;
+    signing_key_id: string;
+    signature: string;
+    record: Readonly<AuthorityMutationEnvelope>;
+}
+export interface AuthorityMutationJournalAcknowledgement {
+    ack_schema_version: typeof AUTHORITY_MUTATION_ACK_SCHEMA_VERSION;
+    acknowledged_through: Int64;
+    frontier_digest: string;
+    journal_id: string;
+    protection_digest: string;
+    restore_domain_id: string;
+    encrypted_at_rest: true;
+    signer_principal: string;
+    signing_key_id: string;
+    signature: string;
+}
+export interface AuthorityMutationAppendReceipt {
+    anchor: Readonly<StoredAuthorityMutationAnchor>;
+    ack: Readonly<AuthorityMutationJournalAcknowledgement>;
+}
+export interface AuthorityMutationJournalProtection {
+    protection_schema_version: typeof AUTHORITY_MUTATION_PROTECTION_SCHEMA_VERSION;
+    journal_id: string;
+    restore_domain_id: string;
+    encrypted_at_rest: boolean;
+    durability: "durable" | "transient";
+    signer_principal: string;
+    signing_key_id: string;
+    protection_digest: string;
+}
+export interface AuthorityMutationJournalRange {
+    range_schema_version: typeof AUTHORITY_MUTATION_RANGE_SCHEMA_VERSION;
+    from_sequence: Int64;
+    through_sequence: Int64;
+    prior_frontier_digest: string | null;
+    receipts: Readonly<AuthorityMutationAppendReceipt>[];
+    head: Readonly<AuthorityMutationJournalAcknowledgement> | null;
+    journal_id: string;
+    protection_digest: string;
+    signer_principal: string;
+    signing_key_id: string;
+    signature: string;
+}
+export interface AuthorityMutationJournalPort {
+    describe(): AuthorityMutationJournalProtection | Promise<AuthorityMutationJournalProtection>;
+    append(envelope: unknown): Readonly<AuthorityMutationAppendReceipt> | Promise<Readonly<AuthorityMutationAppendReceipt>>;
+    readRange(fromSequence: Int64, limit: number): Readonly<AuthorityMutationJournalRange> | Promise<Readonly<AuthorityMutationJournalRange>>;
+    head(): Readonly<AuthorityMutationJournalAcknowledgement> | null | Promise<Readonly<AuthorityMutationJournalAcknowledgement> | null>;
+}
+export interface SynchronousAuthorityMutationJournalPort extends AuthorityMutationJournalPort {
+    describe(): AuthorityMutationJournalProtection;
+    append(envelope: unknown): Readonly<AuthorityMutationAppendReceipt>;
+    readRange(fromSequence: Int64, limit: number): Readonly<AuthorityMutationJournalRange>;
+    head(): Readonly<AuthorityMutationJournalAcknowledgement> | null;
+}
+export interface AuthorityMutationJournalSigner {
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    sign(canonicalPayload: string): string;
+    verify(canonicalPayload: string, signature: string): boolean;
+}
+export interface AuthorityMutationJournalReceiptVerifier {
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    readonly verificationKeyDigest: string;
+    verifyAppendReceipt(value: unknown): Readonly<AuthorityMutationAppendReceipt>;
+    verifyAcknowledgement(value: unknown): Readonly<AuthorityMutationJournalAcknowledgement>;
+    verifyRange(value: unknown): Readonly<AuthorityMutationJournalRange>;
+}
+export declare class Ed25519AuthorityMutationJournalSigner implements AuthorityMutationJournalSigner {
+    private readonly privateKey;
+    private readonly publicKey;
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    private constructor();
+    static generate(signerPrincipal: string, signingKeyId: string): Ed25519AuthorityMutationJournalSigner;
+    publicKeySpki(): string;
+    sign(canonicalPayload: string): string;
+    verify(canonicalPayload: string, signature: string): boolean;
+}
+export declare class Ed25519AuthorityMutationJournalVerifier implements AuthorityMutationJournalReceiptVerifier {
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    private readonly publicKey;
+    readonly verificationKeyDigest: string;
+    private constructor();
+    static fromSpki(signerPrincipal: string, signingKeyId: string, publicKeySpki: string): Ed25519AuthorityMutationJournalVerifier;
+    verifyAnchor(value: unknown): Readonly<StoredAuthorityMutationAnchor>;
+    verifyAcknowledgement(value: unknown): Readonly<AuthorityMutationJournalAcknowledgement>;
+    verifyAppendReceipt(value: unknown): Readonly<AuthorityMutationAppendReceipt>;
+    verifyRange(value: unknown): Readonly<AuthorityMutationJournalRange>;
+}
+export declare class InMemoryAuthorityMutationJournal implements SynchronousAuthorityMutationJournalPort {
+    private readonly signer;
+    private readonly verifier;
+    private readonly receipts;
+    private frontier;
+    private frontierDigest;
+    private available;
+    private readonly protection;
+    constructor(signer: Ed25519AuthorityMutationJournalSigner, protection: {
+        restore_domain_id: string;
+        encrypted_at_rest: boolean;
+    });
+    setAvailable(available: boolean): void;
+    describe(): AuthorityMutationJournalProtection;
+    protected journalProtection(): AuthorityMutationJournalProtection;
+    append(value: unknown): Readonly<AuthorityMutationAppendReceipt>;
+    readRange(fromSequenceInput: Int64, limitInput: number): Readonly<AuthorityMutationJournalRange>;
+    head(): Readonly<AuthorityMutationJournalAcknowledgement> | null;
+    verifyStoredReceipt(value: unknown): Readonly<AuthorityMutationAppendReceipt>;
+    verifyAppendReceipt(value: unknown): Readonly<AuthorityMutationAppendReceipt>;
+    verifyAcknowledgement(value: unknown): Readonly<AuthorityMutationJournalAcknowledgement>;
+    verifyRange(value: unknown): Readonly<AuthorityMutationJournalRange>;
+    verifyContiguousFrontier(): void;
+    private requireAvailable;
+}
+export declare function parseAuthorityMutationEnvelope(value: unknown): Readonly<AuthorityMutationEnvelope>;
+export declare function assertMutationResultMatchesReconstructionEnvelope(envelopeInput: unknown, expected: {
+    operationId: string;
+    command: string;
+    requestHash: string;
+    actorPrincipal: string;
+    scopeDigest: string;
+    idempotencyKey: string;
+    result: unknown;
+}): Readonly<AuthorityMutationEnvelope>;
+export declare function assertAuthorityMutationJournalSeparated(authorityRestoreDomainIdInput: string, protectionInput: AuthorityMutationJournalProtection): Readonly<AuthorityMutationJournalProtection>;
+export declare function authorityMutationJournalProtectionDigest(protection: Omit<AuthorityMutationJournalProtection, "protection_digest">): string;

package/dist/types/authority/mutation-tuple.d.ts

@@ -0,0 +1,26 @@
+import type { Int64 } from "../core/int64";
+import { type RunSpec } from "../contracts/runspec";
+export interface SubmitRunMutationTuple {
+    readonly scope: {
+        readonly route_lineage_id: string;
+        readonly logical_work_key: string;
+    };
+    readonly request: {
+        readonly run_spec_digest: string;
+        readonly route_id: string;
+        readonly route_epoch: Int64;
+    };
+}
+export declare function submitRunMutationTuple(input: {
+    readonly spec: RunSpec;
+    readonly routeLineageId: string;
+    readonly routeId: string;
+    readonly routeEpoch: Int64;
+}): SubmitRunMutationTuple;
+export declare function mutationRequestHash(input: {
+    command: string;
+    scope: Readonly<Record<string, unknown>>;
+    request: Readonly<Record<string, unknown>>;
+    authorityEpoch: Int64;
+    idempotencyKey: string;
+}): string;

package/dist/types/authority/state.d.ts

@@ -0,0 +1,75 @@
+import type { AdmissionKeyRecord, ApprovalRequestRecord, AttemptLeaseEvent, AttemptLeaseGrant, AttemptRecord, AuthorizationUseRecord, BudgetState, CheckpointRecord, IdempotencyRecord, LaneReservation, LaneSlot, QueueEntry, RunRecord, RunSpecRecord } from "../contracts/dtos";
+import type { AuthorityEvent, OutboxRow } from "../contracts/events";
+import type { Int64 } from "../core/int64";
+import type { AuthorityMutationEnvelope } from "./mutation-journal";
+import type { AccountsModelCallEffectJournalRecord, AccountsModelCallOperationRecord, AccountsOperationSignerHistoryPin, AccountsSerializationDomainState } from "../ports/accounts-operation";
+export interface BudgetReservation {
+    run_id: string;
+    ceiling_units: number;
+    charged_units: number;
+    state: "reserved" | "settled" | "released";
+}
+export interface RouteRecord {
+    route_lineage_id: string;
+    route_id: string;
+    route_epoch: Int64;
+    state: "active" | "draining" | "inactive";
+}
+export interface AuthorityState {
+    authorityEpoch: Int64;
+    routes: Record<string, RouteRecord>;
+    runSpecs: Record<string, RunSpecRecord>;
+    runs: Record<string, RunRecord>;
+    attempts: Record<string, AttemptRecord>;
+    attemptLeaseGrants: Record<string, AttemptLeaseGrant>;
+    attemptLeaseEvents: AttemptLeaseEvent[];
+    queueEntries: Record<string, QueueEntry>;
+    laneSlots: Record<string, LaneSlot>;
+    laneReservations: Record<string, LaneReservation>;
+    laneFairnessCursor: Record<string, string | null>;
+    admissionKeys: Record<string, AdmissionKeyRecord>;
+    idempotencyByOperation: Record<string, IdempotencyRecord>;
+    idempotencyScopeIndex: Record<string, string>;
+    approvals: Record<string, ApprovalRequestRecord>;
+    authorizationUses: Record<string, AuthorizationUseRecord>;
+    checkpoints: Record<string, CheckpointRecord>;
+    events: AuthorityEvent[];
+    eventHeads: Record<string, {
+        sequence: number;
+        digest: string;
+    }>;
+    outbox: OutboxRow[];
+    budget: BudgetState;
+    budgetReservations: Record<string, BudgetReservation>;
+    nextQueueSequence: number;
+    nextAuthorityCommitSequence: number;
+    journalAcknowledgedThrough: number;
+    journalAcknowledgedFrontierDigest: string | null;
+    mutationJournalEnvelopes: Record<string, AuthorityMutationEnvelope>;
+    accountsModelCallOperations: Record<string, AccountsModelCallOperationRecord>;
+    accountsModelCallEffectJournal: AccountsModelCallEffectJournalRecord[];
+    accountsSerializationDomains: Record<string, AccountsSerializationDomainState>;
+    accountsOperationSignerHistoryPin: AccountsOperationSignerHistoryPin | null;
+}
+export interface AuthoritySnapshot {
+    authority_epoch: Int64;
+    routes: RouteRecord[];
+    run_specs: RunSpecRecord[];
+    runs: RunRecord[];
+    attempts: AttemptRecord[];
+    attempt_lease_grants: AttemptLeaseGrant[];
+    attempt_lease_events: AttemptLeaseEvent[];
+    queue_entries: QueueEntry[];
+    lane_slots: LaneSlot[];
+    lane_reservations: LaneReservation[];
+    live_lane_reservations: LaneReservation[];
+    admission_keys: AdmissionKeyRecord[];
+    idempotency_records: IdempotencyRecord[];
+    approvals: ApprovalRequestRecord[];
+    authorization_uses: AuthorizationUseRecord[];
+    checkpoints: CheckpointRecord[];
+    events: AuthorityEvent[];
+    outbox: OutboxRow[];
+    budget: BudgetState;
+}
+export declare function initialAuthorityState(authorityEpoch?: Int64): AuthorityState;

package/dist/types/authority/store.d.ts

@@ -0,0 +1,15 @@
+import { type AuthoritySnapshot, type AuthorityState } from "./state";
+export type CrashStage = "before_commit" | "after_commit";
+export declare class DeterministicFaultInjector {
+    private armedStage;
+    arm(stage: CrashStage): void;
+    hit(stage: CrashStage): void;
+}
+export declare class InMemoryAuthorityStore {
+    private readonly faults;
+    private state;
+    constructor(initial?: AuthorityState, faults?: DeterministicFaultInjector);
+    read<T>(reader: (state: Readonly<AuthorityState>) => T): T;
+    transaction<T>(mutation: (draft: AuthorityState) => T): T;
+    snapshot(): AuthoritySnapshot;
+}

package/dist/types/brokers/checkpoint/archive.d.ts

@@ -0,0 +1,21 @@
+export type ArchiveEntryKind = "file" | "directory" | "symlink" | "hardlink" | "device" | "fifo" | "socket";
+export interface ArchiveEntry {
+    path: string;
+    kind: ArchiveEntryKind;
+    byteLength: number;
+    compressedByteLength: number;
+    linkTarget?: string;
+}
+export interface ArchivePolicy {
+    maxEntries: number;
+    maxEntryBytes: number;
+    maxTotalBytes: number;
+    maxCompressionRatio: number;
+}
+export interface ArchiveIndexReceipt {
+    readonly entryCount: number;
+    readonly totalBytes: number;
+    readonly totalCompressedBytes: number;
+}
+export declare function archiveIndexDigest(entries: readonly ArchiveEntry[]): string;
+export declare function validateArchiveIndex(entries: readonly ArchiveEntry[], policy: ArchivePolicy): ArchiveIndexReceipt;

package/dist/types/brokers/checkpoint/bundle.d.ts

@@ -0,0 +1,22 @@
+import { type BinarySource } from "./bytes";
+export interface GitBundleInspectionPolicy {
+    objectFormat: "sha1" | "sha256";
+    expectedBaseOid: string;
+    expectedCandidateOid: string;
+    maxBytes: number;
+    maxHeaderBytes: number;
+    maxPackObjects: number;
+}
+export interface GitBundleInspection {
+    readonly byteLength: number;
+    readonly sha256: string;
+    readonly prerequisiteOid: string;
+    readonly candidateOid: string;
+    readonly candidateRef: "refs/infinity/candidate";
+    readonly bundleVersion: 2 | 3;
+    readonly packVersion: 2 | 3;
+    readonly packObjectCount: number;
+    readonly verificationLevel: "bounded_header_only_requires_clean_verifier";
+    copyBytes(): Uint8Array;
+}
+export declare function inspectGitBundle(source: BinarySource, policy: GitBundleInspectionPolicy): Promise<GitBundleInspection>;

package/dist/types/brokers/checkpoint/bytes.d.ts

@@ -0,0 +1,4 @@
+export type BinarySource = Uint8Array | AsyncIterable<Uint8Array>;
+export declare function readBoundedBytes(source: BinarySource, maximumBytes: number): Promise<Uint8Array>;
+export declare function sha256Bytes(bytes: Uint8Array): string;
+export declare function bytesEqual(left: Uint8Array, right: Uint8Array): boolean;

package/dist/types/brokers/checkpoint/clean-verifier-finalization.d.ts

@@ -0,0 +1,62 @@
+import { type SqlExecutor } from "../persistence/postgres";
+import { type CheckpointManifestSigningTrustHead } from "./manifest-signature";
+import { type CleanVerifierHandoff, type PassingVerificationReceipt, type PassingVerificationReceiptCore, type VerificationReceiptCryptographyPort, type VerificationReceiptFinalTrustAuthorityPort } from "./verifier";
+import { type SandboxesVerifierCleanupReceiptVerifierPort, type VerifierCleanupAuthorityPort, type VerifiedVerifierCleanupEvidence } from "./verifier-cleanup";
+export interface CleanVerifierFinalizationAuthorityPort {
+    prepare(input: {
+        handoff: CleanVerifierHandoff;
+        completion: CleanVerifierCompletionPreparation;
+    }): Promise<void>;
+    resume(handoff: CleanVerifierHandoff): Promise<PassingVerificationReceipt | null>;
+    finalize(input: {
+        handoff: CleanVerifierHandoff;
+        core: PassingVerificationReceiptCore;
+        cleanupEvidence: VerifiedVerifierCleanupEvidence;
+    }): Promise<PassingVerificationReceipt>;
+}
+export interface CleanVerifierCompletionPreparation {
+    testReceiptSha256: string;
+    secretScanReceiptSha256: string;
+    verifierResultAttestationSha256: string;
+    verifierResultSha256: string;
+    resourceLimitsSha256: string;
+    testCommandsSha256: string;
+    expectedCurrentSigningTrustHead: CheckpointManifestSigningTrustHead;
+}
+export declare class InMemoryCleanVerifierFinalizationAuthority implements CleanVerifierFinalizationAuthorityPort {
+    private readonly cryptography;
+    private readonly finalTrustAuthority;
+    private readonly receipts;
+    private readonly preparations;
+    constructor(cryptography: VerificationReceiptCryptographyPort, finalTrustAuthority: VerificationReceiptFinalTrustAuthorityPort);
+    prepare(input: {
+        handoff: CleanVerifierHandoff;
+        completion: CleanVerifierCompletionPreparation;
+    }): Promise<void>;
+    resume(handoff: CleanVerifierHandoff): Promise<PassingVerificationReceipt | null>;
+    finalize(input: {
+        handoff: CleanVerifierHandoff;
+        core: PassingVerificationReceiptCore;
+        cleanupEvidence: VerifiedVerifierCleanupEvidence;
+    }): Promise<PassingVerificationReceipt>;
+}
+export declare class PostgresCleanVerifierFinalizationAuthority implements CleanVerifierFinalizationAuthorityPort {
+    private readonly dependencies;
+    constructor(dependencies: {
+        sql: SqlExecutor;
+        cryptography: VerificationReceiptCryptographyPort;
+        finalTrustAuthority: VerificationReceiptFinalTrustAuthorityPort;
+        cleanupAuthority: VerifierCleanupAuthorityPort;
+        cleanupReceiptVerifier: SandboxesVerifierCleanupReceiptVerifierPort;
+    });
+    prepare(input: {
+        handoff: CleanVerifierHandoff;
+        completion: CleanVerifierCompletionPreparation;
+    }): Promise<void>;
+    resume(handoff: CleanVerifierHandoff): Promise<PassingVerificationReceipt | null>;
+    finalize(input: {
+        handoff: CleanVerifierHandoff;
+        core: PassingVerificationReceiptCore;
+        cleanupEvidence: VerifiedVerifierCleanupEvidence;
+    }): Promise<PassingVerificationReceipt>;
+}