@hasna/infinity 0.1.0

package/dist/types/ports/accounts-operation.d.ts

@@ -0,0 +1,336 @@
+import type { Clock } from "../core/clock";
+import { type Int64 } from "../core/int64";
+import type { AuthorityState } from "../authority/state";
+import { InMemoryAuthorityStore } from "../authority/store";
+import type { LaneReservation } from "../contracts/dtos";
+import { type AccountsOnlineGenerationContext, type AccountsSlotEligibilityPort, type AccountsSerializationDomainPreimage } from "./accounts";
+export type InfinitySha256Digest = `sha256:${string}`;
+export type InfinityCounter = string;
+/** Exact Accounts workspace integration pin used by the local compatibility fixture. */
+export declare const INFINITY_ACCOUNTS_INTEGRATION_COMMIT: "6c2ba3d490cd58c7192d6e274514a9d849575ab8";
+export declare const INFINITY_MODEL_CALL_PREPARED_ANCHOR_SCHEMA_DIGEST: "sha256:39f247a54d025353bdb2cf98907ccfe9ad49d8c03ba4244bf66c72da667e924e";
+export declare const INFINITY_MODEL_CALL_CONSUME_BINDING_SCHEMA_DIGEST: "sha256:5ed69a61c6162ac1aa42e50e8d718b92fc8bbfab9b1da0d78ecbe91c24f621d2";
+declare const PREPARED_SCHEMA_VERSION: "infinity.model-call-prepared-anchor/v1";
+declare const CONSUME_BINDING_SCHEMA_VERSION: "infinity.model-call-consume-binding/v1";
+declare const EFFECT_RECORD_SCHEMA_VERSION: "infinity.accounts-model-call-effect/v1";
+declare const FRONTIER_HEAD_SCHEMA_VERSION: "infinity.account-serialization-frontier-head/v1";
+declare const SIGNER_HISTORY_SCHEMA_VERSION: "infinity.accounts-operation-signer-history/v1";
+export declare const INFINITY_MODEL_CALL_PREPARED_ANCHOR_DESCRIPTOR: {
+    schema_version: "infinity.model-call-prepared-anchor/v1";
+    fields: readonly ["schema_version", "schema_digest", "record_kind", "effect_namespace_id", "model_call_anchor_id", "capability_id", "capability_digest", "nonce", "subject", "actor_principal", "account_lane_id", "capacity_pool_id", "capacity_domain_ref", "credential_family_id", "serialization_key_digest", "resource_lease_id", "resource_id", "resource_lifecycle_generation", "operation_id", "operation_digest", "operation_execution_epoch", "sender_key_thumbprint", "channel_binding_digest", "canonical_request_digest", "provider_destination_policy_digest", "online_receipt_id", "online_receipt_digest", "hold_authority_epoch", "hold_id", "hold_generation", "hold_state", "predecessor_resource_lease_frontier_sequence", "predecessor_resource_lease_frontier_hash", "predecessor_model_effect_frontier_sequence", "predecessor_model_effect_frontier_hash", "predecessor_delivery_frontier_sequence", "predecessor_delivery_frontier_hash", "predecessor_hold_model_frontier_digest", "audience", "prepared_at", "expires_at", "signer_ref", "signer_incarnation", "key_id", "signature"];
+    literals: {
+        readonly record_kind: "PREPARED";
+        readonly hold_state: "OPEN";
+    };
+};
+export declare const INFINITY_MODEL_CALL_CONSUME_BINDING_DESCRIPTOR: {
+    schema_version: "infinity.model-call-consume-binding/v1";
+    fields: readonly ["schema_version", "schema_digest", "record_kind", "effect_namespace_id", "model_call_anchor_id", "model_call_anchor_digest", "consume_receipt_digest", "use_id", "operation_id", "operation_execution_epoch", "canonical_request_digest", "hold_authority_epoch", "hold_id", "hold_generation", "hold_state", "resource_lease_frontier_sequence", "resource_lease_frontier_hash", "prepared_model_effect_frontier_sequence", "prepared_model_effect_frontier_hash", "delivery_frontier_sequence", "delivery_frontier_hash", "hold_model_frontier_digest", "audience", "bound_at", "signer_ref", "signer_incarnation", "key_id", "signature"];
+    literals: {
+        readonly record_kind: "CONSUME_BOUND";
+        readonly hold_state: "OPEN";
+    };
+};
+export declare const INFINITY_ACCOUNT_SERIALIZATION_FRONTIER_HEAD_SCHEMA_DIGEST: "sha256:924a0c36b038769cd96bdceb4457c732cf88663f26986ded66324a5c480527df";
+export declare const INFINITY_ACCOUNT_SERIALIZATION_FRONTIER_HEAD_DESCRIPTOR: {
+    schema_version: "infinity.account-serialization-frontier-head/v1";
+    fields: readonly ["schema_version", "schema_digest", "frontier_kind", "effect_namespace_id", "serialization_key_digest", "frontier_sequence", "predecessor_frontier_hash", "last_record_digest", "recorded_at", "signer_ref", "signer_incarnation", "key_id", "audience", "signature"];
+    frontier_kinds: readonly ["DELIVERY", "MODEL_EFFECT", "RESOURCE_LEASE"];
+};
+export declare const INFINITY_ACCOUNT_MAINTENANCE_HOLD_OPEN_SCHEMA_DIGEST: "sha256:e985c04e6dc40d33e2c53e90ecbf30b64c7f3b303da558ee07e5d8a817214455";
+export declare const INFINITY_ACCOUNT_MAINTENANCE_HOLD_OPEN_DESCRIPTOR: {
+    schema_version: "infinity.account-maintenance-hold-open-receipt/v1";
+    fields: readonly ["schema_version", "schema_digest", "receipt_id", "issuer", "issuer_incarnation", "key_id", "audience", "effect_namespace_id", "authority_epoch", "hold_id", "hold_generation", "event_kind", "hold_state", "account_resource_id", "resource_lifecycle_generation", "owner_ref", "provider_account_id", "capacity_pool_id", "capacity_domain_ref", "serialization_key_digest", "capacity_generation", "deny_generation", "resource_lease_frontier_sequence", "resource_lease_frontier_hash", "model_effect_frontier_sequence", "model_effect_frontier_hash", "delivery_frontier_sequence", "delivery_frontier_hash", "ambiguity_obligation_count", "obligation_set_digest", "opened_at", "signature"];
+    literals: {
+        readonly ambiguity_obligation_count: "0";
+        readonly event_kind: "INITIALIZED";
+        readonly hold_generation: "0";
+        readonly hold_state: "OPEN";
+    };
+};
+export type AccountsSerializationFrontierKind = typeof INFINITY_ACCOUNT_SERIALIZATION_FRONTIER_HEAD_DESCRIPTOR.frontier_kinds[number];
+export interface SignedAccountsSerializationFrontierHead {
+    readonly schemaVersion: typeof FRONTIER_HEAD_SCHEMA_VERSION;
+    readonly schemaDigest: typeof INFINITY_ACCOUNT_SERIALIZATION_FRONTIER_HEAD_SCHEMA_DIGEST;
+    readonly frontierKind: AccountsSerializationFrontierKind;
+    readonly effectNamespaceId: string;
+    readonly serializationKeyDigest: InfinitySha256Digest;
+    readonly frontierSequence: InfinityCounter;
+    readonly predecessorFrontierHash: InfinitySha256Digest;
+    readonly lastRecordDigest: InfinitySha256Digest;
+    readonly recordedAt: string;
+    readonly jcsBase64url: string;
+    readonly digest: InfinitySha256Digest;
+}
+export interface AccountsSerializationDomainState {
+    readonly domainKey: string;
+    readonly effectNamespaceId: string;
+    readonly serializationKeyDigest: InfinitySha256Digest;
+    holdAuthorityEpoch: InfinityCounter;
+    readonly holdId: string;
+    holdGeneration: InfinityCounter;
+    holdState: "OPEN" | "DRAINING" | "HELD";
+    readonly initializedOpenReceiptJcsBase64url: string;
+    readonly initializedOpenReceiptDigest: InfinitySha256Digest;
+    readonly resourceId: string;
+    readonly resourceLifecycleGeneration: InfinityCounter;
+    readonly resourceLeases: Record<string, AccountsResourceLeaseState>;
+    readonly frontierHeads: Record<AccountsSerializationFrontierKind, SignedAccountsSerializationFrontierHead[]>;
+}
+export interface AccountsResourceLeaseState {
+    readonly resourceLeaseId: string;
+    readonly resourceLeaseProjectionJcs: string;
+    readonly resourceLeaseProjectionDigest: InfinitySha256Digest;
+    activeModelOperationId: string | null;
+}
+export type AccountsOperationSigningKeyStatus = "ACTIVE" | "RETIRED" | "REVOKED";
+export interface AccountsOperationSignerHistoryRecord {
+    readonly schemaVersion: typeof SIGNER_HISTORY_SCHEMA_VERSION;
+    readonly historySequence: InfinityCounter;
+    readonly priorHistoryDigest: InfinitySha256Digest;
+    readonly signerPrincipal: string;
+    readonly signerIncarnation: string;
+    readonly keyId: string;
+    readonly publicKeySpkiBase64url: string;
+    readonly status: AccountsOperationSigningKeyStatus;
+    readonly recordDigest: InfinitySha256Digest;
+}
+export interface AccountsOperationSignerHistoryPin {
+    readonly trustAnchorDigest: InfinitySha256Digest;
+    readonly headSequence: InfinityCounter;
+    readonly headDigest: InfinitySha256Digest;
+}
+export interface CapabilityUseOperationBinding {
+    readonly effectNamespaceId: string;
+    readonly capabilityId: string;
+    readonly capabilityDigest: InfinitySha256Digest;
+    readonly nonce: string;
+    readonly subject: string;
+    readonly actorPrincipal: string;
+    readonly accountLaneId: string;
+    readonly capacityPoolId: string;
+    readonly capacityDomainRef: string;
+    readonly serializationKeyDigest: InfinitySha256Digest;
+    readonly credentialFamilyId: string;
+    readonly resourceLeaseId: string;
+    readonly resourceId: string;
+    readonly resourceLifecycleGeneration: InfinityCounter;
+    readonly operationId: string;
+    readonly operationDigest: InfinitySha256Digest;
+    readonly operationExecutionEpoch: InfinityCounter;
+    readonly senderKeyThumbprint: InfinitySha256Digest;
+    readonly channelBindingDigest: InfinitySha256Digest;
+    readonly canonicalRequestDigest: InfinitySha256Digest;
+    readonly providerDestinationPolicyDigest: InfinitySha256Digest;
+    readonly onlineReceiptId: string;
+    readonly onlineReceiptDigest: InfinitySha256Digest;
+    readonly modelCallAnchorDigest: InfinitySha256Digest;
+}
+export interface VerifiedPreparedOpenOperation {
+    readonly schemaVersion: typeof PREPARED_SCHEMA_VERSION;
+    readonly schemaDigest: typeof INFINITY_MODEL_CALL_PREPARED_ANCHOR_SCHEMA_DIGEST;
+    readonly recordKind: "PREPARED";
+    readonly holdState: "OPEN";
+    readonly binding: CapabilityUseOperationBinding;
+    readonly preparedAnchorJcsBase64url: string;
+    readonly preparedAnchorDigest: InfinitySha256Digest;
+    readonly openHoldReceiptJcsBase64url: string;
+    readonly openHoldReceiptDigest: InfinitySha256Digest;
+    readonly holdAuthorityEpoch: InfinityCounter;
+    readonly holdId: string;
+    readonly holdGeneration: InfinityCounter;
+    readonly resourceLeaseFrontierSequence: InfinityCounter;
+    readonly resourceLeaseFrontierHash: InfinitySha256Digest;
+    readonly preparedModelEffectFrontierSequence: InfinityCounter;
+    readonly preparedModelEffectFrontierHash: InfinitySha256Digest;
+    readonly deliveryFrontierSequence: InfinityCounter;
+    readonly deliveryFrontierHash: InfinitySha256Digest;
+    readonly holdModelFrontierDigest: InfinitySha256Digest;
+}
+export interface BindCapabilityUseRequest {
+    readonly prepared: VerifiedPreparedOpenOperation;
+    readonly consumeReceiptDigest: InfinitySha256Digest;
+    readonly useId: InfinitySha256Digest;
+}
+export interface AssertPreparedOpenCurrentRequest {
+    readonly prepared: VerifiedPreparedOpenOperation;
+}
+export interface VerifiedConsumeBoundOperation {
+    readonly schemaVersion: typeof CONSUME_BINDING_SCHEMA_VERSION;
+    readonly schemaDigest: typeof INFINITY_MODEL_CALL_CONSUME_BINDING_SCHEMA_DIGEST;
+    readonly recordKind: "CONSUME_BOUND";
+    readonly holdState: "OPEN";
+    readonly prepared: VerifiedPreparedOpenOperation;
+    readonly consumeReceiptDigest: InfinitySha256Digest;
+    readonly useId: InfinitySha256Digest;
+    readonly consumeBindingJcsBase64url: string;
+    readonly consumeBindingDigest: InfinitySha256Digest;
+    readonly boundModelEffectFrontierSequence: InfinityCounter;
+    readonly boundModelEffectFrontierHash: InfinitySha256Digest;
+}
+export interface AssertConsumeBoundCurrentRequest {
+    readonly consumeBound: VerifiedConsumeBoundOperation;
+}
+export interface InfinityAccountsOperationPort {
+    readPreparedOpenOperation(binding: CapabilityUseOperationBinding): Promise<VerifiedPreparedOpenOperation>;
+    assertPreparedOpenCurrent(request: AssertPreparedOpenCurrentRequest): Promise<VerifiedPreparedOpenOperation>;
+    bindCapabilityUse(request: BindCapabilityUseRequest): Promise<VerifiedConsumeBoundOperation>;
+    assertConsumeBoundCurrent(request: AssertConsumeBoundCurrentRequest): Promise<VerifiedConsumeBoundOperation>;
+}
+export interface InfinityAccountsOperationRecoveryPort extends InfinityAccountsOperationPort {
+    /** Reads the current exact bound evidence, or null while the exact operation remains PREPARED. */
+    readConsumeBoundOperation(binding: CapabilityUseOperationBinding): Promise<VerifiedConsumeBoundOperation | null>;
+}
+export interface PrepareAccountsModelCallInput {
+    readonly binding: Omit<CapabilityUseOperationBinding, "modelCallAnchorDigest" | "onlineReceiptId" | "onlineReceiptDigest">;
+    readonly runId: string;
+    readonly attemptId: string;
+    readonly attemptLeaseId: string;
+    readonly leaseEpoch: InfinityCounter;
+    readonly expiresAt: string;
+    readonly onlineGenerationContext: AccountsOnlineGenerationContext;
+}
+export interface AccountsModelCallEffectJournalRecord {
+    readonly schemaVersion: typeof EFFECT_RECORD_SCHEMA_VERSION;
+    readonly journalSequence: Int64;
+    readonly domainKey: string;
+    readonly effectNamespaceId: string;
+    readonly serializationKeyDigest: InfinitySha256Digest;
+    readonly priorFrontierHash: InfinitySha256Digest;
+    readonly recordKind: "PREPARED" | "CONSUME_BOUND";
+    readonly operationId: string;
+    readonly operationDigest: string;
+    readonly modelCallAnchorDigest: string;
+    readonly recordCanonicalJson: string;
+    readonly recordDigest: string;
+    readonly frontierHash: string;
+    readonly frontierHeadJcsBase64url: string;
+    readonly recordedAt: string;
+}
+export interface AccountsModelCallOperationRecord {
+    operationId: string;
+    prepareInputDigest: string;
+    runId: string;
+    attemptId: string;
+    attemptLeaseId: string;
+    leaseEpoch: Int64;
+    expiresAt: string;
+    state: "PREPARED" | "CONSUME_BOUND" | "INVALIDATED";
+    prepared: VerifiedPreparedOpenOperation;
+    consumeBound: VerifiedConsumeBoundOperation | null;
+    consumeTombstoneDigest: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AccountsOperationEvidenceSigner {
+    readonly signerPrincipal: string;
+    readonly signerIncarnation: string;
+    readonly signingKeyId: string;
+    publicKeySpkiBase64url(): string;
+    sign(canonicalPayload: string): string;
+    verify(canonicalPayload: string, signature: string): boolean;
+}
+export declare class Ed25519AccountsOperationEvidenceSigner implements AccountsOperationEvidenceSigner {
+    readonly signerPrincipal: string;
+    readonly signerIncarnation: string;
+    readonly signingKeyId: string;
+    private readonly privateKey;
+    private readonly publicKey;
+    private constructor();
+    static generate(signerPrincipal: string, signingKeyId: string, signerIncarnation?: string): Ed25519AccountsOperationEvidenceSigner;
+    static fromPublicKey(signerPrincipal: string, signingKeyId: string, publicKeySpkiBase64url: string, signerIncarnation?: string): Ed25519AccountsOperationEvidenceSigner;
+    publicKeySpkiBase64url(): string;
+    sign(canonicalPayload: string): string;
+    verify(canonicalPayload: string, signature: string): boolean;
+}
+/**
+ * Process-external trust input for the local adapter. The history is append-only,
+ * hash-linked, and pinned by the authority state on every transaction. Retired
+ * keys remain historical verifiers; revoked keys invalidate their evidence.
+ */
+export declare class InMemoryAccountsOperationSignerHistory {
+    private readonly records;
+    private readonly signers;
+    private readonly trustAnchorDigestValue;
+    constructor(initialSigner: AccountsOperationEvidenceSigner);
+    get trustAnchorDigest(): InfinitySha256Digest;
+    snapshot(): readonly AccountsOperationSignerHistoryRecord[];
+    pin(): AccountsOperationSignerHistoryPin;
+    assertExtends(pin: AccountsOperationSignerHistoryPin | null): AccountsOperationSignerHistoryPin;
+    rotate(nextSigner: AccountsOperationEvidenceSigner): void;
+    retireCurrent(): void;
+    revoke(keyId: string): void;
+    currentActiveSigner(): AccountsOperationEvidenceSigner;
+    verify(canonicalPayload: string, identity: {
+        signerRef: unknown;
+        signerIncarnation: unknown;
+        keyId: unknown;
+        signature: unknown;
+    }): boolean;
+    private append;
+    private latestStatus;
+    private assertSignerIdentity;
+    private assertIntegrity;
+}
+export type TrustedAccountsReservationProjection = Readonly<Pick<LaneReservation, "id" | "resource_id" | "resource_lifecycle_generation" | "effect_namespace_id" | "provider_account_id" | "owner_ref" | "capacity_pool_id" | "capacity_domain_ref" | "serialization_key" | "serialization_key_digest" | "capacity_generation" | "deny_generation">>;
+export interface AccountsSerializationDomainInitialization {
+    readonly domainKey: string;
+    readonly effectNamespaceId: string;
+    readonly serializationKeyDigest: InfinitySha256Digest;
+    readonly holdAuthorityEpoch: InfinityCounter;
+    readonly holdId: string;
+    readonly holdGeneration: "0";
+    readonly holdState: "OPEN";
+    readonly initializedOpenReceiptJcsBase64url: string;
+    readonly initializedOpenReceiptDigest: InfinitySha256Digest;
+    readonly frontierHeads: Record<AccountsSerializationFrontierKind, SignedAccountsSerializationFrontierHead[]>;
+}
+/**
+ * Package-internal construction seam shared by the local adapter and durable
+ * installers. The caller must supply a reservation read from trusted authority
+ * state; this function independently re-derives its Accounts domain digest.
+ */
+export declare function createAccountsSerializationDomainInitialization(authorityEpochInput: InfinityCounter, reservation: TrustedAccountsReservationProjection, databaseTimeInput: string, signerHistory: InMemoryAccountsOperationSignerHistory): AccountsSerializationDomainInitialization;
+export declare function verifyAccountsSerializationDomainInitialization(initialization: AccountsSerializationDomainInitialization, authorityEpochInput: InfinityCounter, reservation: TrustedAccountsReservationProjection, signerHistory: InMemoryAccountsOperationSignerHistory): void;
+/** Builds trusted initialization and its first RESOURCE_LEASE_ACQUIRED successor. */
+export declare function createAccountsAcquiredSerializationDomain(authorityEpoch: InfinityCounter, reservation: TrustedAccountsReservationProjection & Readonly<Pick<LaneReservation, "run_id" | "attempt_id" | "lease_epoch" | "slot_id">>, attemptLeaseIdInput: string, databaseTimeInput: string, signerHistory: InMemoryAccountsOperationSignerHistory, suppliedInitialization?: AccountsSerializationDomainInitialization): AccountsSerializationDomainState;
+/**
+ * Reusable claim-transaction primitive. A durable store may hydrate/lock the
+ * state row first, invoke this helper, then persist the resulting exact bytes.
+ */
+export declare function installOrAppendAccountsResourceLease(state: AuthorityState, authorityEpoch: InfinityCounter, reservation: TrustedAccountsReservationProjection & Readonly<Pick<LaneReservation, "run_id" | "attempt_id" | "lease_epoch" | "slot_id">>, attemptLeaseId: string, databaseTime: string, signerHistory: InMemoryAccountsOperationSignerHistory): AccountsSerializationDomainState;
+/**
+ * Fails retryably before any shared RESOURCE_LEASE frontier advance while a
+ * PREPARED model operation owns the domain. All resource leases in the domain
+ * share that frontier, so even a sibling acquisition would invalidate the
+ * prepared predecessor proof.
+ */
+export declare function assertAccountsResourceLeaseFrontierAdvanceAllowed(domain: Readonly<AccountsSerializationDomainState>): void;
+/** Clears the exact authoritative child when authority fences/releases a lease. */
+export declare function releaseAccountsResourceLeaseActiveOperation(state: AuthorityState, resourceLeaseId: string, invalidatedAt: string, allowActiveInvalidation?: boolean): void;
+/**
+ * Local vertical adapter. Its projection and append-only journal share the
+ * InMemoryAuthorityStore transaction with run cancellation. It deliberately
+ * performs no credential resolution and has no provider-effect callback.
+ */
+export declare class InMemoryInfinityAccountsOperationAdapter implements InfinityAccountsOperationRecoveryPort {
+    private readonly store;
+    private readonly clock;
+    private readonly signerHistory;
+    private readonly accounts;
+    constructor(store: InMemoryAuthorityStore, clock: Clock, signerHistory: InMemoryAccountsOperationSignerHistory, accounts: AccountsSlotEligibilityPort);
+    prepareModelCall(value: PrepareAccountsModelCallInput): Promise<VerifiedPreparedOpenOperation>;
+    readPreparedOpenOperation(value: CapabilityUseOperationBinding): Promise<VerifiedPreparedOpenOperation>;
+    assertPreparedOpenCurrent(value: AssertPreparedOpenCurrentRequest): Promise<VerifiedPreparedOpenOperation>;
+    readConsumeBoundOperation(value: CapabilityUseOperationBinding): Promise<VerifiedConsumeBoundOperation | null>;
+    bindCapabilityUse(value: BindCapabilityUseRequest): Promise<VerifiedConsumeBoundOperation>;
+    assertConsumeBoundCurrent(value: AssertConsumeBoundCurrentRequest): Promise<VerifiedConsumeBoundOperation>;
+    private assertExactPrepared;
+    private verifyPrepared;
+    private verifyConsumeBound;
+}
+export declare function accountsSerializationKeyDigest(value: AccountsSerializationDomainPreimage): InfinitySha256Digest;
+/** Package-internal durable-startup verification seam. */
+export declare function verifyAccountsSerializationDomainState(state: Readonly<AuthorityState>, storedKey: string, domain: AccountsSerializationDomainState, signerHistory: InMemoryAccountsOperationSignerHistory): void;
+export declare function assertVerifiedConsumeBoundEvidence(signerHistory: InMemoryAccountsOperationSignerHistory, value: VerifiedConsumeBoundOperation, expectedTombstoneDigest?: string | null): VerifiedConsumeBoundOperation;
+export {};

package/dist/types/ports/accounts.d.ts

@@ -0,0 +1,293 @@
+export interface SlotEligibilityRequest {
+    schema_version: "accounts.eligibility-request.v1";
+    account_lane_id: string;
+    data_classification: string;
+    destination_policy_class: string;
+    model: string;
+    operation: string;
+}
+export interface AccountsProviderDestinationPolicy extends Readonly<Record<string, unknown>> {
+    readonly scheme: string;
+    readonly normalized_host: string;
+    readonly port: string;
+    readonly operation_path: string;
+    readonly model: string;
+    readonly request_body_digest: string;
+    readonly tls_server_name: string;
+    readonly resolved_address_class: string;
+    readonly egress_policy_digest: string;
+}
+/** Exact Accounts v11 online-generation binding context. */
+export interface AccountsOnlineGenerationContext {
+    readonly authenticated_actor_principal: string;
+    readonly account_lane_id: string;
+    readonly capability_id: string;
+    readonly capability_digest: string;
+    readonly nonce: string;
+    readonly authority_epoch: string;
+    readonly route_lineage_id: string;
+    readonly route_id: string;
+    readonly route_epoch: string;
+    readonly run_id: string;
+    readonly attempt_id: string;
+    readonly attempt_lease_id: string;
+    readonly lease_epoch: string;
+    readonly resource_lease_id: string;
+    readonly resource_id: string;
+    readonly resource_lifecycle_generation: string;
+    readonly lease_expires_at: string;
+    readonly operation_id: string;
+    readonly operation_digest: string;
+    readonly operation_execution_epoch: string;
+    readonly operation_execution_expires_at: string;
+    readonly subject: string;
+    readonly actor_principal: string;
+    readonly lease_holder_principal: string;
+    readonly operation_executor_principal: string;
+    readonly sender_key_thumbprint: string;
+    readonly approval_mode: string;
+    readonly approval_binding_digest: string;
+    readonly policy_digest: string;
+    readonly canonical_request_digest: string;
+    readonly provider_destination_policy: AccountsProviderDestinationPolicy;
+    readonly provider_destination_policy_digest: string;
+    readonly sender_constraint_confirmation: string;
+    readonly max_uses: "1";
+}
+export interface AllowedOnlineGenerationCheckReceipt extends Readonly<Record<string, unknown>> {
+    readonly schema_version: "accounts.online-generation-check-receipt/v1";
+    readonly schema_digest: string;
+    readonly receipt_id: string;
+    readonly issuer: string;
+    readonly issuer_incarnation: string;
+    readonly key_id: string;
+    readonly audience: string;
+    readonly nonce: string;
+    readonly issued_at: string;
+    readonly not_before: string;
+    readonly expires_at: string;
+    readonly signature: string;
+    readonly capability_id: string;
+    readonly capability_digest: string;
+    readonly authority_epoch: string;
+    readonly route_lineage_id: string;
+    readonly route_id: string;
+    readonly route_epoch: string;
+    readonly run_id: string;
+    readonly attempt_id: string;
+    readonly attempt_lease_id: string;
+    readonly lease_epoch: string;
+    readonly resource_lease_id: string;
+    readonly resource_id: string;
+    readonly resource_lifecycle_generation: string;
+    readonly lease_expires_at: string;
+    readonly operation_id: string;
+    readonly operation_digest: string;
+    readonly operation_execution_epoch: string;
+    readonly operation_execution_expires_at: string;
+    readonly subject: string;
+    readonly actor_principal: string;
+    readonly lease_holder_principal: string;
+    readonly operation_executor_principal: string;
+    readonly sender_key_thumbprint: string;
+    readonly effect_namespace_id: string;
+    readonly provider_account_id: string;
+    readonly account_lane_id: string;
+    readonly capacity_pool_id: string;
+    readonly capacity_domain_ref: string;
+    readonly serialization_key: string;
+    readonly serialization_key_digest: string;
+    readonly access_transport: "api_key" | "workload_identity" | "native_session";
+    readonly credential_family_id: string;
+    readonly allowed: true;
+    readonly deny_state: "allowed";
+    readonly reason_codes: readonly [];
+    readonly capacity_generation: string;
+    readonly deny_generation: string;
+    readonly credential_generation: string;
+    readonly accounts_revision_set_digest: string;
+    readonly allowed_channel_class: "brokered_provider_proxy" | "capsule_remote_tool";
+    readonly slot_eligibility_digest: string;
+    readonly approval_mode: string;
+    readonly approval_binding_digest: string;
+    readonly policy_digest: string;
+    readonly canonical_request_digest: string;
+    readonly provider_destination_policy: AccountsProviderDestinationPolicy;
+    readonly provider_destination_policy_digest: string;
+    readonly sender_constraint_confirmation: string;
+    readonly max_uses: "1";
+    readonly use_count: "0";
+    readonly catalog_incarnation: string;
+    readonly recovery_frontier_sequence: string;
+    readonly recovery_frontier_hash: string;
+    readonly credential_binding_id?: string;
+    readonly broker_ref?: string;
+    readonly auth_capsule_id?: string;
+    readonly canonical_node_id?: string;
+    readonly node_key_thumbprint?: string;
+    readonly node_generation?: string;
+    readonly placement_generation?: string;
+    readonly auth_generation?: string;
+    readonly auth_state_revision?: string;
+}
+export interface BrokeredAccessTarget {
+    kind: "brokered";
+    credential_binding_id: string;
+    broker_ref: string;
+    resolver: "brokered_secret" | "workload_identity";
+}
+export interface NativeAccessTarget {
+    kind: "native";
+    auth_capsule_id: string;
+    canonical_node_id: string;
+    node_key_thumbprint: string;
+    node_generation: string;
+    placement_generation: string;
+    auth_generation: string;
+    auth_state_revision: string;
+}
+export interface BrokeredRecordRevisionSet {
+    provider_account: string;
+    entitlement: string;
+    capacity_pool: string;
+    account_lane: string;
+    credential_binding: string;
+}
+export interface NativeRecordRevisionSet {
+    provider_account: string;
+    entitlement: string;
+    capacity_pool: string;
+    account_lane: string;
+    auth_capsule: string;
+}
+interface ResolvedSlotEligibilityBase {
+    schema_version: "accounts.slot-eligibility/v1";
+    schema_digest: typeof SLOT_ELIGIBILITY_SCHEMA_DIGEST;
+    evidence_id: string;
+    issuer: string;
+    issuer_incarnation: string;
+    catalog_incarnation: string;
+    audience: "infinity:self-hosted";
+    key_id: string;
+    nonce: string;
+    account_lane_id: string;
+    eligibility_request_digest: string;
+    eligible: true;
+    reason_codes: [];
+    issued_at: string;
+    expires_at: string;
+    signature: string;
+    recovery_frontier_sequence: string;
+    recovery_frontier_hash: string;
+    accounts_build_digest: string;
+    accounts_attestation_issuer_ref: string;
+    accounts_attestation_digest: string;
+    accounts_attested_at: string;
+    accounts_attestation_expires_at: string;
+    effect_namespace_id: string;
+    provider_account_id: string;
+    entitlement_id: string;
+    capacity_pool_id: string;
+    capacity_domain_ref: string;
+    provider_key: string;
+    provider_subject_ref: string;
+    owner_ref: string;
+    identity_realm: string;
+    access_transport: "api_key" | "workload_identity" | "native_session";
+    allowed_channel_class: "brokered_provider_proxy" | "capsule_remote_tool";
+    access_target: BrokeredAccessTarget | NativeAccessTarget;
+    serialization_key: string;
+    serialization_key_digest: string;
+    max_concurrency: string;
+    capacity_evidence_ref: string;
+    capacity_evidence_issuer_ref: string;
+    capacity_evidence_version: string;
+    capacity_evidence_digest: string;
+    capacity_evidence_issued_at: string;
+    capacity_evidence_expires_at: string;
+    capacity_evidence_generation: string;
+    capacity_policy_version: string;
+    capacity_generation: string;
+    deny_generation: string;
+    deny_state: "allowed";
+    credential_family_id: string;
+    credential_generation: string;
+    record_revision_set: BrokeredRecordRevisionSet | NativeRecordRevisionSet;
+    accounts_revision_set_digest: string;
+    ownership_evidence_issuer_ref: string;
+    ownership_evidence_version: string;
+    ownership_evidence_digest: string;
+    ownership_evidence_issued_at: string;
+    ownership_evidence_expires_at: string;
+    ownership_generation: string;
+    terms_evidence_issuer_ref: string;
+    terms_evidence_version: string;
+    terms_evidence_digest: string;
+    terms_evidence_issued_at: string;
+    terms_evidence_expires_at: string;
+    execution_policy_evidence_issuer_ref: string;
+    execution_policy_evidence_version: string;
+    execution_policy_evidence_digest: string;
+    execution_policy_evidence_issued_at: string;
+    execution_policy_evidence_expires_at: string;
+    data_policy_evidence_issuer_ref: string;
+    data_policy_evidence_version: string;
+    data_policy_evidence_digest: string;
+    data_policy_evidence_issued_at: string;
+    data_policy_evidence_expires_at: string;
+    isolation_policy_evidence_issuer_ref: string;
+    isolation_policy_evidence_version: string;
+    isolation_policy_evidence_digest: string;
+    isolation_policy_evidence_issued_at: string;
+    isolation_policy_evidence_expires_at: string;
+    health_evidence_issuer_ref: string;
+    health_evidence_version: string;
+    health_evidence_digest: string;
+    health_evidence_issued_at: string;
+    health_evidence_expires_at: string;
+}
+export interface BrokeredSlotEligibility extends ResolvedSlotEligibilityBase {
+    access_transport: "api_key" | "workload_identity";
+    allowed_channel_class: "brokered_provider_proxy";
+    access_target: BrokeredAccessTarget;
+    record_revision_set: BrokeredRecordRevisionSet;
+    binding_policy_digest: string;
+}
+export interface NativeSlotEligibility extends ResolvedSlotEligibilityBase {
+    access_transport: "native_session";
+    allowed_channel_class: "capsule_remote_tool";
+    access_target: NativeAccessTarget;
+    record_revision_set: NativeRecordRevisionSet;
+    capsule_attestation_issuer_ref: string;
+    capsule_attestation_version: string;
+    capsule_attestation_digest: string;
+    capsule_attestation_issued_at: string;
+    capsule_attestation_expires_at: string;
+}
+export type SlotEligibility = BrokeredSlotEligibility | NativeSlotEligibility;
+export interface AccountsSlotEligibilityPort {
+    /** Returns evidence whose Accounts Ed25519 signature and trust policy were already verified. */
+    getSlotEligibility(request: SlotEligibilityRequest): Promise<unknown>;
+    /** Returns exact Accounts evidence already signature/trust/time verified by the port adapter. */
+    checkOnlineGeneration(request: {
+        readonly expectedSlotEligibility: SlotEligibility;
+        readonly context: AccountsOnlineGenerationContext;
+    }): Promise<unknown>;
+}
+export declare const SLOT_ELIGIBILITY_SCHEMA_DIGEST: "sha256:b3415ad8bb71951a628f9744b7949f49d794adde55fb965c73e9b4936c691a55";
+export declare const MAX_SLOT_ELIGIBILITY_LIFETIME_MS = 30000;
+export declare const ACCOUNTS_ELIGIBILITY_REQUEST_SCHEMA_VERSION: "accounts.eligibility-request.v1";
+export declare const ONLINE_GENERATION_CHECK_RECEIPT_SCHEMA_DIGEST: "sha256:5061db743dafa19f9ea2e586494f4205e10549ad546ea92fa6fbc8c2e55a4210";
+export declare function parseSlotEligibilityRequest(value: unknown): Readonly<SlotEligibilityRequest>;
+export interface AccountsSerializationDomainPreimage {
+    effect_namespace_id: string;
+    provider_account_id: string;
+    capacity_pool_id: string;
+    capacity_domain_ref: string;
+    owner_ref: string;
+    serialization_key: string;
+}
+/** Exact seven-member RFC 8785/JCS preimage mandated by Accounts v11. */
+export declare function accountsSerializationDomainDigest(value: AccountsSerializationDomainPreimage): string;
+export declare function parseSlotEligibility(value: unknown): Readonly<SlotEligibility>;
+export {};