@hasna/infinity 0.1.0

package/dist/types/node-agent/contracts.d.ts

@@ -0,0 +1,119 @@
+import type { KeyObject } from "node:crypto";
+import { type AuthCapsuleDescriptor, type CapsuleRemoteToolBinding } from "../authcapsules/codewith-local";
+import { type InfinityAgentPolicy } from "../authcapsules/infinity-agent-policy";
+import { type SubscriptionCapsuleAttestation } from "../authcapsules/os-isolated-runner";
+export declare const NODE_AGENT_COMMAND_SCHEMA_VERSION: "infinity.node-agent-command.v1";
+export declare const NODE_AGENT_REGISTRATION_SCHEMA_VERSION: "infinity.node-agent-registration.v1";
+export declare const NODE_AGENT_HEARTBEAT_SCHEMA_VERSION: "infinity.node-agent-heartbeat.v1";
+export declare const NODE_AGENT_RECEIPT_SCHEMA_VERSION: "infinity.node-agent-receipt.v1";
+export declare const MAX_NODE_AGENT_COMMAND_LIFETIME_MS: number;
+export interface NodeAgentTransportPolicy {
+    readonly endpoint_origin: string;
+    readonly server_spki_sha256: string;
+    readonly client_certificate_ref: string;
+    readonly client_private_key_ref: string;
+    readonly command_signing_key_id: string;
+    readonly command_signing_key_thumbprint: string;
+}
+export interface NodeAgentLaunchPayload {
+    readonly schema_version: "infinity.node-agent-launch.v1";
+    readonly credential_transport: "none";
+    readonly repository_transport: "none";
+    readonly descriptor: AuthCapsuleDescriptor;
+    readonly binding: CapsuleRemoteToolBinding;
+    readonly policy: InfinityAgentPolicy;
+    readonly prompt: string;
+}
+export interface NodeAgentRevokePayload {
+    readonly schema_version: "infinity.node-agent-revoke.v1";
+    readonly credential_transport: "none";
+    readonly repository_transport: "none";
+    readonly reason_code: string;
+}
+export type NodeAgentCommandPayload = NodeAgentLaunchPayload | NodeAgentRevokePayload;
+export interface NodeAgentCommandCore {
+    readonly schema_version: typeof NODE_AGENT_COMMAND_SCHEMA_VERSION;
+    readonly command_id: string;
+    readonly sequence: string;
+    readonly kind: "launch" | "revoke";
+    readonly canonical_node_id: string;
+    readonly node_generation: string;
+    readonly owner_ref: string;
+    readonly capsule_id: string;
+    readonly placement_generation: string;
+    readonly auth_generation: string;
+    readonly lease_id: string;
+    readonly lease_epoch: string;
+    readonly issued_at: string;
+    readonly expires_at: string;
+    readonly payload_sha256: string;
+    readonly payload: NodeAgentCommandPayload;
+    readonly signer_key_id: string;
+}
+export interface SignedNodeAgentCommand extends NodeAgentCommandCore {
+    readonly signature_base64url: string;
+}
+export interface NodeAgentRegistration {
+    readonly schema_version: typeof NODE_AGENT_REGISTRATION_SCHEMA_VERSION;
+    readonly registration_nonce: string;
+    readonly canonical_node_id: string;
+    readonly node_key_thumbprint: string;
+    readonly node_generation: string;
+    readonly agent_version: string;
+    readonly agent_started_at: string;
+    readonly capabilities: readonly ["auth-capsule.launch", "auth-capsule.revoke"];
+    readonly outbound_only: true;
+    readonly credential_transport: "none";
+    readonly repository_transport: "none";
+    readonly capsules: readonly SubscriptionCapsuleAttestation[];
+}
+export interface NodeAgentHeartbeat {
+    readonly schema_version: typeof NODE_AGENT_HEARTBEAT_SCHEMA_VERSION;
+    readonly session_id: string;
+    readonly canonical_node_id: string;
+    readonly node_generation: string;
+    readonly observed_at: string;
+    readonly last_command_sequence: string;
+    readonly capsules: readonly SubscriptionCapsuleAttestation[];
+}
+export interface NodeAgentReceipt {
+    readonly schema_version: typeof NODE_AGENT_RECEIPT_SCHEMA_VERSION;
+    readonly session_id: string;
+    readonly command_id: string;
+    readonly command_sha256: string;
+    readonly canonical_node_id: string;
+    readonly capsule_id: string;
+    readonly lease_epoch: string;
+    readonly outcome: "succeeded" | "failed";
+    readonly reconciled: boolean;
+    readonly exit_code?: number;
+    readonly result_sha256?: string;
+    readonly completed_at: string;
+}
+export interface NodeControlPlanePeerEvidence {
+    readonly session_id: string;
+    readonly mutual_tls: true;
+    readonly server_spki_sha256: string;
+    readonly command_signing_key_id: string;
+    readonly command_signing_key_thumbprint: string;
+}
+export interface NodeControlPlaneSession {
+    readonly peer: NodeControlPlanePeerEvidence;
+    heartbeat(value: NodeAgentHeartbeat): Promise<void>;
+    nextCommand(): Promise<unknown | undefined>;
+    receipt(value: NodeAgentReceipt): Promise<void>;
+    close(): Promise<void>;
+}
+/** Implementations may only originate a connection to endpoint_origin; no inbound listener is part of this port. */
+export interface NodeControlPlaneTransport {
+    connect(input: Readonly<{
+        transport_policy: NodeAgentTransportPolicy;
+        registration: NodeAgentRegistration;
+    }>): Promise<NodeControlPlaneSession>;
+}
+export declare function parseNodeAgentTransportPolicy(value: unknown): NodeAgentTransportPolicy;
+export declare function parseNodeAgentCommandCore(value: unknown): NodeAgentCommandCore;
+export declare function parseSignedNodeAgentCommand(value: unknown): SignedNodeAgentCommand;
+export declare function nodeAgentCommandSigningBytes(command: NodeAgentCommandCore): Uint8Array;
+export declare function nodeAgentCommandDigest(command: SignedNodeAgentCommand): string;
+export type NodeCommandPublicKey = KeyObject;

package/dist/types/node-agent/macos-service.d.ts

@@ -0,0 +1,33 @@
+export declare const INFINITY_AGENT_LAUNCHD_LABEL: "com.hasna.infinity-agent";
+export interface MacOsLaunchdOptions {
+    readonly scope: "user" | "system";
+    readonly program_path: string;
+    readonly config_path: string;
+    readonly stdout_path: string;
+    readonly stderr_path: string;
+}
+export interface MacOsLaunchdHostPort {
+    writeAtomic(path: string, contents: string, mode: number): Promise<void>;
+    remove(path: string): Promise<void>;
+    launchctl(args: readonly string[]): Promise<Readonly<{
+        exit_code: number;
+        stdout: string;
+        stderr: string;
+    }>>;
+}
+export interface MacOsServiceStatus {
+    readonly installed: boolean;
+    readonly running: boolean;
+    readonly details: string;
+}
+export declare function renderMacOsLaunchdPlist(options: MacOsLaunchdOptions): string;
+export declare class MacOsLaunchdService {
+    #private;
+    constructor(host: MacOsLaunchdHostPort, environment: Readonly<{
+        home_directory: string;
+        uid: number;
+    }>);
+    install(options: MacOsLaunchdOptions): Promise<void>;
+    status(scope: "user" | "system"): Promise<MacOsServiceStatus>;
+    uninstall(scope: "user" | "system"): Promise<void>;
+}

package/dist/types/node-agent/service-cli.d.ts

@@ -0,0 +1,26 @@
+import type { MacOsLaunchdOptions, MacOsServiceStatus } from "./macos-service";
+import type { MacOsLaunchdService } from "./macos-service";
+import type { NodeAgentDaemon } from "./agent";
+export interface NodeAgentServiceCliRuntime {
+    /** Runs a fully composed NodeAgentDaemon until its process signal is aborted. */
+    run(): Promise<void>;
+    install(options: MacOsLaunchdOptions): Promise<void>;
+    status(scope: "user" | "system"): Promise<MacOsServiceStatus>;
+    uninstall(scope: "user" | "system"): Promise<void>;
+    writeStdout(value: string): void;
+}
+export declare class ComposedNodeAgentServiceCliRuntime implements NodeAgentServiceCliRuntime {
+    #private;
+    constructor(input: Readonly<{
+        daemon: Pick<NodeAgentDaemon, "run">;
+        launchd: Pick<MacOsLaunchdService, "install" | "status" | "uninstall">;
+        signal: AbortSignal;
+        write_stdout: (value: string) => void;
+    }>);
+    run(): Promise<void>;
+    install(options: MacOsLaunchdOptions): Promise<void>;
+    status(scope: "user" | "system"): Promise<MacOsServiceStatus>;
+    uninstall(scope: "user" | "system"): Promise<void>;
+    writeStdout(value: string): void;
+}
+export declare function runNodeAgentServiceCli(argv: readonly string[], runtime: NodeAgentServiceCliRuntime): Promise<number>;

package/dist/types/persistence/composition.d.ts

@@ -0,0 +1,49 @@
+import type { SQL } from "bun";
+import { PostgresRunAuthority } from "./postgres-authority";
+import { PostgresReconciler, type EffectJournalAnchorVerifier } from "./postgres-reconciler";
+import { type OperatorAuthenticator } from "../http/api";
+import type { Clock } from "../core/clock";
+import type { IdFactory } from "../core/ids";
+import { type AuthorityMutationJournalSigner, type AuthorityMutationJournalPort, type AuthorityMutationJournalReceiptVerifier } from "../authority/mutation-journal";
+import type { EffectJournalPort } from "../authority/effect-journal";
+import { PostgresMutationJournalCoordinator } from "./postgres-mutation-journal";
+import type { InfinityAccountsOperationPort, InMemoryAccountsOperationSignerHistory } from "../ports/accounts-operation";
+import type { AccountsSlotEligibilityPort } from "../ports/accounts";
+import { type AccountsSchedulerClaimPort } from "./postgres-accounts-operation";
+import type { InfinityProductionSandboxDispatchService } from "../providers/sandbox-dispatch";
+export declare function createPostgresAuthorityComposition(input: {
+    runtimeSql: SQL;
+    reconcilerSql: SQL;
+    journalAckerSql: SQL;
+    clock: Clock;
+    ids: IdFactory;
+    authenticator: OperatorAuthenticator;
+    mutationJournal?: AuthorityMutationJournalPort;
+    mutationJournalVerifier?: AuthorityMutationJournalReceiptVerifier;
+    externalJournalDatabase?: {
+        readonly sql: SQL;
+        readonly signer: AuthorityMutationJournalSigner;
+        readonly verifier: AuthorityMutationJournalReceiptVerifier;
+        readonly journalId: string;
+        readonly restoreDomainId: string;
+        readonly encryptedAtRest: true;
+        readonly requiredRole?: string;
+    };
+    authorityRestoreDomainId: string;
+    effectJournal: EffectJournalPort;
+    effectVerifier: EffectJournalAnchorVerifier;
+    runtimeRole?: string;
+    reconcilerRole?: string;
+    journalAckerRole?: string;
+    accountsOperationSignerHistory?: InMemoryAccountsOperationSignerHistory;
+    accounts?: AccountsSlotEligibilityPort;
+    productionSandboxDispatch?: InfinityProductionSandboxDispatchService;
+}): Promise<{
+    readonly authority: PostgresRunAuthority;
+    readonly accountsOperation: InfinityAccountsOperationPort | null;
+    readonly accountsScheduler: AccountsSchedulerClaimPort | null;
+    readonly sandboxDispatchAuthority: import("..").SandboxDispatchAuthorityPortV2 | null;
+    readonly reconciler: PostgresReconciler;
+    readonly mutationJournal: PostgresMutationJournalCoordinator;
+    readonly api: import("..").AuthorityApi;
+}>;

package/dist/types/persistence/migrate-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/types/persistence/migrations.d.ts

@@ -0,0 +1,30 @@
+import type { SQL } from "bun";
+export interface MigrationResult {
+    readonly applied: readonly string[];
+    readonly alreadyApplied: readonly string[];
+}
+export interface PostgresRoleNames {
+    readonly runtimeRole: string;
+    readonly reconcilerRole: string;
+    readonly journalAckerRole: string;
+}
+export declare const DEFAULT_POSTGRES_ROLES: PostgresRoleNames;
+export declare const POSTGRES_MIGRATION_MANIFEST: Readonly<{
+    readonly "0001_authority.sql": "sha256:bfcff16873cf8664ee46aeea581f9f4d212bac05cf3bbc1817dc495434f7f1d6";
+    readonly "0002_effect_step_global_owner.sql": "sha256:3342801f79c4cf6321bbeaa3928cf7a0d4a3e9a391505274e88931c48eb4632d";
+    readonly "0003_effect_journal_observed_head.sql": "sha256:0cf5388c8665f9727df4f1f7430761086bd2fa03d0e1e2aaddecda9ca7790aba";
+    readonly "0004_authority_mutation_journal_binding.sql": "sha256:ddeb4d190016536f61ea55e3e0c36a5fa28211af5ed2c9a41c752ce3b1a857d0";
+    readonly "20260710_checkpoint_broker_v1.sql": "sha256:3e250bee6358188cf30acb2ab14f31edfdf94c2b73502793b91a7caaf28c3d8f";
+    readonly "20260711_checkpoint_trust_v2.sql": "sha256:5165e08ae32b671838a2ee9349b35cf7007afade70ec19694ad27334bdaac065";
+    readonly "20260711_verifier_cleanup_v2.sql": "sha256:fe06ed0ec0bde18310321e7cce19c885f127e550ac1ea365b159be4effb71e79";
+    readonly "20260711_accounts_operation_v1.sql": "sha256:7d9caa3aa9fbbdab501e81b363ec5258b006a86572211eccb563b000d52d3a62";
+    readonly "20260711_z_accounts_claim_authority_v2.sql": "sha256:1da1ace609a4813472f2637d61b435cf372bd9d0f66694b3c502e17da3b9de38";
+    readonly "20260711_zz_sandbox_dispatch_authority_v1.sql": "sha256:543bb2c9b392c98c2069c437616e3d7d0fbf1d02cb8d1f6e09f1bad83238e69f";
+    readonly "20260712_sandbox_dispatch_authority_v2.sql": "sha256:c93b5b31d4f94549018300c94a568a4b8b5a403f28bf04d6177d14726518b3e3";
+}>;
+export declare function applyPostgresMigrations(sql: SQL, directory?: string): Promise<MigrationResult>;
+export declare function configurePostgresRoles(sql: SQL, roles?: PostgresRoleNames): Promise<void>;
+export declare function readMigrationState(sql: SQL): Promise<readonly {
+    migration_name: string;
+    checksum: string;
+}[]>;

package/dist/types/persistence/postgres-accounts-operation.d.ts

@@ -0,0 +1,26 @@
+import type { SQL } from "bun";
+import type { IdFactory } from "../core/ids";
+import { InMemoryAccountsOperationSignerHistory, type InfinityAccountsOperationRecoveryPort } from "../ports/accounts-operation";
+import { type AccountsSlotEligibilityPort } from "../ports/accounts";
+import type { ClaimAttemptInput, ClaimAttemptResult } from "../authority/authority";
+import { type PostgresMutationJournalCoordinator } from "./postgres-mutation-journal";
+/**
+ * PostgreSQL production authority for Accounts model-call evidence. Exact signed
+ * bytes are generated and verified by the shared local authority engine, while
+ * this adapter supplies durable SERIALIZABLE CAS, restart reconstruction, and
+ * the external authority mutation-journal boundary.
+ */
+export interface AccountsSchedulerClaimPort {
+    claimNextAttempt(input: ClaimAttemptInput): Promise<ClaimAttemptResult | null>;
+}
+export interface PostgresAccountsAuthorityFacade {
+    readonly scheduler: AccountsSchedulerClaimPort;
+    readonly operation: InfinityAccountsOperationRecoveryPort;
+}
+export declare function createPostgresAccountsAuthority(input: {
+    readonly sql: SQL;
+    readonly signerHistory: InMemoryAccountsOperationSignerHistory;
+    readonly mutationJournal: PostgresMutationJournalCoordinator;
+    readonly accounts: AccountsSlotEligibilityPort;
+    readonly ids: IdFactory;
+}): Promise<PostgresAccountsAuthorityFacade>;

package/dist/types/persistence/postgres-authority.d.ts

@@ -0,0 +1,69 @@
+import type { SQL } from "bun";
+import type { CapabilityProjection, PublicRunMutationContext, RunEventPage, RunMutationResult, RunWaitProjection, SubmitRunContext, SubmitRunResult } from "../authority/authority";
+import type { AttemptRecord, RunRecord } from "../contracts/dtos";
+import type { Clock } from "../core/clock";
+import type { IdFactory } from "../core/ids";
+import { type Int64 } from "../core/int64";
+import { type RunSpec } from "../contracts/runspec";
+import { type PostgresMutationJournalCoordinator } from "./postgres-mutation-journal";
+export declare class PostgresRunAuthority {
+    private readonly sql;
+    private readonly clock;
+    private readonly ids;
+    private readonly mutationJournal;
+    constructor(sql: SQL, clock: Clock, ids: IdFactory, mutationJournal: PostgresMutationJournalCoordinator);
+    snapshot(): Promise<{
+        authority_epoch: Int64;
+    }>;
+    validateRunSpec(input: unknown): Promise<{
+        valid: true;
+        authority_epoch: Int64;
+        run_spec: RunSpec;
+        run_spec_digest: string;
+    }>;
+    planRun(input: unknown): Promise<{
+        authority_epoch: Int64;
+        run_spec: RunSpec;
+        run_spec_digest: string;
+        budget_ceiling_minor_units: number;
+        required_approvals: string[];
+        denials: string[];
+    }>;
+    listCapabilities(actorPrincipalInput: string): Promise<CapabilityProjection>;
+    submitRun(specInput: unknown, context: SubmitRunContext): Promise<SubmitRunResult>;
+    getRun(runIdInput: string, actorPrincipalInput: string): Promise<{
+        run: RunRecord;
+        attempt: AttemptRecord;
+        run_spec: RunSpec;
+    }>;
+    listRuns(actorPrincipalInput: string, options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        items: Array<{
+            run: RunRecord;
+            attempt: AttemptRecord;
+            run_spec: RunSpec;
+        }>;
+        next_cursor: string | null;
+    }>;
+    waitRun(runIdInput: string, actorPrincipalInput: string, timeoutMsInput: number): Promise<RunWaitProjection>;
+    readRunEvents(runIdInput: string, actorPrincipalInput: string, options: {
+        cursor: string;
+        limit: number;
+        waitMs: number;
+    }): Promise<RunEventPage>;
+    cancelRun(runIdInput: string, context: PublicRunMutationContext & {
+        reasonCode: string;
+    }): Promise<RunMutationResult>;
+    retryRun(runIdInput: string, context: PublicRunMutationContext): Promise<RunMutationResult>;
+    resolveOperation(operationIdInput: string, actorPrincipalInput: string): Promise<Record<string, unknown>>;
+    private currentAuthorityEpoch;
+    private lockRuntimeMeta;
+    private prepareMutation;
+    private recordMutation;
+    private persistMutationEnvelope;
+    private appendRunEvent;
+    private databaseTime;
+}
+export declare function runSerializableMutation<T>(operation: () => Promise<T>, attempts?: number): Promise<T>;

package/dist/types/persistence/postgres-external-mutation-journal.d.ts

@@ -0,0 +1,22 @@
+import type { SQL } from "bun";
+import { type AuthorityMutationJournalPort, type AuthorityMutationJournalProtection, type AuthorityMutationJournalReceiptVerifier, type AuthorityMutationJournalSigner } from "../authority/mutation-journal";
+export declare const POSTGRES_EXTERNAL_MUTATION_JOURNAL_MIGRATION_MANIFEST: Readonly<{
+    readonly "0001_external_authority_mutation_journal.sql": "sha256:ead2509a00dc767b855711be54f7480eaa09e0928cd16b1b86dc5a79b57c9b52";
+}>;
+export interface PostgresExternalMutationJournalOptions {
+    readonly signer: AuthorityMutationJournalSigner;
+    readonly verifier: AuthorityMutationJournalReceiptVerifier;
+    readonly journalId: string;
+    readonly restoreDomainId: string;
+    readonly encryptedAtRest: true;
+    readonly requiredRole?: string;
+}
+export interface PostgresExternalMutationJournalMigrationResult {
+    readonly applied: readonly string[];
+    readonly alreadyApplied: readonly string[];
+}
+export declare function createPostgresExternalMutationJournal(sql: SQL, options: PostgresExternalMutationJournalOptions): Promise<AuthorityMutationJournalPort>;
+export declare function initializePostgresExternalMutationJournalStore(primarySql: SQL, journalSql: SQL, options: Omit<PostgresExternalMutationJournalOptions, "requiredRole">): Promise<Readonly<AuthorityMutationJournalProtection>>;
+export declare function applyPostgresExternalMutationJournalMigrations(sql: SQL, directory?: string): Promise<PostgresExternalMutationJournalMigrationResult>;
+export declare function configurePostgresExternalMutationJournalRole(sql: SQL, roleName?: string): Promise<void>;
+export declare function assertPostgresExternalMutationJournalDatabaseSeparated(primarySql: SQL, journalSql: SQL): Promise<void>;

package/dist/types/persistence/postgres-json.d.ts

@@ -0,0 +1 @@
+export declare function parsePostgresJsonText(value: unknown, label: string): unknown;

package/dist/types/persistence/postgres-mutation-journal.d.ts

@@ -0,0 +1,31 @@
+import type { SQL } from "bun";
+import { type AuthorityMutationAppendReceipt, type AuthorityMutationJournalPort, type AuthorityMutationJournalProtection, type AuthorityMutationJournalReceiptVerifier } from "../authority/mutation-journal";
+import { type Int64 } from "../core/int64";
+export declare const MAX_V1_MUTATION_JOURNAL_STARTUP_RECORDS = 10000n;
+export declare class PostgresMutationJournalCoordinator {
+    private readonly readSql;
+    private readonly acknowledgementSql;
+    private readonly journal;
+    private readonly verifier;
+    private readonly authorityRestoreDomainId;
+    private initialized;
+    private readonly expectedProtection;
+    constructor(readSql: SQL, acknowledgementSql: SQL, journal: AuthorityMutationJournalPort, verifier: AuthorityMutationJournalReceiptVerifier, authorityRestoreDomainId: string, expectedProtectionInput: Readonly<AuthorityMutationJournalProtection>);
+    initialize(): Promise<void>;
+    private assertExpectedProtection;
+    private guardedJournalCall;
+    private assertExpectedAcknowledgement;
+    private verifyExpectedAcknowledgementValue;
+    private readJournalHead;
+    private readJournalRange;
+    private appendJournalEnvelope;
+    private readExternalAcknowledgedPrefix;
+    private readLocalJournalSnapshot;
+    ensureAcknowledged(commitSequenceInput: Int64): Promise<Readonly<AuthorityMutationAppendReceipt>>;
+    verifyAcknowledgedMembership(commitSequenceInput: Int64, expectedEnvelopeInput: unknown): Promise<Readonly<AuthorityMutationAppendReceipt>>;
+    private readLocalMembershipSnapshot;
+    reconcilePending(limitInput?: number): Promise<number>;
+    verifyReady(): Promise<void>;
+    private requireInitialized;
+}
+export declare function runSerializableAcknowledgement<T>(operation: () => Promise<T>, attempts?: number): Promise<T>;

package/dist/types/persistence/postgres-reconciler.d.ts

@@ -0,0 +1,34 @@
+import type { SQL } from "bun";
+import { type EffectJournalPort, type EffectJournalReceiptVerifier, type StoredEffectJournalRecord } from "../authority/effect-journal";
+import { type Int64 } from "../core/int64";
+export declare const MAX_V1_EFFECT_JOURNAL_STARTUP_RECORDS = 10000n;
+export type EffectJournalAnchorVerifier = EffectJournalReceiptVerifier;
+export interface LeasedOutboxRecord {
+    id: string;
+    event_id: string;
+    payload_digest: string;
+    authority_commit_sequence: Int64;
+    event_record: unknown;
+    lease_expires_at: string;
+}
+export declare class PostgresReconciler {
+    private readonly sql;
+    private readonly effectJournal;
+    private readonly effectVerifier;
+    private readonly authorityRestoreDomainId;
+    private effectProtection;
+    constructor(sql: SQL, effectJournal: EffectJournalPort, effectVerifier: EffectJournalAnchorVerifier, authorityRestoreDomainId: string);
+    leaseOutbox(ownerInput: string, leaseDurationMs: number, limit?: number): Promise<readonly LeasedOutboxRecord[]>;
+    markOutboxDelivered(idInput: string, ownerInput: string): Promise<void>;
+    recoverExpiredOutboxLeases(): Promise<number>;
+    appendEffectAnchor(stepInput: unknown, anchorInput: unknown): Promise<Readonly<StoredEffectJournalRecord>>;
+    verifyEffectFrontier(): Promise<{
+        journal_sequence: Int64;
+        frontier_digest: string | null;
+    }>;
+    private pinVerifiedExternalHighWater;
+    private readAndVerifyLocalEffectFrontier;
+    private verifyExternalHead;
+    private readExternalPrefix;
+    private verifyExternalAnchorMembership;
+}

package/dist/types/persistence/postgres-sandbox-dispatch-authority.d.ts

@@ -0,0 +1,9 @@
+import type { SQL } from "bun";
+import { type InMemoryAccountsOperationSignerHistory } from "../ports/accounts-operation";
+import { type SandboxDispatchAuthorityPortV2 } from "../ports/sandbox-dispatch-authority";
+import { type PostgresMutationJournalCoordinator } from "./postgres-mutation-journal";
+export declare function createPostgresSandboxDispatchAuthorityV2(input: Readonly<{
+    sql: SQL;
+    signerHistory: InMemoryAccountsOperationSignerHistory;
+    mutationJournal: PostgresMutationJournalCoordinator;
+}>): SandboxDispatchAuthorityPortV2;

package/dist/types/persistence/self-hosted-migrate-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export declare function runSelfHostedMigrations(environment?: NodeJS.ProcessEnv): Promise<void>;