@hasna/infinity 0.1.0

package/dist/types/ports/sandbox-dispatch-authority.d.ts

@@ -0,0 +1,154 @@
+import type { AccountsOperationEvidenceSigner, InMemoryAccountsOperationSignerHistory, InfinitySha256Digest } from "./accounts-operation";
+export declare const SANDBOX_DISPATCH_AUTHORIZATION_REQUEST_SCHEMA_V2: "infinity.sandbox-dispatch-authorization-request.v2";
+export declare const SANDBOX_DISPATCH_ACCOUNTS_CONSUME_EVIDENCE_REQUEST_SCHEMA_VERSION: "infinity.sandbox-dispatch-accounts-consume-evidence-request.v1";
+export declare const SANDBOX_DISPATCH_ACCOUNTS_CONSUME_EVIDENCE_SCHEMA_VERSION: "infinity.sandbox-dispatch-accounts-consume-evidence.v1";
+export declare const SANDBOX_DISPATCH_AUTHORIZATION_SCHEMA_V2: "infinity.sandbox-dispatch-authorization.v2";
+export declare const DISPOSABLE_TASK_AUTHORIZATION_CONSUMPTION_SCHEMA_V2: "sandboxes.disposable-task-authorization-consumption/v2";
+export declare const DISPOSABLE_TASK_PROVIDER_CONTACT_AUDIENCE_V2: "hasna:sandboxes:disposable-task-provider-contact/v2";
+export type ManagedProviderIdV1 = "e2b" | "daytona_cloud";
+export interface SandboxDispatchAuthorizationRequestV2 {
+    readonly schema_version: typeof SANDBOX_DISPATCH_AUTHORIZATION_REQUEST_SCHEMA_V2;
+    readonly dispatch_id: string;
+    readonly mint_operation_id: string;
+    readonly idempotency_key: string;
+    readonly run_id: string;
+    readonly attempt_id: string;
+    readonly attempt_lease_id: string;
+    readonly lease_epoch: string;
+    readonly account_lane_id: string;
+    readonly model_operation_id: string;
+    readonly operation_digest: InfinitySha256Digest;
+    readonly provider: ManagedProviderIdV1;
+    readonly canonical_intent_sha256: InfinitySha256Digest;
+    readonly provider_execution_sha256: InfinitySha256Digest;
+    readonly source_manifest_sha256: InfinitySha256Digest;
+    readonly input_manifest_sha256: InfinitySha256Digest;
+    readonly checkpoint_policy_sha256: InfinitySha256Digest;
+    readonly prepared_anchor_sha256: InfinitySha256Digest;
+    readonly effect_claim_sha256: InfinitySha256Digest;
+    readonly sandbox_prepare_anchor_sha256: InfinitySha256Digest;
+    readonly consume_receipt_sha256: InfinitySha256Digest;
+    readonly consume_tombstone_sha256: InfinitySha256Digest;
+    readonly consume_use_id_sha256: InfinitySha256Digest;
+    readonly consume_binding_sha256: InfinitySha256Digest;
+    readonly audience: string;
+    readonly expires_at: string;
+}
+export interface SandboxDispatchAccountsConsumeEvidenceRequestV1 {
+    readonly schema_version: typeof SANDBOX_DISPATCH_ACCOUNTS_CONSUME_EVIDENCE_REQUEST_SCHEMA_VERSION;
+    readonly bind_operation_id: string;
+    readonly idempotency_key: string;
+    readonly model_operation_id: string;
+    readonly verified_accounts_consume_evidence: object;
+}
+export interface SandboxDispatchAccountsConsumeEvidenceV1 {
+    readonly schema_version: typeof SANDBOX_DISPATCH_ACCOUNTS_CONSUME_EVIDENCE_SCHEMA_VERSION;
+    readonly model_operation_id: string;
+    readonly consume_receipt_sha256: InfinitySha256Digest;
+    readonly consume_tombstone_sha256: InfinitySha256Digest;
+    readonly consume_use_id_sha256: InfinitySha256Digest;
+    readonly consume_binding_sha256: InfinitySha256Digest;
+    readonly recorded_at: string;
+}
+export interface SignedSandboxDispatchAuthorizationV2 {
+    readonly schema_version: typeof SANDBOX_DISPATCH_AUTHORIZATION_SCHEMA_V2;
+    readonly dispatch_id: string;
+    readonly mint_operation_id: string;
+    readonly idempotency_key: string;
+    readonly run_id: string;
+    readonly attempt_id: string;
+    readonly attempt_lease_id: string;
+    readonly lease_epoch: string;
+    readonly account_lane_id: string;
+    readonly model_operation_id: string;
+    readonly operation_digest: InfinitySha256Digest;
+    readonly provider: ManagedProviderIdV1;
+    readonly canonical_intent_sha256: InfinitySha256Digest;
+    readonly provider_execution_sha256: InfinitySha256Digest;
+    readonly source_manifest_sha256: InfinitySha256Digest;
+    readonly input_manifest_sha256: InfinitySha256Digest;
+    readonly checkpoint_policy_sha256: InfinitySha256Digest;
+    readonly prepared_anchor_sha256: InfinitySha256Digest;
+    readonly effect_claim_sha256: InfinitySha256Digest;
+    readonly sandbox_prepare_anchor_sha256: InfinitySha256Digest;
+    readonly consume_receipt_sha256: InfinitySha256Digest;
+    readonly consume_tombstone_sha256: InfinitySha256Digest;
+    readonly consume_use_id_sha256: InfinitySha256Digest;
+    readonly consume_binding_sha256: InfinitySha256Digest;
+    readonly authority_epoch: string;
+    readonly audience: string;
+    readonly issued_at: string;
+    readonly expires_at: string;
+    readonly signer_ref: string;
+    readonly signer_incarnation: string;
+    readonly key_id: string;
+    readonly signature: string;
+}
+export interface DisposableTaskAuthorityConsumeInputV2 {
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: InfinitySha256Digest;
+    readonly sandbox_prepare_anchor_sha256: InfinitySha256Digest;
+    readonly authority_envelope_sha256: InfinitySha256Digest;
+    readonly operation_digest: InfinitySha256Digest;
+    readonly provider: ManagedProviderIdV1;
+    readonly source_manifest_sha256: InfinitySha256Digest;
+    readonly input_manifest_sha256: InfinitySha256Digest;
+    readonly checkpoint_policy_sha256: InfinitySha256Digest;
+    readonly effect_claim_sha256: InfinitySha256Digest;
+}
+export interface DisposableTaskAuthorizationConsumptionV2 {
+    readonly schema_version: typeof DISPOSABLE_TASK_AUTHORIZATION_CONSUMPTION_SCHEMA_V2;
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: InfinitySha256Digest;
+    readonly sandbox_prepare_anchor_sha256: InfinitySha256Digest;
+    readonly authority_envelope_sha256: InfinitySha256Digest;
+    readonly operation_digest: InfinitySha256Digest;
+    readonly provider: ManagedProviderIdV1;
+    readonly source_manifest_sha256: InfinitySha256Digest;
+    readonly input_manifest_sha256: InfinitySha256Digest;
+    readonly checkpoint_policy_sha256: InfinitySha256Digest;
+    readonly effect_claim_sha256: InfinitySha256Digest;
+    readonly authority_epoch: string;
+    readonly run_id: string;
+    readonly attempt_id: string;
+    readonly attempt_lease_id: string;
+    readonly lease_epoch: string;
+    readonly model_operation_id: string;
+    readonly audience: string;
+    readonly issued_at: string;
+    readonly consumed_at: string;
+    readonly expires_at: string;
+    readonly signer_ref: string;
+    readonly signer_incarnation: string;
+    readonly key_id: string;
+    readonly signature: string;
+}
+export interface DisposableTaskAuthorizationArtifactsV2 {
+    readonly canonical_authority_envelope_bytes: Uint8Array;
+    readonly authority_envelope_sha256: InfinitySha256Digest;
+    readonly canonical_receipt_bytes: Uint8Array;
+    readonly receipt_sha256: InfinitySha256Digest;
+}
+export interface SandboxDispatchAuthorityPortV2 {
+    bindAccountsConsumeEvidence(request: SandboxDispatchAccountsConsumeEvidenceRequestV1): Promise<SandboxDispatchAccountsConsumeEvidenceV1>;
+    mintAuthorization(request: SandboxDispatchAuthorizationRequestV2): Promise<SignedSandboxDispatchAuthorizationV2>;
+    describe(): Readonly<{
+        durability: "durable";
+        implementation_sha256: InfinitySha256Digest;
+        trust_root_sha256: InfinitySha256Digest;
+    }>;
+    consumeOnceV2(request: DisposableTaskAuthorityConsumeInputV2): Promise<DisposableTaskAuthorizationArtifactsV2>;
+    readAuthorization(dispatchId: string): Promise<SignedSandboxDispatchAuthorizationV2 | null>;
+}
+export declare function parseSandboxDispatchAuthorizationRequestV2(value: unknown): SandboxDispatchAuthorizationRequestV2;
+export declare function parseSandboxDispatchAccountsConsumeEvidenceRequestV1(value: unknown): SandboxDispatchAccountsConsumeEvidenceRequestV1;
+export declare function parseSandboxDispatchAccountsConsumeEvidenceV1(value: unknown): SandboxDispatchAccountsConsumeEvidenceV1;
+export declare function signSandboxDispatchAuthorizationV2(requestValue: SandboxDispatchAuthorizationRequestV2, authorityEpoch: string, issuedAt: string, signer: AccountsOperationEvidenceSigner): SignedSandboxDispatchAuthorizationV2;
+export declare function parseSignedSandboxDispatchAuthorizationV2(value: unknown, signerHistory: InMemoryAccountsOperationSignerHistory): SignedSandboxDispatchAuthorizationV2;
+export declare function parseDisposableTaskAuthorityConsumeInputV2(value: unknown): DisposableTaskAuthorityConsumeInputV2;
+export declare function signDisposableTaskAuthorizationConsumptionV2(authorizationValue: SignedSandboxDispatchAuthorizationV2, requestValue: DisposableTaskAuthorityConsumeInputV2, consumedAt: string, expiresAt: string, signer: AccountsOperationEvidenceSigner): DisposableTaskAuthorizationConsumptionV2;
+export declare function parseDisposableTaskAuthorizationConsumptionV2(value: unknown, signerHistory: InMemoryAccountsOperationSignerHistory): DisposableTaskAuthorizationConsumptionV2;
+export declare function disposableTaskAuthorizationArtifactsV2(authorization: SignedSandboxDispatchAuthorizationV2, receipt: DisposableTaskAuthorizationConsumptionV2): DisposableTaskAuthorizationArtifactsV2;
+export declare function parseDisposableTaskAuthorizationArtifactsV2(value: DisposableTaskAuthorizationArtifactsV2, signerHistory: InMemoryAccountsOperationSignerHistory): DisposableTaskAuthorizationArtifactsV2;
+export declare function sandboxDispatchAuthorizationDigest(value: SignedSandboxDispatchAuthorizationV2): InfinitySha256Digest;
+export declare function disposableTaskAuthorizationConsumptionDigest(value: DisposableTaskAuthorizationConsumptionV2): InfinitySha256Digest;

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

@@ -0,0 +1,40 @@
+import type { AuthenticatedFenceContext, BrokerFence } from "../contracts/fence";
+import type { Int64 } from "../core/int64";
+export interface SandboxHandle {
+    handle_id: string;
+    resource_id: string;
+    resource_lifecycle_generation: Int64;
+    provider_identity_digest: string;
+    creation_receipt_digest: string;
+}
+export interface CreateInertSandboxRequest {
+    fence: BrokerFence;
+    allocation_token: string;
+    image_digest: string;
+    resource_policy_digest: string;
+    network_policy_digest: string;
+    ttl_policy_digest: string;
+}
+export interface ActivateSandboxRequest {
+    fence: BrokerFence;
+    handle: SandboxHandle;
+}
+export interface DestroySandboxRequest {
+    fence: BrokerFence;
+    handle: SandboxHandle;
+    cleanup_grant_digest: string;
+}
+export interface SandboxAbsenceReceipt {
+    handle_id: string;
+    resource_id: string;
+    resource_lifecycle_generation: Int64;
+    absence_receipt_digest: string;
+}
+export interface SandboxesPort {
+    createInert(request: CreateInertSandboxRequest, authenticated: AuthenticatedFenceContext): Promise<SandboxHandle>;
+    activate(request: ActivateSandboxRequest, authenticated: AuthenticatedFenceContext): Promise<{
+        activation_receipt_digest: string;
+    }>;
+    describe(handle: SandboxHandle): Promise<"inert" | "active" | "absent" | "unknown">;
+    destroy(request: DestroySandboxRequest, authenticated: AuthenticatedFenceContext): Promise<SandboxAbsenceReceipt>;
+}

package/dist/types/providers/sandbox-dispatch.d.ts

@@ -0,0 +1,143 @@
+import { INFINITY_PROVIDER_ACTIVATION_SANDBOXES_COMMIT, type ProviderActivationState, type ProviderProductionAdmission } from "../runtime/provider-activation";
+export declare const INFINITY_SANDBOX_DISPATCH_AUTHORIZATION_REQUEST_SCHEMA_V1: "infinity.sandbox-dispatch-authorization-request.v1";
+export declare const INFINITY_SANDBOX_DISPATCH_AUTHORIZATION_RESULT_SCHEMA_V1: "infinity.sandbox-dispatch-authorization-result.v1";
+export declare const INFINITY_SANDBOX_PROVIDER_DISPATCH_PRODUCTION_ADMISSION_V1: false;
+export type InfinityManagedSandboxProviderV1 = "e2b" | "daytona_cloud";
+export interface SandboxesV2Intent {
+    readonly schema_version: "sandboxes.disposable-task-intent/v2";
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly idempotency_key_sha256: string;
+    readonly operation_digest: string;
+    readonly source_manifest_sha256: string;
+    readonly input_manifest_sha256: string;
+    readonly environment_image_sha256: string;
+    readonly task_bundle_sha256: string;
+    readonly network_policy: "deny_all";
+    readonly maximum_allocations: 1;
+    readonly max_runtime_ms: number;
+    readonly files: readonly unknown[];
+    readonly exec: Readonly<Record<string, unknown>>;
+    readonly checkpoint: Readonly<Record<string, unknown>>;
+}
+export interface SandboxesV2PreparedIntent {
+    readonly schema_version: "sandboxes.disposable-task-prepared/v2";
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: string;
+    readonly sandbox_prepare_anchor_sha256: string;
+    readonly operation_digest: string;
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly source_manifest_sha256: string;
+    readonly input_manifest_sha256: string;
+    readonly checkpoint_policy_sha256: string;
+    readonly effect_claim_sha256: string;
+    readonly prepared_sha256: string;
+}
+export interface InfinitySandboxDispatchAuthorizationRequestV1 {
+    readonly schema_version: typeof INFINITY_SANDBOX_DISPATCH_AUTHORIZATION_REQUEST_SCHEMA_V1;
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly authority_envelope_sha256: string;
+    readonly intent: SandboxesV2Intent;
+    readonly prepared: SandboxesV2PreparedIntent;
+}
+export interface SandboxesV2BoundAuthorization {
+    readonly schema_version: "sandboxes.disposable-task-bound-authorization/v2";
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: string;
+    readonly sandbox_prepare_anchor_sha256: string;
+    readonly effect_claim_sha256: string;
+    readonly authority_envelope_sha256: string;
+    readonly authorization_consumption_receipt_sha256: string;
+    readonly dispatch_intent_anchor_sha256: string;
+}
+export interface SandboxesV2AuthorizationPort {
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly production_admission: false;
+    authorizePrepared(input: Readonly<{
+        intent: SandboxesV2Intent;
+        prepared: SandboxesV2PreparedIntent;
+        authority_envelope_sha256: string;
+    }>): Promise<SandboxesV2BoundAuthorization>;
+}
+export interface InfinitySandboxDispatchAuthorizationResultV1 {
+    readonly schema_version: typeof INFINITY_SANDBOX_DISPATCH_AUTHORIZATION_RESULT_SCHEMA_V1;
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly state: "dispatch_intent";
+    readonly provider_contacted: false;
+    readonly production_dispatch_admitted: false;
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: string;
+    readonly sandbox_prepare_anchor_sha256: string;
+    readonly effect_claim_sha256: string;
+    readonly authority_envelope_sha256: string;
+    readonly authorization_consumption_receipt_sha256: string;
+    readonly dispatch_intent_anchor_sha256: string;
+}
+export interface InfinityProductionSandboxDispatchResultV1 {
+    readonly schema_version: "infinity.production-sandbox-dispatch-result.v1";
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly state: "provider_dispatched";
+    readonly provider_contacted: true;
+    readonly production_dispatch_admitted: true;
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: string;
+    readonly sandbox_prepare_anchor_sha256: string;
+    readonly effect_claim_sha256: string;
+    readonly authority_envelope_sha256: string;
+    readonly authorization_consumption_receipt_sha256: string;
+    readonly dispatch_intent_anchor_sha256: string;
+    readonly evidence_manifest_sha256: string;
+    readonly activation_manifest_sha256: string;
+    readonly production_admission_sha256: string;
+    readonly provider_effect_journal_receipt_sha256: string;
+    readonly adapter_artifact_sha256: string;
+}
+export interface SandboxesV2ProductionDispatchResult {
+    readonly schema_version: "sandboxes.disposable-task-production-dispatch/v2";
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly provider_contacted: true;
+    readonly production_dispatch_admitted: true;
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: string;
+    readonly sandbox_prepare_anchor_sha256: string;
+    readonly effect_claim_sha256: string;
+    readonly authority_envelope_sha256: string;
+    readonly authorization_consumption_receipt_sha256: string;
+    readonly dispatch_intent_anchor_sha256: string;
+    readonly production_admission_sha256: string;
+    readonly provider_effect_journal_receipt_sha256: string;
+}
+export interface SandboxesV2ProductionDispatchPort {
+    readonly provider: InfinityManagedSandboxProviderV1;
+    readonly production_admission: true;
+    readonly sandboxes_source_commit: typeof INFINITY_PROVIDER_ACTIVATION_SANDBOXES_COMMIT;
+    readonly evidence_manifest_sha256: string;
+    readonly adapter_artifact_sha256: string;
+    dispatchAuthorized(input: Readonly<{
+        request: InfinitySandboxDispatchAuthorizationRequestV1;
+        admission: ProviderProductionAdmission;
+    }>): Promise<SandboxesV2ProductionDispatchResult>;
+}
+export declare class InfinitySandboxDispatchAuthorizationService {
+    private readonly ports;
+    constructor(ports: Readonly<Record<InfinityManagedSandboxProviderV1, SandboxesV2AuthorizationPort>>);
+    authorize(value: unknown): Promise<InfinitySandboxDispatchAuthorizationResultV1>;
+}
+/**
+ * Production gate for the injected Sandboxes adapter boundary. Infinity does
+ * not hold provider credentials or contact the provider directly; the selected
+ * adapter may be entered only after the reviewed activation manifest mints an
+ * exact provider/source/evidence admission.
+ */
+export declare class InfinityProductionSandboxDispatchService {
+    #private;
+    constructor(input: Readonly<{
+        activation: Readonly<ProviderActivationState>;
+        runtimeBuildRevision: string;
+        authorizedPrincipal: string;
+        ports: Readonly<Record<InfinityManagedSandboxProviderV1, SandboxesV2ProductionDispatchPort>>;
+    }>);
+    authorize(value: unknown, actorPrincipal: string): Promise<Readonly<InfinityProductionSandboxDispatchResultV1>>;
+}
+export declare function productionDispatchServiceAuthorizesPrincipal(service: InfinityProductionSandboxDispatchService | undefined, actorPrincipal: string): boolean;
+export declare function productionDispatchServiceCanAdmit(service: InfinityProductionSandboxDispatchService | undefined, activation: Readonly<ProviderActivationState>, runtimeBuildRevision: string): boolean;
+export declare function parseSandboxDispatchAuthorizationRequestV1(value: unknown): InfinitySandboxDispatchAuthorizationRequestV1;

package/dist/types/runtime/config.d.ts

@@ -0,0 +1,61 @@
+import type { AuthorityMutationJournalSigner } from "../authority/mutation-journal";
+import type { EffectJournalSigner } from "../authority/effect-journal";
+export interface SelfHostedRuntimeConfig {
+    readonly deploymentMode: "self-hosted";
+    readonly hostname: string;
+    readonly port: number;
+    readonly migrationPolicy: "verify-only";
+    readonly buildRevision: string;
+    readonly operatorPrincipal: string;
+    readonly authorityRestoreDomainId: string;
+    readonly externalJournalId: string;
+    readonly externalJournalRestoreDomainId: string;
+    readonly effectJournalRestoreDomainId: string;
+    readonly mutationSignerPrincipal: string;
+    readonly mutationSigningKeyId: string;
+    readonly effectSignerPrincipal: string;
+    readonly effectSigningKeyId: string;
+    readonly runtimeRole: string;
+    readonly reconcilerRole: string;
+    readonly journalAckerRole: string;
+    readonly externalJournalRole: string;
+    readonly providerActivationManifestFile: string | null;
+    readonly secretFiles: Readonly<{
+        runtimeDatabaseUrl: string;
+        reconcilerDatabaseUrl: string;
+        journalAckerDatabaseUrl: string;
+        externalJournalDatabaseUrl: string;
+        operatorToken: string;
+        mutationSigningKey: string;
+        effectSigningKey: string;
+    }>;
+}
+export interface SelfHostedMigrationConfig {
+    readonly primaryMigratorDatabaseUrlFile: string;
+    readonly externalJournalMigratorDatabaseUrlFile: string;
+    readonly mutationSigningKeyFile: string;
+    readonly externalJournalId: string;
+    readonly externalJournalRestoreDomainId: string;
+    readonly mutationSignerPrincipal: string;
+    readonly mutationSigningKeyId: string;
+    readonly runtimeRole: string;
+    readonly reconcilerRole: string;
+    readonly journalAckerRole: string;
+    readonly externalJournalRole: string;
+}
+export declare function loadSelfHostedMigrationConfig(environment: Readonly<Record<string, string | undefined>>): Readonly<SelfHostedMigrationConfig>;
+export declare function loadSelfHostedRuntimeConfig(environment: Readonly<Record<string, string | undefined>>): Readonly<SelfHostedRuntimeConfig>;
+export declare class FileEd25519Signer implements AuthorityMutationJournalSigner, EffectJournalSigner {
+    readonly signerPrincipal: string;
+    readonly signingKeyId: string;
+    private readonly privateKey;
+    private readonly publicKey;
+    private constructor();
+    static open(path: string, principalInput: string, keyIdInput: string): FileEd25519Signer;
+    publicKeySpki(): string;
+    sign(payload: string): string;
+    verify(payload: string, signature: string): boolean;
+}
+export declare function assertOwnerOnlySecretFile(path: string, label: string): void;
+export declare function readOwnerOnlySecretFile(path: string, label: string): Buffer;
+export declare function readPostgresUrlFile(path: string, label: string): string;

package/dist/types/runtime/postgres.d.ts

@@ -0,0 +1,18 @@
+import { BearerTokenFileAuthenticator } from "../http/bearer-auth";
+import { type SelfHostedRuntimeConfig } from "./config";
+import type { InfinityProductionSandboxDispatchService } from "../providers/sandbox-dispatch";
+export declare function createSelfHostedPostgresRuntime(config: Readonly<SelfHostedRuntimeConfig>, providerDispatch?: InfinityProductionSandboxDispatchService): Promise<{
+    readonly api: import("..").AuthorityApi;
+    readonly authenticator: BearerTokenFileAuthenticator;
+    readonly composition: {
+        readonly authority: import("..").PostgresRunAuthority;
+        readonly accountsOperation: import("..").InfinityAccountsOperationPort | null;
+        readonly accountsScheduler: import("../persistence/postgres-accounts-operation").AccountsSchedulerClaimPort | null;
+        readonly sandboxDispatchAuthority: import("..").SandboxDispatchAuthorityPortV2 | null;
+        readonly reconciler: import("..").PostgresReconciler;
+        readonly mutationJournal: import("..").PostgresMutationJournalCoordinator;
+        readonly api: import("..").AuthorityApi;
+    };
+    readonly readinessProbe: () => Promise<boolean>;
+    readonly close: () => Promise<void>;
+}>;

package/dist/types/runtime/provider-activation.d.ts

@@ -0,0 +1,45 @@
+export declare const INFINITY_PROVIDER_ACTIVATION_SCHEMA_VERSION: "infinity.provider-production-activation/v1";
+export declare const INFINITY_PROVIDER_ACTIVATION_INFINITY_COMMIT: "952dd7a9a646f16fed9653bab170032db61e0353";
+export declare const INFINITY_PROVIDER_ACTIVATION_SANDBOXES_COMMIT: "8b71a53b9b44bbdf0f7a9536d4f2b7bfeaa0edda";
+export declare const INFINITY_PROVIDER_E2B_EVIDENCE_MANIFEST_SHA256: "sha256:e7e68d1c4f48be2d4ea397fe3cfe7969094ece4a69ef1fbc8548d320e65bc298";
+export declare const INFINITY_PROVIDER_DAYTONA_EVIDENCE_MANIFEST_SHA256: "sha256:b2b26f5ef95224efe93885381e57a62f6ca94da20f36f6921b6dcde8e2100f20";
+export declare const INFINITY_PROVIDER_E2B_ADAPTER_ARTIFACT_SHA256: "sha256:ab9e312b7be170a19382028642fa688d7d700d6555b5c04cb4baf6e51c5ebd19";
+export declare const INFINITY_PROVIDER_DAYTONA_ADAPTER_ARTIFACT_SHA256: "sha256:8c3ffa92eb833c4d2fe6f623e056cd96f66af6394f6ac2ad61e01b1570339aad";
+export interface ProviderActivationState {
+    readonly schema_version: typeof INFINITY_PROVIDER_ACTIVATION_SCHEMA_VERSION;
+    readonly infinity_source_commit: typeof INFINITY_PROVIDER_ACTIVATION_INFINITY_COMMIT;
+    readonly sandboxes_source_commit: typeof INFINITY_PROVIDER_ACTIVATION_SANDBOXES_COMMIT;
+    readonly providers: Readonly<{
+        e2b: Readonly<ProviderActivationEntry>;
+        daytona_cloud: Readonly<ProviderActivationEntry>;
+    }>;
+    readonly activation_manifest_sha256: string;
+}
+export interface ProviderActivationEntry {
+    readonly activation_requested: boolean;
+    readonly activation_eligible: boolean;
+    readonly evidence_manifest_sha256: string | null;
+}
+export interface ProviderProductionAdmission {
+    readonly schema_version: "infinity.provider-production-admission/v1";
+    readonly provider: "e2b" | "daytona_cloud";
+    readonly tested_infinity_source_commit: typeof INFINITY_PROVIDER_ACTIVATION_INFINITY_COMMIT;
+    readonly tested_sandboxes_source_commit: typeof INFINITY_PROVIDER_ACTIVATION_SANDBOXES_COMMIT;
+    readonly evidence_manifest_sha256: string;
+    readonly activation_manifest_sha256: string;
+    readonly runtime_build_revision: string;
+    readonly actor_principal: string;
+    readonly dispatch_request_sha256: string;
+    readonly adapter_artifact_sha256: string;
+    readonly admission_sha256: string;
+}
+export declare function defaultProviderActivation(): Readonly<ProviderActivationState>;
+export declare function loadProviderActivationManifest(path: string | null): Readonly<ProviderActivationState>;
+export declare function parseProviderActivationManifest(value: unknown): Readonly<ProviderActivationState>;
+export declare function authorizeProviderProductionAdmission(activation: Readonly<ProviderActivationState>, provider: "e2b" | "daytona_cloud", context: Readonly<{
+    runtime_build_revision: string;
+    actor_principal: string;
+    dispatch_request_sha256: string;
+    adapter_artifact_sha256: string;
+}>): Readonly<ProviderProductionAdmission>;
+export declare function providerActivationHasEligibleProductionProvider(activation: Readonly<ProviderActivationState>): boolean;

package/dist/types/runtime/server.d.ts

@@ -0,0 +1,68 @@
+import type { AuthorityApi, OperatorAuthenticator } from "../http/api";
+import { type InfinityProductionSandboxDispatchService } from "../providers/sandbox-dispatch";
+import { type ProviderActivationState } from "./provider-activation";
+export declare const EMBEDDED_BUILD_REVISION: string | null;
+export interface RuntimeAuditRecord {
+    readonly event: "http_request";
+    readonly timestamp: string;
+    readonly request_id: string;
+    readonly method: string;
+    readonly route: string;
+    readonly status: number;
+    readonly duration_ms: number;
+    readonly authenticated_principal?: string;
+}
+export type RuntimeAuditSink = (record: Readonly<RuntimeAuditRecord>) => void;
+export interface SelfHostedRuntimeReport {
+    readonly schema_version: "infinity.self-hosted-runtime-report/v1";
+    readonly infinity_version: string;
+    readonly build_revision: string;
+    readonly deployment_mode: "self-hosted";
+    readonly operator_schema: string;
+    readonly postgres: Readonly<{
+        source_of_truth: true;
+        startup_migration_policy: "verify-only";
+        migration_manifest_sha256: string;
+    }>;
+    readonly authentication: Readonly<{
+        mode: "bearer-token-file";
+        fail_closed: true;
+    }>;
+    readonly provider_dispatch: Readonly<{
+        production_admission: boolean;
+        live_composed_evidence_required: true;
+        activation: Readonly<ProviderActivationState>;
+    }>;
+    readonly execution: Readonly<{
+        untrusted_code_execution: false;
+        subprocess_capability: false;
+        provider_effect_journal: "disabled-empty-frontier" | "production-adapter-enforced";
+    }>;
+    readonly runtime_report_sha256: string;
+}
+export declare function createRuntimeReport(input: {
+    buildRevision: string;
+    providerActivation?: Readonly<ProviderActivationState>;
+    providerDispatch?: InfinityProductionSandboxDispatchService;
+}): Readonly<SelfHostedRuntimeReport>;
+export declare function assertBuildRevisionMatches(declared: string, embedded: string | null): string;
+export declare function assertPostgresMigrationState(state: readonly {
+    migration_name: string;
+    checksum: string;
+}[]): readonly {
+    migration_name: string;
+    checksum: string;
+}[];
+export declare function createSelfHostedRuntimeHandler(input: {
+    readonly api: AuthorityApi;
+    readonly authenticator: OperatorAuthenticator;
+    readonly report: Readonly<SelfHostedRuntimeReport>;
+    readonly readinessProbe: () => Promise<boolean>;
+    readonly audit: RuntimeAuditSink;
+}): {
+    readonly report: Readonly<SelfHostedRuntimeReport>;
+    readonly markReady: () => void;
+    readonly markNotReady: () => void;
+    readonly beginShutdown: () => void;
+    readonly fetch: (request: Request) => Promise<Response>;
+};

package/dist/types/testing/accounts-fake.d.ts

@@ -0,0 +1,31 @@
+import type { Clock } from "../core/clock";
+import type { AccountsOnlineGenerationContext, AccountsSlotEligibilityPort, AllowedOnlineGenerationCheckReceipt, SlotEligibility, SlotEligibilityRequest } from "../ports/accounts";
+export declare class DeterministicAccountsPort implements AccountsSlotEligibilityPort {
+    private readonly clock;
+    unavailable: boolean;
+    denyGeneration: number;
+    issuedAtOffsetMs: number;
+    lifetimeMs: number;
+    maxConcurrency: number;
+    capacityGeneration: number;
+    credentialGeneration: number;
+    nativeSession: boolean;
+    effectNamespaceId: string;
+    providerAccountId: string;
+    capacityPoolId: string;
+    serializationKey: string;
+    ownerRef: string;
+    capsuleAttestedAtOffsetMs: number;
+    capsuleAttestationLifetimeMs: number;
+    lastEligibilityRequest: SlotEligibilityRequest | null;
+    lastOnlineContext: AccountsOnlineGenerationContext | null;
+    onlineChecks: number;
+    onlineReceiptMutator: ((receipt: AllowedOnlineGenerationCheckReceipt) => unknown) | null;
+    afterOnlineReceipt: (() => void) | null;
+    constructor(clock: Clock);
+    getSlotEligibility(request: SlotEligibilityRequest): Promise<SlotEligibility>;
+    checkOnlineGeneration(request: {
+        readonly expectedSlotEligibility: SlotEligibility;
+        readonly context: AccountsOnlineGenerationContext;
+    }): Promise<AllowedOnlineGenerationCheckReceipt>;
+}

package/dist/types/testing/fakes.d.ts

@@ -0,0 +1,2 @@
+export { DeterministicAccountsPort } from "./accounts-fake";
+export { DeterministicSandboxesPort } from "./sandboxes-fake";

package/dist/types/testing/node-control-plane-fake.d.ts

@@ -0,0 +1,20 @@
+import { type KeyObject } from "node:crypto";
+import { type NodeAgentCommandCore, type NodeAgentHeartbeat, type NodeAgentReceipt, type NodeAgentRegistration, type NodeAgentTransportPolicy, type NodeControlPlaneSession, type NodeControlPlaneTransport, type SignedNodeAgentCommand } from "../node-agent/contracts";
+/** Deterministic in-process protocol peer; it opens no socket and is suitable for contract tests. */
+export declare class InProcessNodeControlPlane implements NodeControlPlaneTransport {
+    #private;
+    readonly registrations: NodeAgentRegistration[];
+    readonly heartbeats: NodeAgentHeartbeat[];
+    readonly receipts: NodeAgentReceipt[];
+    presentedServerSpkiSha256: string;
+    constructor(input: Readonly<{
+        transport_policy: NodeAgentTransportPolicy;
+        command_private_key: KeyObject;
+    }>);
+    sign(value: NodeAgentCommandCore): SignedNodeAgentCommand;
+    enqueue(command: SignedNodeAgentCommand): void;
+    connect(input: Readonly<{
+        transport_policy: NodeAgentTransportPolicy;
+        registration: NodeAgentRegistration;
+    }>): Promise<NodeControlPlaneSession>;
+}

package/dist/types/testing/reference.d.ts

@@ -0,0 +1,27 @@
+import { InMemoryRunAuthority } from "../authority/authority";
+import { DeterministicFaultInjector, InMemoryAuthorityStore } from "../authority/store";
+import { FakeClock } from "../core/clock";
+import { DeterministicIdFactory } from "../core/ids";
+import { DeterministicAccountsPort } from "./accounts-fake";
+import { Ed25519AuthorityMutationJournalVerifier, InMemoryAuthorityMutationJournal } from "../authority/mutation-journal";
+import { Ed25519AccountsOperationEvidenceSigner, InMemoryAccountsOperationSignerHistory } from "../ports/accounts-operation";
+export declare const TEST_ACCOUNTS_ELIGIBILITY_REQUEST: Readonly<{
+    schema_version: "accounts.eligibility-request.v1";
+    account_lane_id: "0198a0a0-0000-7000-8000-000000000002";
+    data_classification: "internal";
+    destination_policy_class: "managed_isolated";
+    model: "provider-model-1";
+    operation: "generate";
+}>;
+export declare function createReferenceAuthority(): {
+    authority: InMemoryRunAuthority;
+    clock: FakeClock;
+    ids: DeterministicIdFactory;
+    faults: DeterministicFaultInjector;
+    store: InMemoryAuthorityStore;
+    accounts: DeterministicAccountsPort;
+    accountsOperationSigner: Ed25519AccountsOperationEvidenceSigner;
+    accountsOperationSignerHistory: InMemoryAccountsOperationSignerHistory;
+    mutationJournal: InMemoryAuthorityMutationJournal;
+    mutationJournalVerifier: Ed25519AuthorityMutationJournalVerifier;
+};

package/dist/types/testing/sandboxes-fake.d.ts

@@ -0,0 +1,22 @@
+import { type AuthenticatedFenceContext, type BrokerFence } from "../contracts/fence";
+import type { ActivateSandboxRequest, CreateInertSandboxRequest, DestroySandboxRequest, SandboxAbsenceReceipt, SandboxHandle, SandboxesPort } from "../ports/sandboxes";
+export declare class DeterministicSandboxesPort implements SandboxesPort {
+    readonly calls: string[];
+    private readonly resources;
+    private readonly currentFences;
+    private readonly cleanupGrants;
+    private readonly creations;
+    private readonly activations;
+    private readonly destructions;
+    registerCurrentFence(fence: BrokerFence): void;
+    registerCleanupGrant(operationIdInput: string, cleanupGrantDigestInput: string): void;
+    createInert(request: CreateInertSandboxRequest, authenticated: AuthenticatedFenceContext): Promise<SandboxHandle>;
+    activate(request: ActivateSandboxRequest, authenticated: AuthenticatedFenceContext): Promise<{
+        activation_receipt_digest: string;
+    }>;
+    describe(handle: SandboxHandle): Promise<"inert" | "active" | "absent" | "unknown">;
+    destroy(request: DestroySandboxRequest, authenticated: AuthenticatedFenceContext): Promise<SandboxAbsenceReceipt>;
+    private requireAuthorized;
+    private requireExactHandle;
+    private handlesEqual;
+}