@hasna/infinity 0.1.0

package/dist/types/authcapsules/codewith-local.d.ts

@@ -0,0 +1,109 @@
+import { type InfinityAgentPolicy } from "./infinity-agent-policy";
+import { type BrokerFence } from "../contracts/fence";
+import type { SlotEligibility } from "../ports/accounts";
+export declare const AUTH_CAPSULE_DESCRIPTOR_SCHEMA_VERSION: "infinity.auth-capsule-descriptor.v2";
+export declare const CAPSULE_REMOTE_TOOL_BINDING_SCHEMA_VERSION: "infinity.capsule-remote-tool-binding.v1";
+export interface AuthCapsuleDescriptor {
+    readonly schema_version: typeof AUTH_CAPSULE_DESCRIPTOR_SCHEMA_VERSION;
+    readonly auth_capsule_id: string;
+    readonly owner_ref: string;
+    readonly provider_key: string;
+    readonly provider_subject_ref: string;
+    readonly capacity_domain_ref: string;
+    readonly account_lane_id: string;
+    readonly canonical_node_id: string;
+    readonly node_key_thumbprint: string;
+    readonly node_generation: string;
+    readonly placement_generation: string;
+    readonly auth_generation: string;
+    readonly auth_state_revision: string;
+    readonly accounts_revision_set_digest: string;
+    readonly capsule_attestation_digest: string;
+    /** Opaque lookup key for a trusted host-local registry; never an auth path or credential. */
+    readonly local_profile_ref: string;
+    readonly codewith_binary_sha256: string;
+    readonly runtime_policy_sha256: string;
+    readonly infinity_agent_policy_sha256: string;
+}
+export interface AuthCapsuleLocalProfileReference {
+    readonly local_profile_ref: string;
+    readonly codewith_binary_sha256: string;
+    readonly runtime_policy_sha256: string;
+    readonly infinity_agent_policy_sha256: string;
+}
+export interface CapsuleRemoteToolBinding {
+    readonly schema_version: typeof CAPSULE_REMOTE_TOOL_BINDING_SCHEMA_VERSION;
+    readonly dispatch_id: string;
+    readonly canonical_intent_sha256: string;
+    readonly sandbox_prepare_anchor_sha256: string;
+    readonly authority_envelope_sha256: string;
+    readonly effect_claim_sha256: string;
+    readonly operation_digest: string;
+    readonly provider: "e2b" | "daytona";
+    readonly source_manifest_sha256: string;
+    readonly input_manifest_sha256: string;
+    readonly checkpoint_policy_sha256: string;
+    readonly fence: BrokerFence;
+}
+export interface CodewithLocalProfile {
+    readonly executable_path: string;
+    readonly codewith_home: string;
+    readonly empty_workspace_path: string;
+    readonly auth_profile_name: string;
+    readonly runtime_profile_name: "infinity-agent";
+    readonly infinity_agent_policy_path: string;
+    /** Expected values are checked against actual bytes; registry claims are not trusted. */
+    readonly codewith_binary_sha256?: string;
+    readonly runtime_policy_sha256?: string;
+    readonly infinity_agent_policy_sha256?: string;
+}
+export interface CodewithLocalProfileRegistry {
+    resolve(descriptor: AuthCapsuleDescriptor): Promise<CodewithLocalProfile>;
+}
+export interface AuthCapsuleLaunchAuthorityPort {
+    /** Must perform final online run-fence and Accounts deny/generation checks. */
+    assertCurrent(input: Readonly<{
+        descriptor: AuthCapsuleDescriptor;
+        binding: CapsuleRemoteToolBinding;
+    }>): Promise<void>;
+}
+export interface CapsuleRemoteToolBridgeSession {
+    close(): Promise<void>;
+}
+export interface CapsuleRemoteToolBridgePort {
+    /**
+     * Opens a protected, no-secret bridge outside the Codewith PID/UID/mount domain.
+     * The static infinity-agent profile can reach only this bridge; it receives no
+     * bearer, endpoint, credential, or caller-selected command from this method.
+     */
+    open(input: Readonly<{
+        descriptor: AuthCapsuleDescriptor;
+        binding: CapsuleRemoteToolBinding;
+        policy: InfinityAgentPolicy;
+    }>): Promise<CapsuleRemoteToolBridgeSession>;
+}
+export interface CodewithAuthCapsuleLaunchRequest {
+    readonly descriptor: AuthCapsuleDescriptor;
+    readonly binding: CapsuleRemoteToolBinding;
+    readonly prompt: string;
+}
+export interface CodewithAuthCapsuleLaunchResult {
+    readonly schema_version: "infinity.codewith-auth-capsule-result.v1";
+    readonly exit_code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly descriptor_sha256: string;
+    readonly binding_sha256: string;
+}
+export declare function parseAuthCapsuleDescriptor(value: unknown): AuthCapsuleDescriptor;
+export declare function authCapsuleDescriptorFromEligibility(eligibility: SlotEligibility, local: AuthCapsuleLocalProfileReference): AuthCapsuleDescriptor;
+export declare function parseCapsuleRemoteToolBinding(value: unknown): CapsuleRemoteToolBinding;
+export declare class LocalCodewithAuthCapsuleLauncher {
+    #private;
+    constructor(dependencies: {
+        registry: CodewithLocalProfileRegistry;
+        authority: AuthCapsuleLaunchAuthorityPort;
+        bridge: CapsuleRemoteToolBridgePort;
+    });
+    launch(request: CodewithAuthCapsuleLaunchRequest): Promise<CodewithAuthCapsuleLaunchResult>;
+}

package/dist/types/authcapsules/infinity-agent-policy.d.ts

@@ -0,0 +1,57 @@
+import type { AuthCapsuleDescriptor, CapsuleRemoteToolBinding } from "./codewith-local";
+export declare const INFINITY_AGENT_POLICY_SCHEMA_VERSION: "infinity.codewith-agent-policy.v1";
+export declare const CAPSULE_REMOTE_CAPABILITIES: readonly ["sandbox.checkpoint.request", "sandbox.exec", "sandbox.file.read", "sandbox.file.write"];
+export type CapsuleRemoteCapability = typeof CAPSULE_REMOTE_CAPABILITIES[number];
+export interface InfinityAgentPolicy {
+    readonly schema_version: typeof INFINITY_AGENT_POLICY_SCHEMA_VERSION;
+    readonly profile: "infinity-agent";
+    readonly enforcement: "codewith-native-v1";
+    readonly environment_inherit: "none";
+    readonly history_persistence: "none";
+    readonly ephemeral: true;
+    readonly host_filesystem_access: false;
+    readonly host_shell_access: false;
+    readonly direct_network_access: false;
+    readonly auth_profile_control: false;
+    readonly allowed_capabilities: readonly CapsuleRemoteCapability[];
+}
+export declare function parseInfinityAgentPolicy(value: unknown): InfinityAgentPolicy;
+export declare function infinityAgentPolicyDigest(value: unknown): string;
+export interface CapsuleRemoteToolCall {
+    readonly request_id: string;
+    readonly capability: CapsuleRemoteCapability;
+    readonly input: Readonly<Record<string, unknown>>;
+}
+export interface CapsuleRemoteToolAuthorityPort {
+    assertCurrent(input: Readonly<{
+        descriptor: AuthCapsuleDescriptor;
+        binding: CapsuleRemoteToolBinding;
+        policy: InfinityAgentPolicy;
+        capability?: CapsuleRemoteCapability;
+    }>): Promise<void>;
+}
+export interface CapsuleRemoteToolBackendPort {
+    invoke(input: Readonly<{
+        descriptor: AuthCapsuleDescriptor;
+        binding: CapsuleRemoteToolBinding;
+        capability: CapsuleRemoteCapability;
+        request_id: string;
+        input: Readonly<Record<string, unknown>>;
+    }>): Promise<unknown>;
+}
+export interface ProtectedCapsuleRemoteToolSession {
+    invoke(call: CapsuleRemoteToolCall): Promise<unknown>;
+    close(): Promise<void>;
+}
+export declare class ProtectedCapsuleRemoteToolBridge {
+    #private;
+    constructor(dependencies: {
+        authority: CapsuleRemoteToolAuthorityPort;
+        backend: CapsuleRemoteToolBackendPort;
+    });
+    open(input: Readonly<{
+        descriptor: AuthCapsuleDescriptor;
+        binding: CapsuleRemoteToolBinding;
+        policy: unknown;
+    }>): Promise<ProtectedCapsuleRemoteToolSession>;
+}

package/dist/types/authcapsules/os-isolated-runner.d.ts

@@ -0,0 +1,87 @@
+import type { AuthCapsuleDescriptor, AuthCapsuleLaunchAuthorityPort, CapsuleRemoteToolBinding, CapsuleRemoteToolBridgePort } from "./codewith-local";
+export declare const SUBSCRIPTION_CAPSULE_ATTESTATION_SCHEMA_VERSION: "infinity.subscription-capsule-attestation.v1";
+export type MacOsVmDriver = "tart" | "lume" | "virtualization-framework";
+export interface SubscriptionCapsuleAttestation {
+    readonly schema_version: typeof SUBSCRIPTION_CAPSULE_ATTESTATION_SCHEMA_VERSION;
+    readonly provider: "linux-bubblewrap" | "macos-vm";
+    readonly driver: "bubblewrap" | MacOsVmDriver;
+    readonly capsule_id: string;
+    readonly canonical_node_id: string;
+    readonly node_generation: string;
+    readonly placement_generation: string;
+    readonly auth_generation: string;
+    readonly image_sha256: string;
+    readonly codewith_binary_sha256: string;
+    readonly managed_requirements_sha256: string;
+    readonly containment: "linux-user-mount-pid-net-namespace" | "macos-hypervisor-vm";
+    readonly persistent_credential_store: true;
+    readonly host_filesystem_mounted: false;
+    readonly repository_mounted: false;
+    readonly tool_credential_store_readable: false;
+    readonly broker_route: "protected-preprovisioned";
+}
+export interface SubscriptionCapsuleLaunchResult {
+    readonly exit_code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface SubscriptionCapsuleProvider {
+    inspect(): Promise<SubscriptionCapsuleAttestation>;
+    launch(input: Readonly<{
+        prompt: string;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+}
+export declare function parseSubscriptionCapsuleAttestation(value: unknown): SubscriptionCapsuleAttestation;
+export declare class IsolatedSubscriptionCapsuleRunner {
+    #private;
+    constructor(dependencies: {
+        provider: SubscriptionCapsuleProvider;
+        authority: AuthCapsuleLaunchAuthorityPort;
+        bridge: CapsuleRemoteToolBridgePort;
+    });
+    launch(input: Readonly<{
+        descriptor: AuthCapsuleDescriptor;
+        binding: CapsuleRemoteToolBinding;
+        policy: unknown;
+        prompt: string;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+}
+export interface MacOsVmCapsuleAdapter {
+    readonly driver: MacOsVmDriver;
+    inspect(): Promise<unknown>;
+    /** The guest launch route is preprovisioned; no caller argv, env, path, mount, endpoint, or credential is accepted. */
+    launch(input: Readonly<{
+        prompt: string;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+}
+export declare class MacOsVmSubscriptionCapsuleProvider implements SubscriptionCapsuleProvider {
+    #private;
+    constructor(adapter: MacOsVmCapsuleAdapter);
+    inspect(): Promise<SubscriptionCapsuleAttestation>;
+    launch(input: Readonly<{
+        prompt: string;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+}
+export interface LinuxBubblewrapCapsuleOptions {
+    readonly bubblewrap_path: string;
+    readonly capsule_root: string;
+    /** Provisioning-owned fixed command. It is never sourced from a model or task request. */
+    readonly guest_command: readonly string[];
+    readonly capsule_id: string;
+    readonly canonical_node_id: string;
+    readonly node_generation: string;
+    readonly placement_generation: string;
+    readonly auth_generation: string;
+    readonly image_sha256: string;
+    readonly codewith_binary_sha256: string;
+    readonly managed_requirements_path: string;
+    readonly managed_requirements_sha256: string;
+}
+export declare class LinuxBubblewrapCapsuleProvider implements SubscriptionCapsuleProvider {
+    #private;
+    constructor(options: LinuxBubblewrapCapsuleOptions);
+    inspect(): Promise<SubscriptionCapsuleAttestation>;
+    launch(input: Readonly<{
+        prompt: string;
+    }>): Promise<SubscriptionCapsuleLaunchResult>;
+}

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

@@ -0,0 +1,342 @@
+import type { Clock } from "../core/clock";
+import type { IdFactory } from "../core/ids";
+import { type Int64 } from "../core/int64";
+import type { ApprovalDecisionVerb, ApprovalRequestRecord, AttemptOutcome, AttemptRecord, RunRecord } from "../contracts/dtos";
+import { type AuthorityEvent } from "../contracts/events";
+import { type OperationResolution } from "../contracts/operations";
+import { type RunSpec } from "../contracts/runspec";
+import { type AccountsSlotEligibilityPort, type SlotEligibilityRequest } from "../ports/accounts";
+import { type InMemoryAccountsOperationSignerHistory } from "../ports/accounts-operation";
+import type { AuthoritySnapshot } from "./state";
+import { InMemoryAuthorityStore } from "./store";
+import { type AuthorityMutationJournalReceiptVerifier, type SynchronousAuthorityMutationJournalPort } from "./mutation-journal";
+export { mutationRequestHash } from "./mutation-tuple";
+export interface SubmitRunContext {
+    actorPrincipal: string;
+    operationId: string;
+    idempotencyKey: string;
+    authorityEpoch: Int64;
+    routeLineageId: string;
+    routeId: string;
+    routeEpoch: Int64;
+}
+export interface SubmitRunResult {
+    operation_id: string;
+    run_spec_id: string;
+    run_spec_digest: string;
+    run_id: string;
+    attempt_id: string;
+    attempt_number: number;
+    attempt_phase: string;
+    state: string;
+    run_revision: number;
+    attempt_revision: number;
+    authority_epoch: Int64;
+    route_epoch: Int64;
+    idempotency: {
+        replayed: boolean;
+    };
+}
+export interface ClaimAttemptInput {
+    schedulerPrincipal: string;
+    leaseHolderPrincipal: string;
+    audience: string;
+    lanePoolId: string;
+    leaseDurationMs: number;
+    operationId: string;
+    idempotencyKey: string;
+    authorityEpoch: Int64;
+    /** Exact Accounts v11 eligibility request carried into the claim authority decision. */
+    accountsEligibilityRequest: SlotEligibilityRequest;
+}
+export interface ClaimAttemptResult {
+    operation_id: string;
+    run_id: string;
+    project_id: string;
+    attempt_id: string;
+    attempt_number: number;
+    attempt_lease_id: string;
+    lease_epoch: Int64;
+    lease_holder_principal: string;
+    lease_expires_at: string;
+    run_revision: number;
+    attempt_revision: number;
+    eligibility_id: string;
+    lane_reservation_id: string;
+    idempotency: {
+        replayed: boolean;
+    };
+}
+export interface ExistingRunMutationContext {
+    actorPrincipal: string;
+    operationId: string;
+    idempotencyKey: string;
+    authorityEpoch: Int64;
+    expectedRunRevision: number;
+    attemptId: string;
+    attemptLeaseId?: string;
+    leaseEpoch?: Int64;
+}
+export interface PublicRunMutationContext extends ExistingRunMutationContext {
+    expectedAttemptNumber: number;
+    expectedAttemptRevision: number;
+}
+export interface AttemptTerminalContext extends ExistingRunMutationContext {
+    attemptLeaseId: string;
+    leaseEpoch: Int64;
+    outcome: AttemptOutcome;
+    reasonCode: string;
+}
+export interface RunMutationResult {
+    operation_id: string;
+    run_id: string;
+    attempt_id: string;
+    attempt_number: number;
+    state: string;
+    outcome: AttemptOutcome | null;
+    run_revision: number;
+    attempt_revision: number;
+    attempt_lease_id?: string;
+    lease_epoch?: Int64;
+    lease_holder_principal?: string;
+    lease_issued_at?: string;
+    lease_expires_at?: string;
+    lease_duration_ms?: number;
+    idempotency: {
+        replayed: boolean;
+    };
+}
+export interface HumanDiscardPresence {
+    verified: boolean;
+    decisionVerb: "discard_uncheckpointed";
+    challengeOperationId: string;
+    challengeRunId: string;
+    challengeAttemptId: string;
+    challengeConsequenceDigest: string;
+    expiresAt: string;
+}
+export interface DiscardConsequenceInput {
+    actorPrincipal: string;
+    operationId: string;
+    authorityEpoch: Int64;
+    routeLineageId: string;
+    routeId: string;
+    routeEpoch: Int64;
+    runId: string;
+    runRevision: number;
+    attemptId: string;
+    attemptLeaseId: string;
+    leaseEpoch: Int64;
+    abandonedArtifactDigests: string[];
+}
+export declare function computeDiscardConsequenceDigest(input: DiscardConsequenceInput): string;
+export interface DiscardContext extends ExistingRunMutationContext {
+    attemptLeaseId: string;
+    leaseEpoch: Int64;
+    abandonedArtifactDigests: string[];
+    humanPresence: HumanDiscardPresence;
+}
+export interface ApprovalProposalInput {
+    runId: string;
+    action: "create_broker_branch_and_pr";
+    operationDigest: string;
+    evidenceDigests: string[];
+    maximumEffect: "draft_pull_request";
+    requiredHumanRole: "repository_approver";
+    expiresAt: string;
+}
+export interface ApprovalRequestContext extends ExistingRunMutationContext {
+}
+export interface ApprovalDecisionPresence {
+    verified: boolean;
+    challengeVerb: ApprovalDecisionVerb;
+    challengeApprovalId: string;
+    challengeRevision: number;
+    challengeOperationId: string;
+    challengeOperationDigest: string;
+    challengeProposalDigest: string;
+    expiresAt: string;
+}
+export interface ApprovalDecisionContext {
+    actorPrincipal: string;
+    operationId: string;
+    idempotencyKey: string;
+    authorityEpoch: Int64;
+    expectedApprovalRevision: number;
+    humanPresence: ApprovalDecisionPresence;
+}
+export interface ApprovalResult {
+    operation_id: string;
+    approval_id: string;
+    run_id: string;
+    state: string;
+    decision_verb: ApprovalDecisionVerb | null;
+    proposal_digest: string;
+    revision: number;
+    idempotency: {
+        replayed: boolean;
+    };
+}
+export interface ConsumeApprovalContext {
+    actorPrincipal: string;
+    operationId: string;
+    idempotencyKey: string;
+    exactOperationDigest: string;
+    runId: string;
+    authorityEpoch: Int64;
+    attemptId: string;
+    attemptLeaseId?: string;
+    leaseEpoch?: Int64;
+    approvalRevision: number;
+}
+export interface ConsumeApprovalResult {
+    operation_id: string;
+    approval_id: string;
+    authorization_use_id: string;
+    idempotency: {
+        replayed: boolean;
+    };
+}
+export interface RunProjection {
+    run: RunRecord;
+    attempt: AttemptRecord;
+    run_spec: RunSpec;
+}
+export interface CapabilityProjection {
+    authority_epoch: Int64;
+    principal: string;
+    grants: readonly [];
+    capabilities: string[];
+}
+export interface RunWaitProjection extends RunProjection {
+    cursor: string;
+    terminal: boolean;
+    timed_out: boolean;
+}
+export interface RunEventPage {
+    items: AuthorityEvent[];
+    next_cursor: string;
+    has_more: boolean;
+    terminal: boolean;
+    timed_out: boolean;
+}
+export interface MaintenanceQuiescenceBlockers {
+    queued_attempt_ids: string[];
+    live_attempt_ids: string[];
+    live_lane_reservation_ids: string[];
+    reserved_budget_run_ids: string[];
+    budget_accounting_anomaly_codes: string[];
+    undelivered_outbox_ids: string[];
+    actionable_approval_ids: string[];
+    active_accounts_model_operation_ids: string[];
+}
+export interface MaintenanceQuiescenceReport {
+    schema_version: "infinity.maintenance-quiescence-report/v1";
+    checked_at: string;
+    quiescent: boolean;
+    blockers: MaintenanceQuiescenceBlockers;
+}
+export interface HumanApprovalAuthorizer {
+    isAuthorized(input: {
+        principal: string;
+        projectId: string;
+        role: "repository_approver";
+    }): boolean;
+}
+export declare class InMemoryRunAuthority {
+    private readonly store;
+    private readonly accounts;
+    private readonly clock;
+    private readonly ids;
+    private readonly humanApprovalAuthorizer;
+    private readonly mutationJournal;
+    private readonly mutationJournalVerifier;
+    private readonly authorityRestoreDomainId;
+    private readonly accountsOperationSignerHistory;
+    private readonly expectedMutationJournalProtection;
+    constructor(store: InMemoryAuthorityStore, accounts: AccountsSlotEligibilityPort, clock: Clock, ids: IdFactory, humanApprovalAuthorizer: HumanApprovalAuthorizer, mutationJournal: SynchronousAuthorityMutationJournalPort, mutationJournalVerifier: AuthorityMutationJournalReceiptVerifier, authorityRestoreDomainId: string, accountsOperationSignerHistory: InMemoryAccountsOperationSignerHistory);
+    validateRunSpec(input: unknown): {
+        valid: true;
+        authority_epoch: Int64;
+        run_spec: RunSpec;
+        run_spec_digest: string;
+    };
+    planRun(input: unknown): {
+        authority_epoch: Int64;
+        run_spec: RunSpec;
+        run_spec_digest: string;
+        budget_ceiling_minor_units: number;
+        required_approvals: string[];
+        denials: string[];
+    };
+    submitRun(input: unknown, context: SubmitRunContext): SubmitRunResult;
+    getRun(runIdInput: string, actorPrincipalInput: string): RunProjection;
+    listRuns(actorPrincipalInput: string, options?: {
+        limit?: number;
+        cursor?: string;
+    }): {
+        items: RunProjection[];
+        next_cursor: string | null;
+    };
+    listCapabilities(actorPrincipalInput: string): CapabilityProjection;
+    waitRun(runIdInput: string, actorPrincipalInput: string, timeoutMsInput: number): Promise<RunWaitProjection>;
+    readRunEvents(runIdInput: string, actorPrincipalInput: string, options: {
+        cursor: string;
+        limit: number;
+        waitMs: number;
+    }): Promise<RunEventPage>;
+    claimNextAttempt(input: ClaimAttemptInput): Promise<ClaimAttemptResult | null>;
+    recordAttemptTerminal(runIdInput: string, context: AttemptTerminalContext): RunMutationResult;
+    cancelRun(runIdInput: string, context: PublicRunMutationContext & {
+        reasonCode: string;
+    }): RunMutationResult;
+    retryRun(runIdInput: string, context: PublicRunMutationContext): RunMutationResult;
+    discardUncheckpointed(runIdInput: string, context: DiscardContext): RunMutationResult;
+    requestApproval(input: ApprovalProposalInput, context: ApprovalRequestContext): ApprovalResult;
+    decideApproval(approvalIdInput: string, decisionVerbInput: ApprovalDecisionVerb, context: ApprovalDecisionContext): ApprovalResult;
+    consumeApproval(approvalIdInput: string, context: ConsumeApprovalContext): ConsumeApprovalResult;
+    getApproval(approvalIdInput: string, actorPrincipalInput: string): {
+        approval: ApprovalRequestRecord;
+    };
+    listApprovals(runIdInput: string, actorPrincipalInput: string): {
+        items: ApprovalRequestRecord[];
+    };
+    resolveOperation(operationIdInput: string, actorPrincipalInput: string): OperationResolution;
+    snapshot(): AuthoritySnapshot;
+    maintenanceQuiescenceReport(): MaintenanceQuiescenceReport;
+    reconcileMutationJournal(): number;
+    private mutate;
+    private ensureMutationAcknowledged;
+    private assertMutationEnvelopeExternallyStored;
+    private assertExpectedMutationJournalProtection;
+    private guardedMutationJournalCall;
+    private assertExpectedMutationJournalAcknowledgement;
+    private readMutationJournalHead;
+    private readMutationJournalRange;
+    private appendMutationJournalEnvelope;
+    private withReplay;
+    private replayKnownMutation;
+    private appendEvent;
+    private parseExistingRunContext;
+    private requireCurrentRunAttempt;
+    private assertOwner;
+    private assertRunRevision;
+    private assertAttemptObservation;
+    private assertAttemptLease;
+    private assertLeaseSelector;
+    private hasAttemptLease;
+    private requiredLeaseEpoch;
+    private requiredAttemptLeaseId;
+    private staleLease;
+    private assertRouteCurrentInState;
+    private assertRunRouteCurrent;
+    private assertApprovalProposalCurrent;
+    private selectQueueCandidate;
+    private selectQueueCandidateInState;
+    private findFreeSlot;
+    private hasFreeSlot;
+    private validateEligibility;
+    private releaseLaneReservation;
+    private releaseBudget;
+    private runMutationResult;
+}