@hasna/infinity 0.1.0

package/dist/types/client/operator-client.d.ts

@@ -0,0 +1,100 @@
+import type { Int64 } from "../core/int64";
+export interface OperatorEnvelope {
+    schema_version: "infinity.operator/v1";
+    ok: boolean;
+    request_id: string;
+    command: string;
+    server_time: string;
+    operation_id?: string;
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        retry_after_ms: number | null;
+        details: Record<string, unknown>;
+        remediation: string;
+    };
+    warnings: unknown[];
+    next_actions: unknown[];
+}
+export declare function operatorEnvelopeHttpStatus(envelope: OperatorEnvelope): number | undefined;
+export declare function inheritOperatorEnvelopeHttpStatus(source: OperatorEnvelope, target: OperatorEnvelope): OperatorEnvelope;
+export interface SubmitRequest {
+    spec: unknown;
+    idempotencyKey: string;
+    operationId: string;
+    authorityEpoch: Int64;
+    routeLineageId: string;
+    routeId: string;
+    routeEpoch: Int64;
+}
+export interface ExistingRunRequest {
+    runId: string;
+    idempotencyKey: string;
+    operationId: string;
+    authorityEpoch: Int64;
+    ifRevision: number;
+    attemptId: string;
+    expectedAttemptNumber: number;
+    expectedAttemptRevision: number;
+    attemptLeaseId?: string;
+    leaseEpoch?: Int64;
+}
+export interface OperatorClient {
+    version(): Promise<OperatorEnvelope>;
+    doctor(): Promise<OperatorEnvelope>;
+    listCapabilities(): Promise<OperatorEnvelope>;
+    validateRun(spec: unknown): Promise<OperatorEnvelope>;
+    planRun(spec: unknown): Promise<OperatorEnvelope>;
+    submitRun(request: SubmitRequest): Promise<OperatorEnvelope>;
+    getRun(runId: string): Promise<OperatorEnvelope>;
+    listRuns(options: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<OperatorEnvelope>;
+    waitRun(runId: string, timeoutMs: number): Promise<OperatorEnvelope>;
+    readRunEvents(runId: string, options: {
+        cursor: string;
+        limit: number;
+        waitMs: number;
+    }): Promise<OperatorEnvelope>;
+    cancelRun(request: ExistingRunRequest & {
+        reasonCode: string;
+    }): Promise<OperatorEnvelope>;
+    retryRun(request: ExistingRunRequest): Promise<OperatorEnvelope>;
+    authorizeSandboxDispatch(request: unknown): Promise<OperatorEnvelope>;
+    dispatchProductionSandbox(request: unknown): Promise<OperatorEnvelope>;
+    resolveOperation(operationId: string): Promise<OperatorEnvelope>;
+}
+export declare class OperatorHttpClient implements OperatorClient {
+    private readonly fetchImpl;
+    private readonly endpoint;
+    constructor(endpoint: string, fetchImpl?: typeof fetch);
+    version(): Promise<OperatorEnvelope>;
+    doctor(): Promise<OperatorEnvelope>;
+    listCapabilities(): Promise<OperatorEnvelope>;
+    validateRun(spec: unknown): Promise<OperatorEnvelope>;
+    planRun(spec: unknown): Promise<OperatorEnvelope>;
+    submitRun(request: SubmitRequest): Promise<OperatorEnvelope>;
+    getRun(runId: string): Promise<OperatorEnvelope>;
+    listRuns(options: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<OperatorEnvelope>;
+    waitRun(runId: string, timeoutMs: number): Promise<OperatorEnvelope>;
+    readRunEvents(runId: string, options: {
+        cursor: string;
+        limit: number;
+        waitMs: number;
+    }): Promise<OperatorEnvelope>;
+    cancelRun(request: ExistingRunRequest & {
+        reasonCode: string;
+    }): Promise<OperatorEnvelope>;
+    retryRun(request: ExistingRunRequest): Promise<OperatorEnvelope>;
+    authorizeSandboxDispatch(request: unknown): Promise<OperatorEnvelope>;
+    dispatchProductionSandbox(request: unknown): Promise<OperatorEnvelope>;
+    resolveOperation(operationId: string): Promise<OperatorEnvelope>;
+    private request;
+}
+export declare function isOperatorPreReservationFailure(envelope: OperatorEnvelope): boolean;

package/dist/types/contracts/dtos.d.ts

@@ -0,0 +1,198 @@
+import type { RunSpec } from "./runspec";
+import type { Int64 } from "../core/int64";
+export type RunState = "admitted" | "active" | "cancel_requested" | "finalizing" | "succeeded" | "failed" | "canceled" | "lost_uncheckpointed" | "discarded_uncheckpointed";
+export type AttemptPhase = "queued" | "lane_leased" | "sandbox_allocating" | "running" | "checkpointed" | "verifying" | "finalizing" | "terminal";
+export type AttemptOutcome = "succeeded" | "failed_retryable" | "failed_permanent" | "canceled" | "lost_uncheckpointed" | "discarded_uncheckpointed" | "policy_denied" | "budget_exhausted";
+export type CancellationState = "none" | "requested" | "fenced" | "cleanup_pending" | "complete";
+export interface RunSpecRecord {
+    id: string;
+    digest: string;
+    canonical_spec: RunSpec;
+    schema_version: string;
+    canonicalization_version: string;
+    admitted_at: string;
+}
+export interface RunRecord {
+    id: string;
+    run_spec_id: string;
+    run_spec_digest: string;
+    route_lineage_id: string;
+    route_id: string;
+    route_epoch: Int64;
+    admitted_authority_epoch: Int64;
+    logical_work_key: string;
+    owner_principal: string;
+    project_id: string;
+    repository_id: string;
+    current_attempt_id: string;
+    state: RunState;
+    terminal_outcome: AttemptOutcome | null;
+    revision: number;
+    next_event_sequence: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface AttemptRecord {
+    id: string;
+    run_id: string;
+    attempt_number: number;
+    phase: AttemptPhase;
+    outcome: AttemptOutcome | null;
+    pending_outcome: AttemptOutcome | null;
+    runner_principal: string | null;
+    attempt_lease_id?: string;
+    lease_epoch?: Int64;
+    lease_holder_principal?: string;
+    lease_expires_at?: string;
+    cancellation_state: CancellationState;
+    retry_cause: string | null;
+    terminal_reason: string | null;
+    revision: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface AttemptLeaseGrant {
+    attempt_lease_id: string;
+    attempt_id: string;
+    run_id: string;
+    lease_epoch: Int64;
+    lease_holder_principal: string;
+    audience: string;
+    issued_at: string;
+    lease_expires_at: string;
+    grant_digest: string;
+    kind: "worker" | "cancel_recovery";
+}
+export interface AttemptLeaseEvent {
+    id: string;
+    attempt_lease_id: string;
+    attempt_id: string;
+    lease_epoch: Int64;
+    kind: "granted" | "renewed" | "fenced" | "released" | "expired";
+    actor_principal: string;
+    database_time: string;
+    detail_digest: string;
+}
+export interface QueueEntry {
+    attempt_id: string;
+    run_id: string;
+    project_id: string;
+    lane_pool_id: string;
+    enqueue_sequence: number;
+    admitted_at: string;
+    state: "queued" | "reserved" | "removed";
+}
+export interface LaneSlot {
+    lane_pool_id: string;
+    capacity_generation: Int64;
+    slot_index: number;
+    slot_id: string;
+}
+export interface LaneReservation {
+    id: string;
+    resource_id: string;
+    resource_lifecycle_generation: Int64;
+    slot_id: string;
+    attempt_id: string;
+    run_id: string;
+    route_epoch: Int64;
+    lease_epoch: Int64;
+    acquisition_operation_id: string;
+    slot_eligibility_request_digest: string;
+    slot_eligibility_id: string;
+    slot_eligibility_jcs_base64url: string;
+    slot_eligibility_digest: string;
+    access_target_digest: string;
+    effect_namespace_id: string;
+    provider_account_id: string;
+    owner_ref: string;
+    account_lane_id: string;
+    capacity_pool_id: string;
+    capacity_domain_ref: string;
+    serialization_key: string;
+    serialization_key_digest: string;
+    credential_family_id: string;
+    max_concurrency: Int64;
+    capacity_generation: Int64;
+    deny_generation: Int64;
+    credential_generation: Int64;
+    state: "reserved" | "released" | "fenced";
+    created_at: string;
+    updated_at: string;
+}
+export interface AdmissionKeyRecord {
+    route_lineage_id: string;
+    logical_work_key: string;
+    run_spec_digest: string;
+    run_id: string;
+    disposition: "admitted" | "tombstone";
+    created_at: string;
+}
+export interface IdempotencyRecord {
+    operation_id: string;
+    actor_principal: string;
+    command: string;
+    scope: string;
+    idempotency_key: string;
+    request_hash: string;
+    state: "in_flight" | "committed" | "aborted";
+    result: unknown;
+    created_at: string;
+    updated_at: string;
+}
+export type ApprovalState = "pending" | "approved" | "denied" | "consumed" | "expired" | "revoked";
+export type ApprovalDecisionVerb = "approve" | "deny";
+export interface ApprovalRequestRecord {
+    id: string;
+    run_id: string;
+    run_revision: number;
+    run_spec_digest: string;
+    route_lineage_id: string;
+    route_id: string;
+    route_epoch: Int64;
+    attempt_id: string;
+    attempt_lease_id?: string;
+    lease_epoch?: Int64;
+    expected_base_sha: string;
+    operation_digest: string;
+    proposal_digest: string;
+    action: "create_broker_branch_and_pr";
+    evidence_digests: string[];
+    maximum_effect: "draft_pull_request";
+    requester_principal: string;
+    required_human_role: "repository_approver";
+    expires_at: string;
+    state: ApprovalState;
+    decision_verb: ApprovalDecisionVerb | null;
+    decision_principal: string | null;
+    decision_operation_id: string | null;
+    revision: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface AuthorizationUseRecord {
+    id: string;
+    approval_id: string;
+    operation_id: string;
+    operation_digest: string;
+    actor_principal: string;
+    run_id: string;
+    attempt_id: string;
+    attempt_lease_id?: string;
+    lease_epoch?: Int64;
+    authority_epoch: Int64;
+    used_at: string;
+}
+export interface CheckpointRecord {
+    id: string;
+    run_id: string;
+    attempt_id: string;
+    seal_digest: string;
+    state: "sealed" | "integrity_failed";
+}
+export interface BudgetState {
+    limit_units: number;
+    reserved_units: number;
+    charged_units: number;
+    released_units: number;
+}

package/dist/types/contracts/events.d.ts

@@ -0,0 +1,45 @@
+import type { Int64 } from "../core/int64";
+export interface AuthorityEvent {
+    event_id: string;
+    authority_commit_sequence: Int64;
+    operation_id: string;
+    operation_digest: string;
+    aggregate_type: "run" | "approval" | "lane";
+    aggregate_id: string;
+    aggregate_sequence: number;
+    run_id: string | null;
+    run_sequence: number | null;
+    actor_principal: string;
+    authority_epoch: Int64;
+    route_lineage_id: string | null;
+    route_id: string | null;
+    route_epoch: Int64 | null;
+    attempt_id: string | null;
+    lease_epoch: Int64 | null;
+    attempt_lease_id: string | null;
+    lease_holder_principal: string | null;
+    audience: string | null;
+    resource_lease_id: string | null;
+    resource_id: string | null;
+    resource_lifecycle_generation: Int64 | null;
+    operation_executor_principal: string | null;
+    event_schema: "infinity.event/v1";
+    event_type: string;
+    payload: Record<string, unknown>;
+    payload_digest: string;
+    prior_event_digest: string | null;
+    event_digest: string;
+    database_time: string;
+}
+export interface OutboxRow {
+    id: string;
+    event_id: string;
+    destination: "projection";
+    projection_version: "v1";
+    outbox_identity_digest: string;
+    payload_digest: string;
+    state: "held" | "pending" | "leased" | "delivered" | "blocked";
+    authority_commit_sequence: Int64;
+    created_at: string;
+}
+export declare function eventDigest(event: AuthorityEvent): string;

package/dist/types/contracts/fence.d.ts

@@ -0,0 +1,39 @@
+import { type Int64 } from "../core/int64";
+export declare const BROKER_FENCE_FIELDS: readonly ["authority_epoch", "route_lineage_id", "route_id", "route_epoch", "run_id", "attempt_id", "attempt_lease_id", "lease_epoch", "lease_holder_principal", "resource_lease_id", "resource_id", "resource_lifecycle_generation", "operation_id", "operation_digest", "operation_execution_epoch", "actor_principal", "operation_executor_principal", "audience", "issued_at", "lease_expires_at", "operation_execution_expires_at"];
+export declare const BROKER_FENCE_SCHEMA_VERSION: "infinity.broker-fence.v1";
+export declare const BROKER_FENCE_WIRE_FIELDS: readonly ["schema_version", "authority_epoch", "route_lineage_id", "route_id", "route_epoch", "run_id", "attempt_id", "attempt_lease_id", "lease_epoch", "lease_holder_principal", "resource_lease_id", "resource_id", "resource_lifecycle_generation", "operation_id", "operation_digest", "operation_execution_epoch", "actor_principal", "operation_executor_principal", "audience", "issued_at", "lease_expires_at", "operation_execution_expires_at"];
+export declare const REJECTED_FENCE_ALIASES: readonly ["authority_generation", "authority_incarnation", "route_authority_epoch", "producer_epoch", "attempt_lease_epoch", "cancellation_generation", "allocation_generation", "lifecycle_revision"];
+export interface BrokerFenceInput {
+    schema_version: typeof BROKER_FENCE_SCHEMA_VERSION;
+    authority_epoch: Int64;
+    route_lineage_id: string;
+    route_id: string;
+    route_epoch: Int64;
+    run_id: string;
+    attempt_id: string;
+    attempt_lease_id: string;
+    lease_epoch: Int64;
+    lease_holder_principal: string;
+    resource_lease_id: string;
+    resource_id: string;
+    resource_lifecycle_generation: Int64;
+    operation_id: string;
+    operation_digest: string;
+    operation_execution_epoch: Int64;
+    actor_principal: string;
+    operation_executor_principal: string;
+    audience: string;
+    issued_at: string;
+    lease_expires_at: string;
+    operation_execution_expires_at: string;
+}
+export type BrokerFence = Readonly<BrokerFenceInput>;
+export declare function parseBrokerFence(value: unknown): BrokerFence;
+export interface AuthenticatedFenceContext {
+    databaseTime: Date;
+    actorPrincipal: string;
+    leaseHolderPrincipal: string;
+    operationExecutorPrincipal: string;
+    audience: string;
+}
+export declare function assertFenceCurrent(candidate: BrokerFence, current: BrokerFence, authenticated: AuthenticatedFenceContext): void;

package/dist/types/contracts/operations.d.ts

@@ -0,0 +1,91 @@
+import { type Int64 } from "../core/int64";
+import type { BrokerFence } from "./fence";
+export type ExternalOperationState = "planned" | "intent_committed" | "prepared" | "dispatched" | "succeeded" | "failed_effect" | "failed_no_effect" | "unknown" | "suppressed" | "quarantined";
+export interface ExternalOperation {
+    id: string;
+    kind: "sandbox_create_inert" | "sandbox_activate" | "checkpoint_seal" | "verification" | "promotion" | "typed_cleanup";
+    digest: string;
+    fence: BrokerFence;
+    broker_audience: string;
+    provider_idempotency_token: string;
+    operation_execution_epoch: Int64;
+    operation_executor_principal: string;
+    operation_execution_expires_at: string;
+    state: ExternalOperationState;
+    attempt_count: number;
+    not_after: string;
+    receipt_digests: string[];
+    reconciliation_result: "not_started" | "definitive" | "unknown_requires_review";
+}
+export type PublicMutationCommand = "run.submit" | "run.cancel" | "run.retry";
+export declare const MAX_POSTGRES_INTEGER = 2147483647;
+export declare const MAX_REVISION = 2147483647;
+export declare const MAX_MUTABLE_IF_REVISION: number;
+export declare const CANCEL_RECOVERY_LEASE_DURATION_MS = 300000;
+export type PublicMutationResultExpectation = {
+    command: "run.submit";
+    run_spec_digest: string;
+    authority_epoch: Int64;
+    route_epoch: Int64;
+} | {
+    command: "run.cancel";
+    run_id: string;
+    attempt_id: string;
+    attempt_number: number;
+    expected_run_revision: number;
+    expected_attempt_revision: number;
+    recovery_lease_duration_ms: typeof CANCEL_RECOVERY_LEASE_DURATION_MS;
+    prior_lease: {
+        state: "none";
+    } | {
+        state: "selected";
+        attempt_lease_id: string;
+        lease_epoch: Int64;
+    };
+} | {
+    command: "run.retry";
+    run_id: string;
+    predecessor_attempt_id: string;
+    expected_attempt_number: number;
+    expected_run_revision: number;
+};
+export interface OperationBinding {
+    command: string;
+    idempotency_key: string;
+    scope_digest: string;
+    request_hash: string;
+}
+export type OperationResolution = {
+    operation_id: string;
+    status: "unknown";
+} | {
+    operation_id: string;
+    status: "in_flight" | "aborted";
+    operation_binding: OperationBinding;
+} | {
+    operation_id: string;
+    status: "committed";
+    operation_binding: OperationBinding;
+    result: unknown;
+};
+export interface PublicOperationBinding extends OperationBinding {
+    command: PublicMutationCommand;
+}
+export type PublicOperationResolution = {
+    operation_id: string;
+    status: "unknown";
+} | {
+    operation_id: string;
+    status: "in_flight" | "aborted";
+    operation_binding: PublicOperationBinding;
+} | {
+    operation_id: string;
+    status: "committed";
+    operation_binding: PublicOperationBinding;
+    result: Readonly<Record<string, unknown>>;
+};
+export declare function isPublicMutationCommand(value: unknown): value is PublicMutationCommand;
+export declare function parsePublicMutationResultExpectation(value: unknown): Readonly<PublicMutationResultExpectation>;
+export declare function parsePublicMutationResult(command: PublicMutationCommand, value: unknown, expectedOperationId: string, expectation?: PublicMutationResultExpectation): Readonly<Record<string, unknown>>;
+export declare function assertStoredMutationResult(command: string, value: unknown, expectedOperationId: string, expectation?: PublicMutationResultExpectation): void;
+export declare function parsePublicOperationResolution(value: unknown, expectedOperationId: string, expectation?: PublicMutationResultExpectation): Readonly<PublicOperationResolution>;

package/dist/types/contracts/runspec.d.ts

@@ -0,0 +1,75 @@
+export interface RunSpecInput {
+    api_version: string;
+    kind: string;
+    canonicalization_version: string;
+    metadata: {
+        project_id: string;
+        logical_work_key: string;
+    };
+    source: {
+        repository_id: string;
+        object_format: string;
+        commit_sha: string;
+        expected_base_sha: string;
+    };
+    environment: {
+        image_digest: string;
+    };
+    policy: {
+        data_class: string;
+        capabilities?: string[];
+        network_policy_digest: string;
+        lane_policy_class: string;
+        budget: {
+            wall_time_ms: number;
+            resource_units: number;
+            cost_minor_units: number;
+        };
+        approval_policy_id: string;
+        retry_policy?: {
+            max_attempts: number;
+            retryable_reasons: string[];
+        };
+        cancellation_policy_id: string;
+        checkpoint_policy_id: string;
+        verification_policy_id: string;
+        cleanup_policy_id: string;
+        steering: {
+            allowed_media_types: string[];
+            max_bytes: number;
+        };
+        policy_decision_digest: string;
+        repository_automation_policy_digest: string;
+    };
+    task: {
+        input_artifacts?: Array<{
+            artifact_id: string;
+            digest: string;
+        }>;
+        expected_outputs: string[];
+        expected_evidence: string[];
+    };
+}
+export interface RunSpec extends Omit<RunSpecInput, "policy" | "task"> {
+    policy: Omit<RunSpecInput["policy"], "capabilities" | "retry_policy"> & {
+        capabilities: string[];
+        retry_policy: {
+            max_attempts: number;
+            retryable_reasons: string[];
+        };
+    };
+    task: Omit<RunSpecInput["task"], "input_artifacts"> & {
+        input_artifacts: Array<{
+            artifact_id: string;
+            digest: string;
+        }>;
+    };
+}
+/**
+ * Closed transport schema for tools that accept a RunSpec. Runtime admission
+ * still passes through strict JSON provenance and parseRunSpec; this schema is
+ * the fail-closed discovery contract, not a replacement for those checks.
+ */
+export declare const RUN_SPEC_INPUT_SCHEMA: Readonly<Record<string, unknown>>;
+export declare function parseRunSpec(value: unknown): Readonly<RunSpec>;
+export declare function runSpecDigest(spec: RunSpec): string;

package/dist/types/contracts/validators.d.ts

@@ -0,0 +1,8 @@
+import type { AttemptRecord, RunRecord } from "./dtos";
+import { type AuthorityEvent, type OutboxRow } from "./events";
+import { type ExternalOperation } from "./operations";
+export declare function parseRunRecord(value: unknown): Readonly<RunRecord>;
+export declare function parseAttemptRecord(value: unknown): Readonly<AttemptRecord>;
+export declare function parseExternalOperation(value: unknown): Readonly<ExternalOperation>;
+export declare function parseAuthorityEvent(value: unknown): Readonly<AuthorityEvent>;
+export declare function parseOutboxRow(value: unknown): Readonly<OutboxRow>;

package/dist/types/core/clock.d.ts

@@ -0,0 +1,12 @@
+export interface Clock {
+    now(): Date;
+}
+export declare class SystemClock implements Clock {
+    now(): Date;
+}
+export declare class FakeClock implements Clock {
+    private current;
+    constructor(current?: Date);
+    now(): Date;
+    advance(milliseconds: number): void;
+}

package/dist/types/core/errors.d.ts

@@ -0,0 +1,18 @@
+export type InfinityErrorCode = "invalid_input" | "not_found" | "idempotency_key_reused" | "operation_id_conflict" | "logical_work_conflict" | "authority_epoch_mismatch" | "stale_revision" | "stale_lease_epoch" | "state_conflict" | "policy_denied" | "approval_required" | "approval_digest_mismatch" | "capability_denied" | "integrity_failure" | "capacity_unavailable" | "protocol_incompatible" | "internal_error";
+export declare class InfinityError extends Error {
+    readonly code: InfinityErrorCode;
+    readonly status: number;
+    readonly retryable: boolean;
+    readonly details: Readonly<Record<string, unknown>>;
+    constructor(code: InfinityErrorCode, message: string, options?: {
+        status?: number;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export declare class SimulatedCrashError extends Error {
+    readonly stage: "before_commit" | "after_commit";
+    constructor(stage: "before_commit" | "after_commit");
+}
+export declare function invariant(condition: unknown, message: string): asserts condition;

package/dist/types/core/ids.d.ts

@@ -0,0 +1,10 @@
+export interface IdFactory {
+    next(prefix: string): string;
+}
+export declare class RandomIdFactory implements IdFactory {
+    next(prefix: string): string;
+}
+export declare class DeterministicIdFactory implements IdFactory {
+    private sequence;
+    next(prefix: string): string;
+}

package/dist/types/core/int64.d.ts

@@ -0,0 +1,7 @@
+export type Int64 = number | bigint;
+export declare const INT64_MAX = 9223372036854775807n;
+export declare function positiveInt64(value: unknown, label: string): Int64;
+export declare function nonnegativeInt64(value: unknown, label: string): Int64;
+export declare function incrementInt64(value: Int64, label: string): Int64;
+export declare function int64Compare(left: Int64, right: Int64): -1 | 0 | 1;
+export declare function int64Equal(left: Int64, right: Int64): boolean;

package/dist/types/core/strict-json.d.ts

@@ -0,0 +1,8 @@
+export type JsonPrimitive = null | boolean | number | bigint | string;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function parseStrictJson(source: string): JsonValue;
+export declare function assertStrictJsonDocument(value: unknown): asserts value is JsonValue;
+export declare function canonicalJson(value: unknown): string;
+export declare function digestCanonical(value: unknown): string;

package/dist/types/core/validation.d.ts

@@ -0,0 +1,25 @@
+import { InfinityError } from "./errors";
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function closedObject(value: unknown, label: string, required: readonly string[], optional?: readonly string[]): Record<string, unknown>;
+export declare function stringValue(value: unknown, label: string, options?: {
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+}): string;
+export declare const IDENTIFIER_PATTERN: RegExp;
+export declare const DIGEST_PATTERN: RegExp;
+export declare const CREDENTIAL_CARRIER_PATTERN_SOURCE = "^(?:[sS][kK]-[A-Za-z0-9]|[gG][hH][pPoOuUsSrR]_|[gG][iI][tT][hH][uU][bB]_[pP][aA][tT]_|[xX][oO][xX][bBaApPrRsS]-|[aA][kKsS][iI][aA][0-9A-Za-z]|[aA][iI][zZ][aA]|[nN][pP][mM]_|[xX][aA][iI]-|[cC][tT][xX]7[sS][kK]-)";
+export declare function identifier(value: unknown, label: string): string;
+export declare function digest(value: unknown, label: string): string;
+export declare function positiveInteger(value: unknown, label: string, maximum?: number): number;
+export declare function nonnegativeInteger(value: unknown, label: string, maximum?: number): number;
+export declare function enumValue<T extends string>(value: unknown, label: string, values: readonly T[]): T;
+export declare function stringArray(value: unknown, label: string, options?: {
+    maxItems?: number;
+    item?: (entry: unknown, label: string) => string;
+    allowEmpty?: boolean;
+}): string[];
+export declare function timestamp(value: unknown, label: string): string;
+export declare function invalid(message: string): InfinityError;
+export declare function deepClone<T>(value: T): T;
+export declare function deepFreeze<T>(value: T): T;