@hasna/infinity 0.1.0

package/dist/types/golden/disposable-task.d.ts

@@ -0,0 +1,108 @@
+import type { InfinityAccountsOperationRecoveryPort, VerifiedConsumeBoundOperation } from "../ports/accounts-operation";
+import { type SandboxDispatchAuthorityPortV2 } from "../ports/sandbox-dispatch-authority";
+export type GoldenDigestV1 = `sha256:${string}`;
+export declare const GOLDEN_SOURCE_PIN_SET_SHA256: GoldenDigestV1;
+export interface GoldenDisposableTaskRequestV1 {
+    readonly schema_version: "infinity.golden-disposable-task-request/v1";
+    readonly invocation_nonce_sha256: GoldenDigestV1;
+    readonly task_invocation_sha256: GoldenDigestV1;
+    readonly authority_binding_sha256: GoldenDigestV1;
+    readonly prepared_anchor_sha256: GoldenDigestV1;
+    readonly consume_request_sha256: GoldenDigestV1;
+    readonly source_pin_set_sha256: typeof GOLDEN_SOURCE_PIN_SET_SHA256;
+    readonly environment_sha256: GoldenDigestV1;
+    readonly checkpoint_policy_sha256: GoldenDigestV1;
+}
+export interface GoldenAccountsConsumeResultV1 {
+    readonly receiptBytes: Uint8Array;
+    readonly replayed: boolean;
+    readonly bindingCurrent: boolean;
+    readonly consumeReceiptDigest: GoldenDigestV1;
+    readonly tombstoneBytes: Uint8Array;
+    readonly tombstoneDigest: GoldenDigestV1;
+    readonly useId: GoldenDigestV1;
+    readonly consumeBound?: VerifiedConsumeBoundOperation;
+}
+export interface GoldenAccountsConsumePortV1 {
+    consume(input: unknown): Promise<GoldenAccountsConsumeResultV1>;
+}
+export interface GoldenAccountsConsumeInputV1 {
+    readonly consumeRequestBytes: Uint8Array;
+    readonly [key: string]: unknown;
+}
+export interface TrustedGoldenAccountsConsumeEvidenceV1 {
+    readonly schema_version: "infinity.trusted-accounts-consume-evidence.v1";
+    readonly model_operation_id: string;
+    readonly consume_receipt_sha256: GoldenDigestV1;
+    readonly consume_tombstone_sha256: GoldenDigestV1;
+    readonly consume_use_id_sha256: GoldenDigestV1;
+    readonly consume_binding_sha256: GoldenDigestV1;
+    readonly receipt_bytes_sha256: GoldenDigestV1;
+    readonly tombstone_bytes_sha256: GoldenDigestV1;
+}
+interface AuthorizedGoldenTaskEvidenceV1 {
+    readonly prepared_anchor_sha256: GoldenDigestV1;
+    readonly consume_receipt_sha256: GoldenDigestV1;
+    readonly consume_binding_sha256: GoldenDigestV1;
+}
+export interface InfinityDisposableTaskAuthorityPortV1 {
+    authorize(request: GoldenDisposableTaskRequestV1): Promise<AuthorizedGoldenTaskEvidenceV1>;
+}
+export declare function createInfinityDisposableTaskAuthorityPortV1(input: Readonly<{
+    accounts: GoldenAccountsConsumePortV1;
+    accountsConsumeInput: GoldenAccountsConsumeInputV1;
+    infinity: Pick<InfinityAccountsOperationRecoveryPort, "readConsumeBoundOperation" | "assertPreparedOpenCurrent" | "bindCapabilityUse" | "assertConsumeBoundCurrent">;
+    prepared: VerifiedConsumeBoundOperation["prepared"];
+    accountsEvidenceBinding: Readonly<{
+        port: Pick<SandboxDispatchAuthorityPortV2, "bindAccountsConsumeEvidence">;
+        bindOperationId: string;
+        idempotencyKey: string;
+    }>;
+}>): InfinityDisposableTaskAuthorityPortV1;
+export declare function assertTrustedGoldenAccountsConsumeEvidenceV1(value: object): TrustedGoldenAccountsConsumeEvidenceV1;
+export interface GoldenSandboxTaskRequestV1 {
+    readonly schema_version: "sandboxes.disposable-task-request/v1";
+    readonly invocation_nonce_sha256: GoldenDigestV1;
+    readonly authority_envelope_sha256: GoldenDigestV1;
+    readonly source_manifest_sha256: GoldenDigestV1;
+    readonly input_manifest_sha256: GoldenDigestV1;
+}
+export interface GoldenSandboxTaskReceiptV1 {
+    readonly schema_version: "sandboxes.disposable-task-receipt/v1";
+    readonly request_sha256: GoldenDigestV1;
+    readonly authority_envelope_sha256: GoldenDigestV1;
+    readonly source_manifest_sha256: GoldenDigestV1;
+    readonly input_manifest_sha256: GoldenDigestV1;
+    readonly task_result_sha256: GoldenDigestV1;
+    readonly checkpoint_handoff_sha256: GoldenDigestV1;
+    readonly absence_evidence_sha256: GoldenDigestV1;
+    readonly destroyed: true;
+    readonly absent_by_get: true;
+    readonly absent_by_list: true;
+    readonly replayed: boolean;
+}
+export interface GoldenDisposableSandboxTaskPortV1 {
+    runDisposableTask(request: GoldenSandboxTaskRequestV1): Promise<GoldenSandboxTaskReceiptV1>;
+}
+export interface GoldenDisposableTaskReceiptV1 {
+    readonly schema_version: "infinity.golden-disposable-task-receipt/v1";
+    readonly source_pin_set_sha256: GoldenDigestV1;
+    readonly authority_binding_sha256: GoldenDigestV1;
+    readonly prepared_anchor_sha256: GoldenDigestV1;
+    readonly consume_receipt_sha256: GoldenDigestV1;
+    readonly consume_binding_sha256: GoldenDigestV1;
+    readonly authority_envelope_sha256: GoldenDigestV1;
+    readonly sandbox_request_sha256: GoldenDigestV1;
+    readonly task_result_sha256: GoldenDigestV1;
+    readonly checkpoint_handoff_sha256: GoldenDigestV1;
+    readonly absence_evidence_sha256: GoldenDigestV1;
+    readonly destroyed: true;
+    readonly absent_by_get: true;
+    readonly absent_by_list: true;
+    readonly receipt_sha256: GoldenDigestV1;
+}
+export declare function runGoldenDisposableTaskV1(input: GoldenDisposableTaskRequestV1, ports: Readonly<{
+    authority: InfinityDisposableTaskAuthorityPortV1;
+    sandboxes: GoldenDisposableSandboxTaskPortV1;
+}>): Promise<GoldenDisposableTaskReceiptV1>;
+export {};

package/dist/types/golden/source-pins.d.ts

@@ -0,0 +1,77 @@
+export declare const GOLDEN_BUILD_RECIPE_V1: Readonly<{
+    readonly schema_version: "infinity.golden-build-recipe/v1";
+    readonly git: Readonly<{
+        path: "/usr/bin/git";
+        version: "2.43.0";
+        executable_sha256: "sha256:aa6540695d076182256dd6e96c8b302e4d56381e3000bbfd5c71bbdfe94a4942";
+    }>;
+    readonly bun: Readonly<{
+        version: "1.3.13";
+        executable_sha256: "sha256:67892bb6734ef352f90a964f0a2a680d5f6e6d15bdb5510e56b8065ac4d599ae";
+    }>;
+    readonly umask: "0022";
+    readonly source_materialization: "git archive <commit> into fresh mode-0700 root";
+    readonly commands: readonly string[];
+    readonly consumer_commands: readonly string[];
+    readonly ambient_resolution: false;
+}>;
+export declare const GOLDEN_SOURCE_PINS_V1: Readonly<{
+    readonly schema_version: "infinity.golden-source-pins/v1";
+    readonly build_recipe: Readonly<{
+        readonly schema_version: "infinity.golden-build-recipe/v1";
+        readonly git: Readonly<{
+            path: "/usr/bin/git";
+            version: "2.43.0";
+            executable_sha256: "sha256:aa6540695d076182256dd6e96c8b302e4d56381e3000bbfd5c71bbdfe94a4942";
+        }>;
+        readonly bun: Readonly<{
+            version: "1.3.13";
+            executable_sha256: "sha256:67892bb6734ef352f90a964f0a2a680d5f6e6d15bdb5510e56b8065ac4d599ae";
+        }>;
+        readonly umask: "0022";
+        readonly source_materialization: "git archive <commit> into fresh mode-0700 root";
+        readonly commands: readonly string[];
+        readonly consumer_commands: readonly string[];
+        readonly ambient_resolution: false;
+    }>;
+    readonly infinity: Readonly<{
+        repository: "hasna/infinity";
+        commit: "c5970a24525835ecf23c8540517c424ea54c9fa0";
+        tree: "ea9d18003bc018841ac653cb45c7a7b54f50bb94";
+        archive_sha256: "sha256:4384c9994f7b4aae9f3454126dcb8a4fb8e5f6763fdf236cde59851e85469b33";
+    }>;
+    readonly accounts: Readonly<{
+        repository: "hasna/accounts";
+        commit: "fe26a79f316ce81ca64366194e0f3f7e3534f4e3";
+        tree: "52e9aa6311369a896b03aea1586c1ab8af2542f8";
+        archive_sha256: "sha256:84ce1409c87ba20f4b938279161d2b5a0965e224219d4af06e0d63ea7d5c48a0";
+        package_sha256: "sha256:55a579f60b677ea58c903319b5f84241fd58d997380afd50fd7068030dcd578b";
+    }>;
+    readonly sandboxes: Readonly<{
+        repository: "hasna/sandboxes";
+        commit: "33a5f670d4c20469902c641dd493c7c0c09726c0";
+        tree: "f041a133fc69db56cf206871c8708bef6843a6ae";
+        archive_sha256: "sha256:caed739b07fa828baf9e5ec6669d3b53d793fa3077fe101d8426ac72f32c15e9";
+        package_sha256: "sha256:5a911d3556b8b8e54df94c665f0ceffaf49bd57834ec6a9360907ebac54eaf68";
+    }>;
+    readonly reference_only_golden: Readonly<{
+        repository: "hasna/infinity";
+        commit: "c0dd4b9612cdd9705856fa155c89402a40f8b7fa";
+        imported: false;
+    }>;
+}>;
+export type GoldenSourceNameV1 = "infinity" | "accounts" | "sandboxes";
+export interface GoldenSourceAttestationV1 {
+    readonly schema_version: "infinity.golden-source-attestation/v1";
+    readonly source: GoldenSourceNameV1;
+    readonly commit: string;
+    readonly tree: string;
+    readonly archive_sha256: `sha256:${string}`;
+    readonly package_sha256?: `sha256:${string}`;
+    readonly exact: true;
+}
+export declare function attestGoldenSourceV1(input: {
+    readonly source: GoldenSourceNameV1;
+    readonly root: string;
+    readonly package_path?: string;
+}): Promise<GoldenSourceAttestationV1>;

package/dist/types/http/api.d.ts

@@ -0,0 +1,52 @@
+import type { CapabilityProjection, PublicRunMutationContext, SubmitRunContext } from "../authority/authority";
+import { type Int64 } from "../core/int64";
+import { type InfinityProductionSandboxDispatchService, type InfinitySandboxDispatchAuthorizationRequestV1 } from "../providers/sandbox-dispatch";
+export declare const OPERATOR_SCHEMA_VERSION: "infinity.operator/v1";
+export declare const INFINITY_VERSION: "0.1.0";
+export interface AuthenticatedOperator {
+    principal: string;
+    audience: "operator";
+}
+export interface OperatorAuthenticator {
+    authenticate(request: Request): Promise<AuthenticatedOperator>;
+}
+export declare class FixedPrincipalAuthenticator implements OperatorAuthenticator {
+    private readonly principal;
+    constructor(principal: string);
+    authenticate(_request: Request): Promise<AuthenticatedOperator>;
+}
+export interface AuthorityApi {
+    handle(request: Request): Promise<Response>;
+}
+type MaybePromise<T> = T | Promise<T>;
+export interface OperatorAuthority {
+    snapshot(): MaybePromise<{
+        authority_epoch: Int64;
+    }>;
+    listCapabilities(actorPrincipal: string): MaybePromise<CapabilityProjection>;
+    validateRunSpec(input: unknown): MaybePromise<unknown>;
+    planRun(input: unknown): MaybePromise<unknown>;
+    submitRun(input: unknown, context: SubmitRunContext): MaybePromise<unknown>;
+    getRun(runId: string, actorPrincipal: string): MaybePromise<unknown>;
+    listRuns(actorPrincipal: string, options: {
+        limit?: number;
+        cursor?: string;
+    }): MaybePromise<unknown>;
+    waitRun(runId: string, actorPrincipal: string, timeoutMs: number): MaybePromise<unknown>;
+    readRunEvents(runId: string, actorPrincipal: string, options: {
+        cursor: string;
+        limit: number;
+        waitMs: number;
+    }): MaybePromise<unknown>;
+    cancelRun(runId: string, context: PublicRunMutationContext & {
+        reasonCode: string;
+    }): MaybePromise<unknown>;
+    retryRun(runId: string, context: PublicRunMutationContext): MaybePromise<unknown>;
+    authorizeSandboxDispatch?(input: InfinitySandboxDispatchAuthorizationRequestV1, actorPrincipal: string): MaybePromise<unknown>;
+    resolveOperation(operationId: string, actorPrincipal: string): MaybePromise<unknown>;
+}
+export interface AuthorityApiExtensions {
+    readonly productionSandboxDispatch?: InfinityProductionSandboxDispatchService;
+}
+export declare function createAuthorityApi(authority: OperatorAuthority, authenticator: OperatorAuthenticator, extensions?: Readonly<AuthorityApiExtensions>): AuthorityApi;
+export {};

package/dist/types/http/bearer-auth.d.ts

@@ -0,0 +1,8 @@
+import type { AuthenticatedOperator, OperatorAuthenticator } from "./api";
+export declare class BearerTokenFileAuthenticator implements OperatorAuthenticator {
+    private readonly expectedDigest;
+    private readonly principal;
+    private constructor();
+    static open(path: string, principalInput: string): BearerTokenFileAuthenticator;
+    authenticate(request: Request): Promise<AuthenticatedOperator>;
+}

package/dist/types/http/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export declare const LOCAL_REFERENCE_HOSTNAME: "127.0.0.1";
+export declare function startLocalReferenceServer(port: number): ReturnType<typeof Bun.serve>;

package/dist/types/http/self-hosted-main.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+import { type InfinityManagedSandboxProviderV1, type SandboxesV2ProductionDispatchPort } from "../providers/sandbox-dispatch";
+export interface SelfHostedServerDependencies {
+    readonly productionDispatchPorts?: Readonly<Record<InfinityManagedSandboxProviderV1, SandboxesV2ProductionDispatchPort>>;
+}
+export declare function startSelfHostedServer(environment?: NodeJS.ProcessEnv, dependencies?: Readonly<SelfHostedServerDependencies>): Promise<{
+    readonly server: Bun.Server<unknown>;
+    readonly runtime: {
+        readonly report: Readonly<import("..").SelfHostedRuntimeReport>;
+        readonly markReady: () => void;
+        readonly markNotReady: () => void;
+        readonly beginShutdown: () => void;
+        readonly fetch: (request: Request) => Promise<Response>;
+    };
+    readonly report: Readonly<import("..").SelfHostedRuntimeReport>;
+    readonly stop: (signal: "SIGINT" | "SIGTERM") => Promise<void>;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,65 @@
+export { InMemoryRunAuthority, computeDiscardConsequenceDigest, mutationRequestHash, type ApprovalDecisionContext, type ApprovalProposalInput, type CapabilityProjection, type ClaimAttemptInput, type ClaimAttemptResult, type ConsumeApprovalResult, type DiscardConsequenceInput, type HumanApprovalAuthorizer, type MaintenanceQuiescenceBlockers, type MaintenanceQuiescenceReport, type RunEventPage, type RunMutationResult, type RunWaitProjection, type SubmitRunContext, type SubmitRunResult, } from "./authority/authority";
+export { InMemoryAuthorityStore, DeterministicFaultInjector } from "./authority/store";
+export { EFFECT_JOURNAL_OUTCOME_KINDS, EFFECT_JOURNAL_OUTCOME_SCHEMA, EFFECT_JOURNAL_OUTCOME_SCHEMA_DIGEST, EFFECT_JOURNAL_OUTCOME_SCHEMA_VERSION, EFFECT_JOURNAL_ANCHOR_SCHEMA_VERSION, EFFECT_JOURNAL_HEAD_SCHEMA_VERSION, EFFECT_JOURNAL_PROTECTION_SCHEMA_VERSION, EFFECT_JOURNAL_RANGE_SCHEMA_VERSION, EFFECT_JOURNAL_RECORD_SCHEMA_VERSION, Ed25519EffectJournalSigner, Ed25519EffectJournalVerifier, InMemoryEffectJournal, OPERATION_STEP_SCHEMA_VERSION, RECONCILIATION_BLOCKED_MAPPING_FIXTURE, assertEffectJournalSeparated, operationStepDigest, parseEffectJournalRecord, parseOperationStep, type EffectJournalOutcomeKind, type EffectJournalHeadReceipt, type EffectJournalPort, type EffectJournalProtection, type EffectJournalRange, type EffectJournalReceiptVerifier, type EffectJournalAppendAuthorization, type EffectJournalAppendAuthorizer, type EffectJournalRecord, type EffectJournalRecordInput, type EffectJournalRecordKind, type EffectJournalSigner, type OperationStep, type OperationStepInput, type StoredEffectJournalRecord, type SynchronousEffectJournalPort, } from "./authority/effect-journal";
+export { AUTHORITY_MUTATION_ACK_SCHEMA_VERSION, AUTHORITY_MUTATION_ANCHOR_SCHEMA_VERSION, AUTHORITY_MUTATION_ENVELOPE_SCHEMA_VERSION, AUTHORITY_MUTATION_PROTECTION_SCHEMA_VERSION, AUTHORITY_MUTATION_RANGE_SCHEMA_VERSION, Ed25519AuthorityMutationJournalSigner, Ed25519AuthorityMutationJournalVerifier, InMemoryAuthorityMutationJournal, authorityMutationJournalProtectionDigest, assertAuthorityMutationJournalSeparated, parseAuthorityMutationEnvelope, type AuthorityMutationAppendReceipt, type AuthorityMutationChange, type AuthorityMutationEnvelope, type AuthorityMutationJournalAcknowledgement, type AuthorityMutationJournalPort, type AuthorityMutationJournalProtection, type AuthorityMutationJournalRange, type AuthorityMutationJournalReceiptVerifier, type AuthorityMutationJournalSigner, type SynchronousAuthorityMutationJournalPort, type StoredAuthorityMutationAnchor, } from "./authority/mutation-journal";
+export { initialAuthorityState, type AuthoritySnapshot, type AuthorityState } from "./authority/state";
+export { BROKER_FENCE_FIELDS, BROKER_FENCE_SCHEMA_VERSION, BROKER_FENCE_WIRE_FIELDS, REJECTED_FENCE_ALIASES, assertFenceCurrent, parseBrokerFence, type AuthenticatedFenceContext, type BrokerFence, } from "./contracts/fence";
+export type { Int64 } from "./core/int64";
+export { RUN_SPEC_INPUT_SCHEMA, parseRunSpec, runSpecDigest, type RunSpec, type RunSpecInput } from "./contracts/runspec";
+export { parseAttemptRecord, parseAuthorityEvent, parseExternalOperation, parseOutboxRow, parseRunRecord, } from "./contracts/validators";
+export { MAX_SLOT_ELIGIBILITY_LIFETIME_MS, parseSlotEligibility, type AccountsSlotEligibilityPort, type SlotEligibility } from "./ports/accounts";
+export { Ed25519AccountsOperationEvidenceSigner, InMemoryAccountsOperationSignerHistory, InMemoryInfinityAccountsOperationAdapter, INFINITY_ACCOUNT_SERIALIZATION_FRONTIER_HEAD_DESCRIPTOR, INFINITY_ACCOUNT_SERIALIZATION_FRONTIER_HEAD_SCHEMA_DIGEST, INFINITY_ACCOUNTS_INTEGRATION_COMMIT, INFINITY_MODEL_CALL_CONSUME_BINDING_DESCRIPTOR, INFINITY_MODEL_CALL_CONSUME_BINDING_SCHEMA_DIGEST, INFINITY_MODEL_CALL_PREPARED_ANCHOR_DESCRIPTOR, INFINITY_MODEL_CALL_PREPARED_ANCHOR_SCHEMA_DIGEST, accountsSerializationKeyDigest, assertVerifiedConsumeBoundEvidence, type AccountsModelCallEffectJournalRecord, type AccountsModelCallOperationRecord, type AccountsOperationEvidenceSigner, type AccountsOperationSignerHistoryPin, type AccountsOperationSignerHistoryRecord, type AccountsOperationSigningKeyStatus, type AccountsSerializationDomainState, type AccountsSerializationFrontierKind, type AssertConsumeBoundCurrentRequest, type AssertPreparedOpenCurrentRequest, type BindCapabilityUseRequest, type CapabilityUseOperationBinding, type InfinityAccountsOperationPort, type InfinityAccountsOperationRecoveryPort, type InfinityCounter, type InfinitySha256Digest, type PrepareAccountsModelCallInput, type SignedAccountsSerializationFrontierHead, type VerifiedConsumeBoundOperation, type VerifiedPreparedOpenOperation, } from "./ports/accounts-operation";
+export type { SandboxesPort } from "./ports/sandboxes";
+export { INFINITY_SANDBOX_DISPATCH_AUTHORIZATION_REQUEST_SCHEMA_V1, INFINITY_SANDBOX_DISPATCH_AUTHORIZATION_RESULT_SCHEMA_V1, INFINITY_SANDBOX_PROVIDER_DISPATCH_PRODUCTION_ADMISSION_V1, InfinityProductionSandboxDispatchService, InfinitySandboxDispatchAuthorizationService, type InfinityProductionSandboxDispatchResultV1, type InfinityManagedSandboxProviderV1, type InfinitySandboxDispatchAuthorizationRequestV1, type InfinitySandboxDispatchAuthorizationResultV1, type SandboxesV2AuthorizationPort, type SandboxesV2BoundAuthorization, type SandboxesV2Intent, type SandboxesV2PreparedIntent, type SandboxesV2ProductionDispatchPort, type SandboxesV2ProductionDispatchResult, } from "./providers/sandbox-dispatch";
+export { SANDBOX_DISPATCH_ACCOUNTS_CONSUME_EVIDENCE_REQUEST_SCHEMA_VERSION, SANDBOX_DISPATCH_ACCOUNTS_CONSUME_EVIDENCE_SCHEMA_VERSION, SANDBOX_DISPATCH_AUTHORIZATION_REQUEST_SCHEMA_V2, SANDBOX_DISPATCH_AUTHORIZATION_SCHEMA_V2, DISPOSABLE_TASK_AUTHORIZATION_CONSUMPTION_SCHEMA_V2, DISPOSABLE_TASK_PROVIDER_CONTACT_AUDIENCE_V2, parseSandboxDispatchAuthorizationRequestV2, parseSandboxDispatchAccountsConsumeEvidenceRequestV1, parseSandboxDispatchAccountsConsumeEvidenceV1, parseDisposableTaskAuthorityConsumeInputV2, parseDisposableTaskAuthorizationConsumptionV2, disposableTaskAuthorizationArtifactsV2, parseDisposableTaskAuthorizationArtifactsV2, parseSignedSandboxDispatchAuthorizationV2, sandboxDispatchAuthorizationDigest, disposableTaskAuthorizationConsumptionDigest, type SandboxDispatchAuthorityPortV2, type SandboxDispatchAccountsConsumeEvidenceRequestV1, type SandboxDispatchAccountsConsumeEvidenceV1, type SandboxDispatchAuthorizationRequestV2, type DisposableTaskAuthorityConsumeInputV2, type DisposableTaskAuthorizationConsumptionV2, type DisposableTaskAuthorizationArtifactsV2, type ManagedProviderIdV1, type SignedSandboxDispatchAuthorizationV2, } from "./ports/sandbox-dispatch-authority";
+export { MCP_TOOL_SCHEMAS, getMcpToolSchema, type McpToolSchema } from "./mcp/schema";
+export { assertStoredMutationResult, isPublicMutationCommand, MAX_MUTABLE_IF_REVISION, MAX_REVISION, parsePublicMutationResult, parsePublicMutationResultExpectation, parsePublicOperationResolution, type OperationBinding, type OperationResolution, type PublicMutationCommand, type PublicMutationResultExpectation, type PublicOperationBinding, type PublicOperationResolution, } from "./contracts/operations";
+export { OperatorHttpClient, type ExistingRunRequest, type OperatorClient, type OperatorEnvelope, type SubmitRequest, } from "./client/operator-client";
+export { FixedPrincipalAuthenticator, createAuthorityApi, type AuthenticatedOperator, type AuthorityApi, type OperatorAuthenticator, type OperatorAuthority, } from "./http/api";
+export { BearerTokenFileAuthenticator } from "./http/bearer-auth";
+export { startSelfHostedServer, type SelfHostedServerDependencies, } from "./http/self-hosted-main";
+export { FileEd25519Signer, assertOwnerOnlySecretFile, loadSelfHostedRuntimeConfig, loadSelfHostedMigrationConfig, readPostgresUrlFile, readOwnerOnlySecretFile, type SelfHostedRuntimeConfig, type SelfHostedMigrationConfig, } from "./runtime/config";
+export { createSelfHostedPostgresRuntime } from "./runtime/postgres";
+export { INFINITY_PROVIDER_ACTIVATION_INFINITY_COMMIT, INFINITY_PROVIDER_ACTIVATION_SANDBOXES_COMMIT, INFINITY_PROVIDER_ACTIVATION_SCHEMA_VERSION, INFINITY_PROVIDER_DAYTONA_EVIDENCE_MANIFEST_SHA256, INFINITY_PROVIDER_E2B_EVIDENCE_MANIFEST_SHA256, defaultProviderActivation, authorizeProviderProductionAdmission, loadProviderActivationManifest, parseProviderActivationManifest, providerActivationHasEligibleProductionProvider, type ProviderActivationEntry, type ProviderActivationState, type ProviderProductionAdmission, } from "./runtime/provider-activation";
+export { assertPostgresMigrationState, assertBuildRevisionMatches, EMBEDDED_BUILD_REVISION, createRuntimeReport, createSelfHostedRuntimeHandler, type RuntimeAuditRecord, type RuntimeAuditSink, type SelfHostedRuntimeReport, } from "./runtime/server";
+export { DurableCliOperationJournal, defaultCliOperationJournalPath, successfulMutationConsequenceDigest, type CliOperationIntent, type CliOperationJournal, type PreparedCliOperation, } from "./cli/operation-journal";
+export { applyPostgresMigrations, configurePostgresRoles, DEFAULT_POSTGRES_ROLES, POSTGRES_MIGRATION_MANIFEST, readMigrationState, type MigrationResult, type PostgresRoleNames, } from "./persistence/migrations";
+export { PostgresRunAuthority } from "./persistence/postgres-authority";
+export { createPostgresSandboxDispatchAuthorityV2 } from "./persistence/postgres-sandbox-dispatch-authority";
+export { PostgresMutationJournalCoordinator } from "./persistence/postgres-mutation-journal";
+export { POSTGRES_EXTERNAL_MUTATION_JOURNAL_MIGRATION_MANIFEST, applyPostgresExternalMutationJournalMigrations, configurePostgresExternalMutationJournalRole, initializePostgresExternalMutationJournalStore, type PostgresExternalMutationJournalMigrationResult, type PostgresExternalMutationJournalOptions, } from "./persistence/postgres-external-mutation-journal";
+export { PostgresReconciler, type EffectJournalAnchorVerifier, type LeasedOutboxRecord, } from "./persistence/postgres-reconciler";
+export { createPostgresAuthorityComposition } from "./persistence/composition";
+export { AUTH_CAPSULE_DESCRIPTOR_SCHEMA_VERSION, CAPSULE_REMOTE_TOOL_BINDING_SCHEMA_VERSION, LocalCodewithAuthCapsuleLauncher, authCapsuleDescriptorFromEligibility, parseAuthCapsuleDescriptor, parseCapsuleRemoteToolBinding, type AuthCapsuleDescriptor, type AuthCapsuleLaunchAuthorityPort, type AuthCapsuleLocalProfileReference, type CapsuleRemoteToolBinding, type CapsuleRemoteToolBridgePort, type CapsuleRemoteToolBridgeSession, type CodewithAuthCapsuleLaunchRequest, type CodewithAuthCapsuleLaunchResult, type CodewithLocalProfile, type CodewithLocalProfileRegistry, } from "./authcapsules/codewith-local";
+export { CAPSULE_REMOTE_CAPABILITIES, INFINITY_AGENT_POLICY_SCHEMA_VERSION, ProtectedCapsuleRemoteToolBridge, infinityAgentPolicyDigest, parseInfinityAgentPolicy, type CapsuleRemoteCapability, type CapsuleRemoteToolAuthorityPort, type CapsuleRemoteToolBackendPort, type CapsuleRemoteToolCall, type InfinityAgentPolicy, type ProtectedCapsuleRemoteToolSession, } from "./authcapsules/infinity-agent-policy";
+export { SUBSCRIPTION_CAPSULE_ATTESTATION_SCHEMA_VERSION, IsolatedSubscriptionCapsuleRunner, LinuxBubblewrapCapsuleProvider, MacOsVmSubscriptionCapsuleProvider, parseSubscriptionCapsuleAttestation, type LinuxBubblewrapCapsuleOptions, type MacOsVmCapsuleAdapter, type MacOsVmDriver, type SubscriptionCapsuleAttestation, type SubscriptionCapsuleLaunchResult, type SubscriptionCapsuleProvider, } from "./authcapsules/os-isolated-runner";
+export { CheckpointBroker, checkpointProvenanceInputDigest, checkpointProvenanceReceiptCoreDigest, checkpointProvenanceReceiptDigest, checkpointProvenanceReceiptSigningPreimage, checkpointSealOperationDigest, checkpointSealReceiptDigest, parseVerifiedCheckpointProvenanceReceipt, verifyCheckpointProvenanceReceiptSignature, type CheckpointSealCore, type CheckpointProvenanceVerificationInput, type CheckpointProvenanceVerifierPort, type CheckpointProvenanceReceiptCryptographyPort, type CheckpointSealReceipt, type CheckpointSealRequest, type FenceAuthorityPort, type ManifestSignerPort, type VerifiedCheckpointProvenanceReceipt, } from "./brokers/checkpoint/service";
+export type { ArchiveEntry, ArchivePolicy } from "./brokers/checkpoint/archive";
+export type { BinarySource } from "./brokers/checkpoint/bytes";
+export type { GitBundleInspectionPolicy } from "./brokers/checkpoint/bundle";
+export { IdempotentOperationLedger, type IdempotentExecutionContext, type IdempotentExecutor, type IdempotentResolution, } from "./brokers/checkpoint/idempotency";
+export { CleanCheckpointVerifier, parseManagedVerifierResult, parseManagedVerifierSandboxHandle, parseSandboxesVerifierAllocationReceipt, parseSandboxesVerifierCleanupReceipt, parseSandboxesVerifierQuarantineReceipt, parseVerifierCleanupCommitReceipt, parseVerifierCleanupGrant, sandboxesVerifierAllocationReceiptDigest, sandboxesVerifierCleanupReceiptDigest, sandboxesVerifierQuarantineReceiptCanonicalBytes, sandboxesVerifierQuarantineReceiptDigest, verifierCleanupCommitReceiptDigest, verifierCleanupGrantDigest, verifierCleanupGrantRequestDigest, verifierCleanupOperationDigest, verifierCleanupTarget, verifierInvalidAllocationEvidenceDigest, verifierQuarantineSubjectDigest, verifyRecordAndReadbackVerifierQuarantine, verifySandboxesVerifierAllocationReceipt, verifySandboxesVerifierCleanupReceipt, verifySandboxesVerifierQuarantineReceipt, type CleanCheckpointVerifierLimits, type ManagedVerifierDependentResource, type ManagedVerifierProviderHandle, type ManagedVerifierResultAttestationPort, type ManagedVerifierSandboxHandle, type ManagedVerifierSandboxPort, type ManagedVerifierSandboxResult, type SandboxesVerifierAllocationReceipt, type SandboxesVerifierAllocationReceiptAttestation, type SandboxesVerifierAllocationReceiptCore, type SandboxesVerifierAllocationReceiptVerifierPort, type SandboxesResourceAbsence, type SandboxesVerifierCleanupReceipt, type SandboxesVerifierCleanupReceiptAttestation, type SandboxesVerifierCleanupReceiptCore, type SandboxesVerifierCleanupReceiptVerifierPort, type SandboxesVerifierQuarantineReceipt, type SandboxesVerifierQuarantineReceiptAttestation, type SandboxesVerifierQuarantineReceiptCore, type SandboxesVerifierQuarantineReceiptVerifierPort, type VerifiedVerifierCleanupEvidence, type VerifierCleanupAuthorityPort, type VerifierCleanupFenceAuthorityPort, type VerifierCleanupCommitReceipt, type VerifierCleanupGrant, type VerifierCleanupGrantBinding, type VerifierCleanupGrantCore, type VerifierCleanupTarget, type VerifierQuarantineExpectation, type VerifierQuarantineReason, type VerifierEvidenceLoaderPort, } from "./brokers/checkpoint/clean-verifier";
+export { parseCheckpointManifestSigningTrust, parseCheckpointManifestSigningTrustHead, checkpointManifestKeyHistoryDigest, checkpointManifestSigningTrustHeadDigest, assertCheckpointManifestSigningTrustHeadMonotonic, assertCheckpointManifestSigningTrustHeadFreshAtDatabaseTime, verifyCheckpointManifestSignature, verifyCheckpointManifestSigningTrustHead, type CheckpointManifestSignatureVerifierPort, type CheckpointManifestSignatureVerificationResult, type CheckpointManifestSigningKeyRecord, type CheckpointManifestSigningKeyRecordInput, type CheckpointManifestSigningKeyStatus, type CheckpointManifestSigningTrust, type CheckpointManifestSigningTrustInput, type CheckpointManifestSigningTrustResolverPort, type CheckpointManifestSigningTrustHead, type CheckpointManifestSigningTrustHeadAttestation, type CheckpointManifestSigningTrustHeadCore, type CheckpointManifestSigningTrustHeadResolverPort, type CheckpointManifestSigningTrustHeadVerifierPort, } from "./brokers/checkpoint/manifest-signature";
+export { CHECKPOINT_MANIFEST_SIGNATURE_DOMAIN, CHECKPOINT_PROVENANCE_SIGNATURE_DOMAIN, checkpointSigningMessage, checkpointSigningMessageCanonicalBytes, checkpointSigningMessageDigest, checkpointSigningMessageDigestBytes, type CheckpointSignatureDomain, type CheckpointSigningMessage, } from "./brokers/checkpoint/signing-message";
+export { InMemoryVerifierCleanupAuthority, type VerifierCleanupGrantAuthorityPort, } from "./brokers/checkpoint/verifier-cleanup";
+export { PostgresVerifierCleanupAuthority, PostgresVerifierCleanupFinalizationAuthority, type VerifierCleanupFinalizationAuthorityPort, } from "./brokers/checkpoint/verifier-cleanup-authority";
+export { InMemoryCleanVerifierFinalizationAuthority, PostgresCleanVerifierFinalizationAuthority, type CleanVerifierCompletionPreparation, type CleanVerifierFinalizationAuthorityPort, } from "./brokers/checkpoint/clean-verifier-finalization";
+export { cleanVerifierOperationDigest, createCleanVerifierHandoff, finalizePassingVerificationReceipt, parseCleanVerifierHandoff, parseCheckpointSealReceipt, parseVerificationReceiptFinalTrustAuthorization, validatePassingVerificationReceipt, validateCheckpointSealReceipt, verifyPassingVerificationReceiptSignature, verifyPassingVerificationReceiptFinalTrustAuthorization, verificationReceiptFinalTrustAuthorizationDigest, verificationReceiptTrustGenerationDigest, verificationReceiptDigest, type CleanVerifierHandoff, type CleanVerifierHandoffRequest, type PassingVerificationReceipt, type AuthoritySignedPassingVerificationReceipt, type PassingVerificationReceiptCore, type PassingVerificationReceiptInput, type VerificationReceiptAuthorityAttestation, type VerificationReceiptCryptographyPort, type VerificationReceiptFinalTrustAuthorization, type VerificationReceiptFinalTrustAuthorityPort, type VerificationReceiptFinalTrustCryptographyPort, type VerificationReceiptCurrentTrustEffectContext, } from "./brokers/checkpoint/verifier";
+export { PostgresRecordedManifestSigningTrustHeadResolver, PostgresVerificationReceiptFinalTrustAuthority, } from "./brokers/checkpoint/final-trust-authority";
+export { checkpointManifestCanonicalBytes, checkpointManifestDigest, parseCheckpointManifest, type CheckpointArtifactName, type CheckpointArtifactRef, type CheckpointArtifactRefInput, type CheckpointManifest, type CheckpointManifestInput, } from "./brokers/checkpoint/manifest";
+export { InMemoryVersionedObjectStore, parseVersionedObjectRef, type PutAndReadbackInput, type PutVersionedObjectInput, type VersionedObjectRead, type VersionedObjectRef, type VersionedObjectStore, type VersionedReadbackReceipt, } from "./brokers/checkpoint/store";
+export { ProviderJournaledVersionedObjectStore } from "./brokers/checkpoint/journaled-store";
+export { InMemoryCheckpointSealAuthority, PostgresCheckpointSealAuthority, parseAuthorityCheckpointSealCommitReceipt, verifyAuthorityCheckpointSeal, type AuthorityCheckpointSealCommitReceipt, type AuthorityReceiptCryptographyPort, type CheckpointManifestSigningTrustFinalizationAuthorityPort, type CheckpointSealAuthorityPort, } from "./brokers/checkpoint/seal-authority";
+export { S3VersionedObjectStore, AwsSdkV3S3EvidenceClient, S3AmbiguousWriteError, S3ConditionalWriteConflictError, type AwsSdkV3Client, type AwsSdkV3S3CommandFactory, type S3EvidenceBucketInspector, type S3EvidenceBucketControls, type S3EvidenceClient, type S3EvidenceFenceAuthorityPort, type S3GetObjectRequest, type S3GetObjectResponse, type S3HeadObjectVersionResponse, type S3KmsContextAuditPort, type S3ObjectVersionSummary, type S3PutObjectRequest, type S3PutObjectResponse, type S3VersionedObjectStoreConfig, } from "./brokers/checkpoint/s3-store";
+export { GitPromotionBroker, InMemoryExpectedBaseGitPort, createGitPromotionIntent, derivePromotionBranchRef, parseGitPromotionReceipt, promotionApprovalConsumptionReceiptDigest, promotionApprovalSignedEnvelopeDigest, promotionApprovalWebauthnChallengeDigest, promotionOperationDigest, promotionProposalDigest, type DecisionIdempotencyTuple, type ExpectedBaseGitPort, type FreshPromotionSecretScanReceipt, type GitBranchCasReceipt, type GitBranchCreateReceipt, type GitCandidateObjectSource, type GitPromotionIntent, type GitPromotionIntentInput, type GitPromotionProposalInput, type GitPromotionReceipt, type GitPromotionReceiptCore, type GitPromotionResultAuthorityCommit, type GitPromotionStatus, type GitPullRequestCreateReceipt, type GitPullRequestReadReceipt, type GitPullRequestRecord, type GitRefReadReceipt, type InMemoryExpectedBaseGitPortOptions, type PromotionApprovalReceipt, type PromotionApprovalSignedEnvelope, type PromotionApprovalAuthorityPort, type PromotionApprovalChallengeInput, type PromotionApprovalConsumptionVerification, type PromotionFenceAuthorityPort, type PromotionSecretScannerPort, type PromotionResultAuthorityPort, type PromotionStepAction, } from "./brokers/git/promotion";
+export { GitHubAppExpectedBaseGitPort, GitHubAmbiguousCreateError, GitHubAmbiguousBranchWriteError, VersionedGitCandidateObjectLoader, type GitHubAppExpectedBaseConfig, type GitHubAppCredentialBrokerPort, type GitHubAppSessionContext, type GitHubBranchWriteEvidence, type GitHubRawBranchWriteReceipt, type GitHubRawRefReceipt, type GitHubRepositorySession, type GitHubSessionAuthorityPort, type GitPromotionCandidateObjectLoaderPort, type RepositoryAutomationAdmission, type RepositoryAutomationAdmissionPort, } from "./brokers/git/github-app";
+export { BunPostgresExecutor, PostgresOperationLedger, PostgresProviderStepLedger, ProviderNoEffectError, providerEffectJournalAnchorCoreDigest, applyCheckpointBrokerMigration, canonicalCodec, type CanonicalCodec, type PostgresLedgerOptions, type ProviderEffectJournalAnchorInput, type ProviderEffectJournalAuthorityPort, type ProviderStepExecutor, type ProviderStepExecutionInput, type ProviderStepResolution, type VerifiedProviderEffectJournalAnchor, type SqlParameter, type SqlExecutor, } from "./brokers/persistence/postgres";
+export { InMemoryProviderStepLedger } from "./brokers/persistence/memory";
+export { CHECKPOINT_BROKER_MIGRATION_ID, CHECKPOINT_BROKER_MIGRATION_V1, CHECKPOINT_TRUST_MIGRATION_ID, CHECKPOINT_TRUST_MIGRATION_V2, CHECKPOINT_BROKER_MIGRATION_V2_ID, CHECKPOINT_BROKER_MIGRATION_V2, } from "./brokers/persistence/migration";
+export { createDurableCheckpointBroker, createDurableGitPromotionBroker, createProductionCheckpointGitBrokerStack, type DurableCheckpointBrokerDependencies, type DurableGitPromotionBrokerDependencies, type ProductionCheckpointGitBrokerStack, type ProductionCheckpointGitBrokerStackDependencies, } from "./brokers/composition";
+export { GOLDEN_BUILD_RECIPE_V1, GOLDEN_SOURCE_PINS_V1, attestGoldenSourceV1, type GoldenSourceAttestationV1, type GoldenSourceNameV1, } from "./golden/source-pins";
+export { GOLDEN_SOURCE_PIN_SET_SHA256, runGoldenDisposableTaskV1, type GoldenAccountsConsumeInputV1, type GoldenAccountsConsumePortV1, type GoldenAccountsConsumeResultV1, type GoldenDigestV1, type GoldenDisposableSandboxTaskPortV1, type GoldenDisposableTaskReceiptV1, type GoldenDisposableTaskRequestV1, type GoldenSandboxTaskReceiptV1, type GoldenSandboxTaskRequestV1, type InfinityDisposableTaskAuthorityPortV1, } from "./golden/disposable-task";
+export { NODE_AGENT_COMMAND_SCHEMA_VERSION, NODE_AGENT_HEARTBEAT_SCHEMA_VERSION, MAX_NODE_AGENT_COMMAND_LIFETIME_MS, NODE_AGENT_RECEIPT_SCHEMA_VERSION, NODE_AGENT_REGISTRATION_SCHEMA_VERSION, nodeAgentCommandDigest, nodeAgentCommandSigningBytes, parseNodeAgentCommandCore, parseNodeAgentTransportPolicy, parseSignedNodeAgentCommand, type NodeAgentCommandCore, type NodeAgentCommandPayload, type NodeAgentHeartbeat, type NodeAgentLaunchPayload, type NodeAgentReceipt, type NodeAgentRegistration, type NodeAgentRevokePayload, type NodeAgentTransportPolicy, type NodeControlPlanePeerEvidence, type NodeControlPlaneSession, type NodeControlPlaneTransport, type SignedNodeAgentCommand, } from "./node-agent/contracts";
+export { Ed25519NodeCommandVerifier, DurableNodeAgentJournal, InMemoryNodeAgentAuditSink, InMemoryNodeAgentJournal, IsolatedRunnerNodeCapsuleRuntime, JsonLinesNodeAgentAuditSink, NodeAgentDaemon, ed25519PublicKeyThumbprint, type NodeAgentAuditEvent, type NodeAgentAuditSink, type NodeAgentConfig, type NodeAgentJournal, type NodeCapsuleRuntimePort, type NodeCapsuleLifecyclePort, type NodeCapsuleCommandIdentity, type NodeCommandClaim, type NodeCommandVerifier, } from "./node-agent/agent";
+export { INFINITY_AGENT_LAUNCHD_LABEL, MacOsLaunchdService, renderMacOsLaunchdPlist, type MacOsLaunchdHostPort, type MacOsLaunchdOptions, type MacOsServiceStatus, } from "./node-agent/macos-service";
+export { ComposedNodeAgentServiceCliRuntime, runNodeAgentServiceCli, type NodeAgentServiceCliRuntime, } from "./node-agent/service-cli";

package/dist/types/mcp/schema.d.ts

@@ -0,0 +1,7 @@
+export interface McpToolSchema {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+export declare const MCP_TOOL_SCHEMAS: readonly McpToolSchema[];
+export declare function getMcpToolSchema(name: string): McpToolSchema | undefined;

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

@@ -0,0 +1,174 @@
+import { type KeyObject } from "node:crypto";
+import type { Clock } from "../core/clock";
+import type { IsolatedSubscriptionCapsuleRunner, SubscriptionCapsuleAttestation, SubscriptionCapsuleLaunchResult, SubscriptionCapsuleProvider } from "../authcapsules/os-isolated-runner";
+import { type NodeAgentCommandCore, type NodeAgentLaunchPayload, type NodeAgentReceipt, type NodeAgentTransportPolicy, type NodeControlPlaneTransport, type SignedNodeAgentCommand } from "./contracts";
+export interface NodeCapsuleRuntimePort {
+    readonly owner_ref: string;
+    inspect(): Promise<SubscriptionCapsuleAttestation>;
+    launch(input: Readonly<{
+        identity: NodeCapsuleCommandIdentity;
+        request: Extract<NodeAgentCommandCore["payload"], {
+            schema_version: "infinity.node-agent-launch.v1";
+        }>;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+    revoke(input: Readonly<{
+        identity: NodeCapsuleCommandIdentity;
+        reason_code: string;
+    }>): Promise<void>;
+    reconcile(command: SignedNodeAgentCommand): Promise<Readonly<{
+        state: "not_applied";
+    }> | Readonly<{
+        state: "applied";
+        exit_code?: number;
+    }>>;
+}
+export interface NodeCapsuleCommandIdentity {
+    readonly command_id: string;
+    readonly command_sha256: string;
+    readonly lease_id: string;
+    readonly lease_epoch: string;
+}
+export interface NodeCapsuleLifecyclePort {
+    launch(input: Readonly<{
+        identity: NodeCapsuleCommandIdentity;
+    }>, effect: () => Promise<SubscriptionCapsuleLaunchResult>): Promise<SubscriptionCapsuleLaunchResult>;
+    revoke(input: Readonly<{
+        identity: NodeCapsuleCommandIdentity;
+        reason_code: string;
+    }>): Promise<void>;
+    reconcile(command: SignedNodeAgentCommand): Promise<Readonly<{
+        state: "not_applied";
+    }> | Readonly<{
+        state: "applied";
+        exit_code?: number;
+    }>>;
+}
+/**
+ * Narrow composition adapter for the existing OS-isolated runner. The adapter
+ * deliberately has no caller-controlled path, mount, argv, environment, repo,
+ * endpoint, or credential input.
+ */
+export declare class IsolatedRunnerNodeCapsuleRuntime implements NodeCapsuleRuntimePort {
+    #private;
+    readonly owner_ref: string;
+    constructor(input: Readonly<{
+        provider: Pick<SubscriptionCapsuleProvider, "inspect">;
+        runner: Pick<IsolatedSubscriptionCapsuleRunner, "launch">;
+        lifecycle: NodeCapsuleLifecyclePort;
+        owner_ref: string;
+    }>);
+    inspect(): Promise<SubscriptionCapsuleAttestation>;
+    launch(input: Readonly<{
+        identity: NodeCapsuleCommandIdentity;
+        request: NodeAgentLaunchPayload;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+    revoke(input: Readonly<{
+        identity: NodeCapsuleCommandIdentity;
+        reason_code: string;
+    }>): Promise<void>;
+    reconcile(command: SignedNodeAgentCommand): ReturnType<NodeCapsuleLifecyclePort["reconcile"]>;
+}
+export interface NodeAgentAuditEvent {
+    readonly schema_version: "infinity.node-agent-audit.v1";
+    readonly event_id: string;
+    readonly observed_at: string;
+    readonly canonical_node_id: string;
+    readonly action: "connect" | "heartbeat" | "launch" | "revoke" | "reconcile";
+    readonly outcome: "accepted" | "succeeded" | "rejected";
+    readonly command_id?: string;
+    readonly command_sha256?: string;
+    readonly capsule_id?: string;
+    readonly lease_epoch?: string;
+    readonly reason_code?: string;
+}
+export interface NodeAgentAuditSink {
+    write(event: NodeAgentAuditEvent): Promise<void>;
+}
+export declare class InMemoryNodeAgentAuditSink implements NodeAgentAuditSink {
+    readonly events: NodeAgentAuditEvent[];
+    write(event: NodeAgentAuditEvent): Promise<void>;
+}
+export declare class JsonLinesNodeAgentAuditSink implements NodeAgentAuditSink {
+    #private;
+    constructor(path: string);
+    write(event: NodeAgentAuditEvent): Promise<void>;
+}
+export interface NodeCommandClaim {
+    readonly state: "claimed" | "pending_replay" | "completed_replay";
+    readonly receipt?: NodeAgentReceipt;
+}
+export interface NodeAgentJournal {
+    claim(command: SignedNodeAgentCommand): Promise<NodeCommandClaim>;
+    complete(commandId: string, receipt: NodeAgentReceipt): Promise<void>;
+    pending(): Promise<readonly SignedNodeAgentCommand[]>;
+    lastSequence(): Promise<string>;
+}
+interface JournalEntry {
+    readonly digest: string;
+    readonly command: SignedNodeAgentCommand;
+    receipt?: NodeAgentReceipt;
+}
+interface CapsuleFenceState {
+    leaseEpoch: bigint;
+    placementGeneration: string;
+    authGeneration: string;
+    revoked: boolean;
+}
+export declare class InMemoryNodeAgentJournal implements NodeAgentJournal {
+    protected readonly entries: Map<string, JournalEntry>;
+    protected readonly capsuleFences: Map<string, CapsuleFenceState>;
+    protected highSequence: bigint;
+    claim(command: SignedNodeAgentCommand): Promise<NodeCommandClaim>;
+    complete(commandId: string, receipt: NodeAgentReceipt): Promise<void>;
+    pending(): Promise<readonly SignedNodeAgentCommand[]>;
+    lastSequence(): Promise<string>;
+    snapshotEntries(): readonly JournalEntry[];
+}
+export declare class DurableNodeAgentJournal implements NodeAgentJournal {
+    #private;
+    private constructor();
+    static open(path: string): Promise<DurableNodeAgentJournal>;
+    claim(command: SignedNodeAgentCommand): Promise<NodeCommandClaim>;
+    complete(commandId: string, receipt: NodeAgentReceipt): Promise<void>;
+    pending(): Promise<readonly SignedNodeAgentCommand[]>;
+    lastSequence(): Promise<string>;
+}
+export interface NodeCommandVerifier {
+    readonly key_id: string;
+    readonly key_thumbprint: string;
+    verify(command: SignedNodeAgentCommand): void;
+}
+export declare class Ed25519NodeCommandVerifier implements NodeCommandVerifier {
+    #private;
+    readonly key_id: string;
+    readonly key_thumbprint: string;
+    constructor(input: Readonly<{
+        key_id: string;
+        key_thumbprint: string;
+        public_key: KeyObject | string | Buffer;
+    }>);
+    verify(command: SignedNodeAgentCommand): void;
+}
+export declare function ed25519PublicKeyThumbprint(publicKey: KeyObject): string;
+export interface NodeAgentConfig {
+    readonly canonical_node_id: string;
+    readonly node_key_thumbprint: string;
+    readonly node_generation: string;
+    readonly agent_version: string;
+    readonly transport_policy: NodeAgentTransportPolicy;
+}
+export declare class NodeAgentDaemon {
+    #private;
+    constructor(input: Readonly<{
+        config: NodeAgentConfig;
+        transport: NodeControlPlaneTransport;
+        verifier: NodeCommandVerifier;
+        capsules: Readonly<Record<string, NodeCapsuleRuntimePort>>;
+        journal: NodeAgentJournal;
+        audit: NodeAgentAuditSink;
+        clock?: Clock;
+    }>);
+    runOnce(): Promise<void>;
+    run(signal: AbortSignal): Promise<void>;
+}
+export {};