p2party 0.14.2 → 0.14.7

package/lib/blindRendezvous/localStableIdentityCustody.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Process-local custody for one persisted stable Ed25519 identity key.
+ *
+ * Trusted key storage constructs this handle from the secret key and its
+ * non-reused record revision. The public key is derived rather than accepted
+ * from the caller, so later receiver-key custody cannot bind an unrelated
+ * public identity. This internal module is absent from the package barrel.
+ */
+import type { LibCrypto } from "../cryptography/libcrypto";
+declare const localStableIdentityCustodyBrand: unique symbol;
+/** Opaque live custody for one exact persisted stable identity key record. */
+export interface LocalStableIdentityCustodyV1 {
+    readonly [localStableIdentityCustodyBrand]: true;
+}
+export interface CreateLocalStableIdentityCustodyOptionsV1 {
+    readonly module: LibCrypto;
+    readonly stableEd25519SecretKey: Uint8Array;
+    readonly localIdentityKeyRecordRevision: bigint;
+}
+export interface LocalStableIdentityCustodySnapshotV1 {
+    readonly version: 1;
+    readonly localStableEd25519PublicKey: Uint8Array;
+    readonly localIdentityKeyRecordRevision: bigint;
+}
+export declare class LocalStableIdentityCustodyError extends Error {
+    readonly name = "LocalStableIdentityCustodyError";
+    constructor(message: string);
+}
+/**
+ * Copy one stable secret and derive its public identity before minting custody.
+ *
+ * All caller-controlled values are captured before the first await. Mutating
+ * or wiping the caller's secret after invocation therefore cannot change the
+ * key held by the returned capability.
+ */
+export declare const createLocalStableIdentityCustodyV1: (options: CreateLocalStableIdentityCustodyOptionsV1) => Promise<LocalStableIdentityCustodyV1>;
+/** Return a fresh non-secret projection and assert that custody is still live. */
+export declare const snapshotLocalStableIdentityCustodyV1: (custody: LocalStableIdentityCustodyV1) => LocalStableIdentityCustodySnapshotV1;
+/**
+ * Wipe stable identity custody after its persisted key record is retired.
+ *
+ * Destruction is idempotent for a genuine handle. Dependent receiver custody
+ * retains the exact handle and therefore fails closed after this transition.
+ */
+export declare const destroyLocalStableIdentityCustodyV1: (custody: LocalStableIdentityCustodyV1) => void;
+export {};

package/lib/blindRendezvous/normativeKernel.d.ts

@@ -0,0 +1,222 @@
+/**
+ * Blind-rendezvous registry shape validators, intentionally absent from the
+ * package's public barrel.
+ *
+ * This module validates the logical shape of the kernel manifest, claim
+ * registry, claim evaluations, and formal-obligation records so separate tools
+ * cannot accept different registry shapes. It deliberately evaluates no claim
+ * and exposes no positive-wording authorizer.
+ *
+ * Every field table and closed enumeration below is now imported from
+ * `projections.ts`, which derives them from the canonical binary schema. The
+ * schema is the SSOT for bytes, widths, ordering, and bounds; this module owns
+ * only the cross-record reference, ordering, and acyclicity rules that a
+ * per-value encoding cannot express.
+ *
+ * The schema itself is still PROPOSED, not frozen: acquiring real protocol
+ * hashes additionally requires the Phase-0 freeze, deterministic vectors, and
+ * the module-8 resolver/evaluator.
+ */
+export type Bytes32 = Uint8Array;
+export type Uint16 = number;
+export type KernelModuleIdV1 = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export type KernelEntrypointIdV1 = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export interface KernelEntrypointV1 {
+    entrypointId: KernelEntrypointIdV1;
+    inputSchemaHash: Bytes32;
+    outputSchemaHash: Bytes32;
+    normativeSourceHash: Bytes32;
+}
+export interface ExecutableRendezvousKernelModuleV1 {
+    moduleId: KernelModuleIdV1;
+    entrypoints: readonly KernelEntrypointV1[];
+    executableArtifactHash: Bytes32;
+    normativeSourceTreeHash: Bytes32;
+    canonicalVectorSetHash: Bytes32;
+}
+export interface ExecutableRendezvousKernelManifestV1 {
+    version: 1;
+    canonicalBinarySchemaHash: Bytes32;
+    modules: readonly ExecutableRendezvousKernelModuleV1[];
+}
+export interface BlindRendezvousImplementationBuildManifestV1 {
+    version: 1;
+    releaseRegistryHash: Bytes32;
+    implementationArtifactSetDigest: Bytes32;
+    executableModuleArtifactHashes: readonly Bytes32[];
+    productionSchedulerArtifactHash: Bytes32;
+    canonicalTraceSetDigest: Bytes32;
+}
+export type ClaimEvaluationStateV1 = "not-implemented" | "not-evaluated" | "unknown" | "expired" | "failed" | "satisfied";
+export type ClaimScopeKindV1 = "release" | "deployment" | "room" | "carrier-instance" | "edge" | "r2-conformance-record";
+export interface ClaimAssumptionV1 {
+    assumptionId: Uint16;
+    kind: "cryptographic" | "protocol" | "deployment" | "environmental";
+    canonicalStatement: string;
+    verification: {
+        kind: "declared-foundational";
+    } | {
+        kind: "evidence-verified";
+        verifierEntrypointId: KernelEntrypointIdV1;
+    };
+}
+export interface ClaimEvidenceKindV1 {
+    evidenceKindId: Uint16;
+    canonicalSchemaHash: Bytes32;
+    verifierEntrypointId: KernelEntrypointIdV1;
+}
+export interface ClaimWordingByStateV1 {
+    notImplemented: Uint16;
+    notEvaluated: Uint16;
+    unknown: Uint16;
+    expired: Uint16;
+    failed: Uint16;
+    satisfied: Uint16;
+}
+export interface ClaimDefinitionV1 {
+    claimId: Uint16;
+    scopeKind: ClaimScopeKindV1;
+    scopeSchemaHash: Bytes32;
+    predicateEntrypointId: KernelEntrypointIdV1;
+    assumptionIds: readonly Uint16[];
+    requiredEvidenceKindIds: readonly Uint16[];
+    prerequisiteClaimIds: readonly Uint16[];
+    requiredFormalObligationIds: readonly Uint16[];
+    wordingIdByState: ClaimWordingByStateV1;
+    forbiddenWordingIds: readonly Uint16[];
+}
+export interface ClaimRegistryV1 {
+    version: 1;
+    assumptions: readonly ClaimAssumptionV1[];
+    evidenceKinds: readonly ClaimEvidenceKindV1[];
+    claims: readonly ClaimDefinitionV1[];
+    wordingCatalogHash: Bytes32;
+}
+export interface ClaimWordingCatalogV1 {
+    version: 1;
+    wording: readonly {
+        claimId: Uint16;
+        wordingId: Uint16;
+        state: ClaimEvaluationStateV1;
+        canonicalText: string;
+    }[];
+    reasons: readonly {
+        reasonId: Uint16;
+        canonicalText: string;
+    }[];
+}
+export interface ClaimEvidenceBindingV1 {
+    evidenceKindId: Uint16;
+    evidenceId: Bytes32;
+}
+export interface ClaimPrerequisiteBindingV1 {
+    claimId: Uint16;
+    evaluationDigest: Bytes32;
+}
+export interface ClaimFormalResultBindingV1 {
+    obligationId: Uint16;
+    resultDigest: Bytes32;
+}
+export type ClaimAssumptionBindingV1 = {
+    assumptionId: Uint16;
+    kind: "declared-foundational";
+} | {
+    assumptionId: Uint16;
+    kind: "evidence-verified";
+    evidenceId: Bytes32;
+};
+export interface ClaimEvaluationDatasetV1 {
+    version: 1;
+    releaseRegistryHash: Bytes32;
+    claimRegistryHash: Bytes32;
+    claimId: Uint16;
+    canonicalScope: Uint8Array;
+    assumptionBindings: readonly ClaimAssumptionBindingV1[];
+    evidenceBindings: readonly ClaimEvidenceBindingV1[];
+    prerequisiteBindings: readonly ClaimPrerequisiteBindingV1[];
+    formalResultBindings: readonly ClaimFormalResultBindingV1[];
+    evidenceSaturated: boolean;
+    firstSaturatedEvidenceId: Bytes32 | null;
+}
+export interface ClaimEvaluationInputV1 {
+    releaseRegistryHash: Bytes32;
+    claimRegistryHash: Bytes32;
+    claimId: Uint16;
+    scopeDigest: Bytes32;
+    evaluatedAtMs: bigint;
+    evaluationClockUncertaintyMs: bigint;
+    implementationPresent: boolean;
+    evaluationDatasetDigest: Bytes32;
+}
+export interface ClaimEvaluationV1 {
+    version: 1;
+    input: ClaimEvaluationInputV1;
+    state: ClaimEvaluationStateV1;
+    reasonIds: readonly Uint16[];
+    selectedWordingId: Uint16;
+    validThroughMs: bigint | null;
+}
+export interface CurrentClaimEvaluationRegistryRootsV1 {
+    releaseRegistryHash: Bytes32;
+    claimRegistryHash: Bytes32;
+}
+export type FormalObligationKindV1 = "algebraic" | "safety" | "liveness-refinement" | "computational-game";
+export interface FormalObligationV1 {
+    obligationId: Uint16;
+    kind: FormalObligationKindV1;
+    modelSourceHash: Bytes32;
+    propertySourceHash: Bytes32;
+    abstractionMapHash: Bytes32;
+    toolchainLockHash: Bytes32;
+    proofScopeSchemaHash: Bytes32;
+    scopeCoverageEntrypointId: KernelEntrypointIdV1;
+    assumptionIds: readonly Uint16[];
+}
+export interface FormalObligationRegistryV1 {
+    version: 1;
+    obligations: readonly FormalObligationV1[];
+}
+export interface FormalProofScopeArtifactV1 {
+    version: 1;
+    obligationId: Uint16;
+    canonicalScope: Uint8Array;
+}
+export interface FormalProofResultV1 {
+    version: 1;
+    releaseRegistryHash: Bytes32;
+    formalObligationRegistryHash: Bytes32;
+    obligationId: Uint16;
+    modelSourceHash: Bytes32;
+    propertySourceHash: Bytes32;
+    assumptionSetHash: Bytes32;
+    abstractionMapHash: Bytes32;
+    toolchainLockHash: Bytes32;
+    proofScopeDigest: Bytes32;
+    implementationArtifactSetDigest: Bytes32;
+    canonicalTraceSetDigest: Bytes32;
+    schedulerWorkloadDigest: Bytes32;
+    result: "proved-within-scope" | "counterexample" | "inconclusive";
+    proofArtifactDigest: Bytes32;
+    counterexampleTraceDigest: Bytes32 | null;
+}
+export interface FormalProofValidationContextV1 {
+    releaseRegistryHash: Bytes32;
+    formalObligationRegistryHash: Bytes32;
+    expectedAssumptionSetHash: Bytes32;
+}
+export declare const validateExecutableRendezvousKernelManifestV1: (manifest: ExecutableRendezvousKernelManifestV1) => void;
+export declare const validateClaimRegistryV1: (registry: ClaimRegistryV1) => void;
+export declare const validateFormalObligationRegistryV1: (registry: FormalObligationRegistryV1) => void;
+export declare const validateNormativeRegistriesV1: (manifest: ExecutableRendezvousKernelManifestV1, claimRegistry: ClaimRegistryV1, formalRegistry: FormalObligationRegistryV1) => void;
+/**
+ * Checks the v0.4 structural publication set. This is not cryptographic
+ * release conformance until a caller verifies canonically derived roots.
+ */
+export declare const validateV04ReleaseConformanceShapeV1: (manifest: ExecutableRendezvousKernelManifestV1, claimRegistry: ClaimRegistryV1, formalRegistry: FormalObligationRegistryV1) => void;
+/**
+ * Validates artifact shape and its binding to caller-supplied current roots.
+ * It deliberately does not verify evidence, run the predicate, or authorize
+ * claim wording.
+ */
+export declare const validateClaimEvaluationShapeV1: (evaluation: ClaimEvaluationV1, definition: ClaimDefinitionV1, currentRoots: CurrentClaimEvaluationRegistryRootsV1) => void;
+export declare const validateFormalProofResultV1: (result: FormalProofResultV1, obligation: FormalObligationV1, validationContext: FormalProofValidationContextV1) => void;

package/lib/blindRendezvous/operation.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The canonical authenticated room operation (Section 4.4).
+ *
+ * Outer validity is deliberately endpoint-independent: every room member can
+ * validate the canonical framing, author chain, lifetime, payload class, slot,
+ * and signature of any operation — including a `PAIR_STEP` addressed to two
+ * other members — so the same delivered bytes enter every member's core set.
+ * Pair AEAD and inner ledger rules are a separate edge-local step that can
+ * fail one edge without removing the operation from `CoreRoomState`. That
+ * split is what keeps another pair's private plaintext out of room convergence.
+ */
+import type { LibCrypto } from "../cryptography/libcrypto";
+import type { DecodedNonPairOperationPayloadV1 } from "./operationPayload";
+import type { PairStepEnvelopeV1 } from "./pairStepEnvelope";
+import type { RoomPolicyV4 } from "./roomPolicyV4";
+export type OperationKindV1 = "PRESENCE" | "LEAVE" | "PAIR_STEP" | "STORE_HINT" | "ADMISSION_REVOKE";
+export type OperationLifetimeV1 = "WINDOW_TRANSIENT" | "GRANT_HORIZON" | "PAIR_CAUSAL";
+export type OperationPayloadClassV1 = 0 | 1;
+export interface AuthenticatedRoomOperationV1 {
+    version: 1;
+    roomContextConfirmation: Uint8Array;
+    logicalWindow: bigint;
+    expiresAfterWindow: bigint;
+    lifetime: OperationLifetimeV1;
+    authorEpochEd25519Key: Uint8Array;
+    authorSequence: bigint;
+    previousAuthorOperationId: Uint8Array | null;
+    kind: OperationKindV1;
+    semanticSlot: Uint8Array;
+    dependencies: readonly Uint8Array[];
+    operationPayloadClass: OperationPayloadClassV1;
+    fixedPayload: Uint8Array;
+    operationPadding: Uint8Array;
+    authorSignature: Uint8Array;
+}
+export type UnsignedRoomOperationV1 = Omit<AuthenticatedRoomOperationV1, "authorSignature">;
+export declare class OperationValidationError extends Error {
+    readonly name = "OperationValidationError";
+    constructor(message: string);
+}
+/**
+ * Longest period for which exact signed bytes can still be needed as inert
+ * author/dependency evidence.
+ *
+ * A LEAVE can be created at the end of a presence's transient lifetime and
+ * itself remain transient for one full retention interval, hence the checked
+ * two-interval dependency bound. Pair-causal and authority horizons may be
+ * longer and share this one SSOT.
+ */
+export declare const requiredRoomRetentionWindows: (roomPolicy: RoomPolicyV4) => bigint;
+/**
+ * The numerically smallest permitted class whose frozen codec fits the payload
+ * (`OperationPayloadClassFor`). The sender must use it and the receiver
+ * recomputes it, so a larger-than-necessary class is noncanonical rather than
+ * merely wasteful — otherwise class choice would leak a sender-selectable
+ * signal into a fixed-size traffic model.
+ */
+export declare const operationPayloadClassFor: (kind: OperationKindV1, payloadBytes: number) => OperationPayloadClassV1;
+declare const operationValidationContextBrand: unique symbol;
+/**
+ * A process-local proof that one exact capability and one exact policy were
+ * used to derive this room context.
+ *
+ * The brand is backed by a private WeakMap, not by a caller-constructible
+ * property. This prevents a caller from pairing a real RoomContextId with a
+ * different policy and thereby changing admission semantics.
+ */
+export interface OperationValidationContext {
+    readonly [operationValidationContextBrand]: true;
+    /** Canonical local `RoomContextId`; never supplied by a carrier. */
+    readonly roomContextId: Uint8Array;
+    /** `RoomContextConfirmation` derived from the local room context. */
+    readonly roomContextConfirmation: Uint8Array;
+    readonly roomPolicy: RoomPolicyV4;
+    /** The explicit reference window; never ambient wall-clock time. */
+    readonly referenceWindow: bigint;
+}
+/**
+ * Initialize the sole trusted operation-validation context from room secret
+ * material. Neither the capability nor PolicyHash is retained or exposed.
+ */
+export declare const createOperationValidationContext: (capability: Uint8Array, roomPolicy: RoomPolicyV4, referenceWindow: bigint) => Promise<OperationValidationContext>;
+/**
+ * Rebind an initialized room to an explicit reference window without needing
+ * to expose or reload its capability.
+ */
+export declare const operationValidationContextAt: (context: OperationValidationContext, referenceWindow: bigint) => OperationValidationContext;
+/** Return an independently owned, still-branded copy for an async boundary. */
+export declare const snapshotOperationValidationContext: (context: OperationValidationContext) => OperationValidationContext;
+/**
+ * Public cheap structural gate.
+ *
+ * Its return type intentionally remains void: the decoded pair envelope is an
+ * internal validation artifact, not a value callers may treat as trusted
+ * without the semantic-slot and author-signature checks below.
+ */
+export declare const validateOperationStructure: (operation: AuthenticatedRoomOperationV1, context: OperationValidationContext) => void;
+/** Verify the author signature over the exact domain-separated transcript. */
+export declare const verifyOperationSignature: (operation: AuthenticatedRoomOperationV1, module?: LibCrypto) => Promise<boolean>;
+export type DecodedOperationPayloadV1 = DecodedNonPairOperationPayloadV1 | {
+    readonly kind: "PAIR_STEP";
+    readonly value: PairStepEnvelopeV1;
+};
+export declare const validateOperationOuter: (operation: AuthenticatedRoomOperationV1, context: OperationValidationContext, module?: LibCrypto) => Promise<PairStepEnvelopeV1 | null>;
+/**
+ * Authenticate a bounded reducer candidate.
+ *
+ * Unlike `validateOperationOuter`, this accepts exact outer-expired bytes only
+ * through the policy-derived inert evidence horizon. It still performs no
+ * nested payload signature work, so author quota/fork classification remains
+ * the first expensive-work boundary.
+ */
+export declare const validateOperationCandidateOuter: (operation: AuthenticatedRoomOperationV1, context: OperationValidationContext, module?: LibCrypto) => Promise<PairStepEnvelopeV1 | null>;
+/**
+ * Full intrinsic validation: authenticated outer candidate followed by the
+ * one nested payload codec selected by its signed kind.
+ *
+ * LEAVE's referenced-presence rule remains set-dependent and is completed by
+ * CoreReduce after the dependency is available.
+ */
+export declare const validateOperationAndDecodePayload: (operation: AuthenticatedRoomOperationV1, context: OperationValidationContext, module?: LibCrypto) => Promise<DecodedOperationPayloadV1>;
+/** Validate an operation without exposing its decoded payload artifact. */
+export declare const validateOperation: (operation: AuthenticatedRoomOperationV1, context: OperationValidationContext, module?: LibCrypto) => Promise<void>;
+/** Sign an operation over the exact transcript and return the signed form. */
+export declare const signOperation: (unsigned: UnsignedRoomOperationV1, authorSecretKey: Uint8Array, module?: LibCrypto) => Promise<AuthenticatedRoomOperationV1>;
+/** The unique canonical encoding of a signed operation. */
+export declare const encodeOperation: (operation: AuthenticatedRoomOperationV1) => Uint8Array;
+/** Decode and prove the bytes are the unique encoding of the result. */
+export declare const decodeOperation: (encoded: Uint8Array) => AuthenticatedRoomOperationV1;
+/**
+ * `OperationId`, derived only after carrier decryption and validation. It is
+ * never sent to a store as a logical identifier.
+ */
+export declare const deriveOperationId: (operation: AuthenticatedRoomOperationV1) => Promise<Uint8Array>;
+/** Build the all-zero padding a payload needs to reach its class length. */
+export declare const operationPaddingFor: (operationPayloadClass: OperationPayloadClassV1, payloadBytes: number) => Uint8Array;
+export {};

package/lib/blindRendezvous/operationPayload.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Closed non-pair operation payload codecs and intrinsic validation.
+ *
+ * The schema descriptors in `schemas.ts` are the byte SSOT. This module adds
+ * only rules that cannot be expressed by field widths alone: room/policy
+ * binding, interval containment, semantic-slot derivation, and signatures.
+ *
+ * A LEAVE's same-author/live-presence dependency is intentionally completed
+ * by `CoreReduce`, after the referenced operation is available. Rejecting a
+ * missing dependency here would make acceptance depend on carrier arrival
+ * order. Stable presence ownership is likewise verified only when a trusted
+ * local address-book key or the pair-private stable key is available.
+ */
+import type { LibCrypto } from "../cryptography/libcrypto";
+import type { AuthenticatedRoomOperationV1 } from "./operation";
+import type { CorePresenceFactV1 } from "./coreReduce";
+import type { RoomPolicyV4 } from "./roomPolicyV4";
+import type { StoreDescriptorV1, StoreRouteV1 } from "./storeDescriptor";
+export interface AdmissionGrantV1 {
+    version: 1;
+    roomContextId: Uint8Array;
+    stableEd25519PublicKey: Uint8Array;
+    generation: bigint;
+    issuedAtLogicalWindow: bigint;
+    notBeforeLogicalWindow: bigint;
+    notAfterLogicalWindow: bigint;
+    authoritySignature: Uint8Array;
+}
+export interface AdmissionRevokeV1 {
+    version: 1;
+    roomContextId: Uint8Array;
+    stableIdentityCommitment: Uint8Array;
+    minimumAcceptedGeneration: bigint;
+    effectiveLogicalWindow: bigint;
+    expiresAfterLogicalWindow: bigint;
+    authoritySignature: Uint8Array;
+}
+export interface PresenceCoreV1 {
+    version: 1;
+    stableIdentityCommitment: Uint8Array;
+    rendezvousHybridKemPublicKey: Uint8Array;
+    receiverKeyValidThroughLogicalWindow: bigint;
+    presenceNonce: Uint8Array;
+    validThroughLogicalWindow: bigint;
+}
+export interface PresencePermitV1 {
+    version: 1;
+    roomContextId: Uint8Array;
+    presenceProofTranscriptHash: Uint8Array;
+    permitSerial: Uint8Array;
+    generation: bigint;
+    issuedAtLogicalWindow: bigint;
+    notBeforeLogicalWindow: bigint;
+    notAfterLogicalWindow: bigint;
+    authoritySignature: Uint8Array;
+}
+export interface PresenceV1 {
+    core: PresenceCoreV1;
+    stableOwnershipSignature: Uint8Array;
+    authorityPermit: PresencePermitV1 | null;
+}
+export interface LeaveV1 {
+    version: 1;
+    presenceOperationId: Uint8Array;
+    effectiveLogicalWindow: bigint;
+}
+export interface StoreHintOperationV1 {
+    version: 1;
+    descriptor: StoreDescriptorV1;
+    routes: readonly StoreRouteV1[];
+    hintExpiresAfterLogicalWindow: bigint;
+}
+export type DecodedNonPairOperationPayloadV1 = {
+    readonly kind: "PRESENCE";
+    readonly value: PresenceV1;
+} | {
+    readonly kind: "LEAVE";
+    readonly value: LeaveV1;
+} | {
+    readonly kind: "STORE_HINT";
+    readonly value: StoreHintOperationV1;
+} | {
+    readonly kind: "ADMISSION_REVOKE";
+    readonly value: AdmissionRevokeV1;
+};
+export interface NonPairPayloadValidationContext {
+    readonly roomContextId: Uint8Array;
+    readonly roomPolicy: RoomPolicyV4;
+}
+export interface AdmissionGrantValidationContext extends NonPairPayloadValidationContext {
+    /** Logical window of the HELLO or ACCEPT carrying this grant. */
+    readonly carriedAtLogicalWindow: bigint;
+    readonly referenceWindow: bigint;
+}
+export declare class OperationPayloadValidationError extends Error {
+    readonly name = "OperationPayloadValidationError";
+    constructor(message: string);
+}
+export declare const encodeAdmissionGrantV1: (value: AdmissionGrantV1) => Uint8Array;
+export declare const decodeAdmissionGrantV1: (bytes: Uint8Array) => AdmissionGrantV1;
+export declare const encodeAdmissionRevokeV1: (value: AdmissionRevokeV1) => Uint8Array;
+export declare const decodeAdmissionRevokeV1: (bytes: Uint8Array) => AdmissionRevokeV1;
+export declare const encodePresenceV1: (value: PresenceV1) => Uint8Array;
+export declare const decodePresenceV1: (bytes: Uint8Array) => PresenceV1;
+export declare const encodeLeaveV1: (value: LeaveV1) => Uint8Array;
+export declare const decodeLeaveV1: (bytes: Uint8Array) => LeaveV1;
+export declare const encodeStoreHintOperationV1: (value: StoreHintOperationV1) => Uint8Array;
+export declare const decodeStoreHintOperationV1: (bytes: Uint8Array) => StoreHintOperationV1;
+/**
+ * Validate a pair-private admission grant at the one decision snapshot.
+ *
+ * This does not apply frontend allow/deny policy or a revocation floor. Those
+ * belong to the sole admission kernel after it has captured its trusted
+ * snapshot; this function proves only the grant's canonical authority facts.
+ */
+export declare const validateAdmissionGrantV1: (grant: AdmissionGrantV1, context: AdmissionGrantValidationContext, module?: LibCrypto) => Promise<void>;
+/**
+ * Verify the stable ownership proof once a trusted local lookup or pair flight
+ * supplies the exact stable public key. The key is deliberately absent from
+ * room-wide presence, so core validation cannot call this function itself.
+ */
+export declare const validatePresenceOwnershipV1: (operation: AuthenticatedRoomOperationV1, presence: PresenceV1, stableEd25519PublicKey: Uint8Array, context: NonPairPayloadValidationContext, module?: LibCrypto) => Promise<void>;
+/**
+ * Verify ownership directly from a trusted Core presence fact.
+ *
+ * Core already authenticated the outer operation and preserved every field
+ * used by the ownership transcript. This avoids fabricating an incomplete
+ * `AuthenticatedRoomOperationV1` merely to perform a local address-book
+ * lookup. The function proves only the signature/commitment relation; the
+ * caller must still obtain the fact from a genuine current or retained Core
+ * projection before treating it as admission evidence.
+ */
+export declare const validateCorePresenceFactOwnershipV1: (fact: CorePresenceFactV1, stableEd25519PublicKey: Uint8Array, context: NonPairPayloadValidationContext, module?: LibCrypto) => Promise<void>;
+export declare const decodeAndValidateNonPairOperationPayload: (operation: AuthenticatedRoomOperationV1, context: NonPairPayloadValidationContext, module?: LibCrypto) => Promise<DecodedNonPairOperationPayloadV1>;

package/lib/blindRendezvous/pairBootstrapSuite.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Constants-only registry for the complete pair-bootstrap suite selected by
+ * RoomPolicyV4 and encoded in PairBootstrapHeaderV1.
+ *
+ * This is the ID-to-cryptography SSOT. Schema geometry, policy validation,
+ * HPKE bootstrap, and established pair flights must project from this object
+ * rather than independently assigning meaning to suite ID 1.
+ */
+export declare const PAIR_BOOTSTRAP_SUITE_ID_V1 = 1;
+export declare const PAIR_BOOTSTRAP_SUITE_V1: Readonly<{
+    readonly id: 1;
+    readonly hybridKem: Readonly<{
+        readonly standardName: "MLKEM768-X25519";
+        readonly specification: "draft-irtf-cfrg-concrete-hybrid-kems-04";
+        readonly seedBytes: 32;
+        readonly publicKeyBytes: 1216;
+        readonly secretKeyBytes: 32;
+        readonly ciphertextBytes: 1120;
+        readonly sharedSecretBytes: 32;
+        readonly randomnessBytes: 64;
+    }>;
+    readonly hpke: Readonly<{
+        readonly specification: Readonly<{
+            kem: "draft-ietf-hpke-pq-05";
+            kemKeyDerivation: "draft-ietf-hpke-hpke-03";
+            keySchedule: "RFC 9180";
+        }>;
+        readonly kemId: 25722;
+        readonly kdfId: 1;
+        readonly aeadId: 3;
+        readonly publicKeyBytes: 1216;
+        readonly secretKeyBytes: 32;
+        readonly encapsulatedKeyBytes: 1120;
+        readonly sharedSecretBytes: 32;
+        readonly keyBytes: 32;
+        readonly nonceBytes: 12;
+        readonly tagBytes: 16;
+        readonly pskBytes: 32;
+        readonly pskIdBytes: 32;
+    }>;
+    readonly establishedPairAead: Readonly<{
+        standardName: "XChaCha20-Poly1305-IETF";
+        kdfId: 1;
+        keyBytes: number;
+        nonceBytes: number;
+        tagBytes: number;
+    }>;
+    readonly routingTagBytes: 32;
+}>;
+export declare const PAIR_BOOTSTRAP_SUITES_BY_ID: Readonly<{
+    readonly 1: Readonly<{
+        readonly id: 1;
+        readonly hybridKem: Readonly<{
+            readonly standardName: "MLKEM768-X25519";
+            readonly specification: "draft-irtf-cfrg-concrete-hybrid-kems-04";
+            readonly seedBytes: 32;
+            readonly publicKeyBytes: 1216;
+            readonly secretKeyBytes: 32;
+            readonly ciphertextBytes: 1120;
+            readonly sharedSecretBytes: 32;
+            readonly randomnessBytes: 64;
+        }>;
+        readonly hpke: Readonly<{
+            readonly specification: Readonly<{
+                kem: "draft-ietf-hpke-pq-05";
+                kemKeyDerivation: "draft-ietf-hpke-hpke-03";
+                keySchedule: "RFC 9180";
+            }>;
+            readonly kemId: 25722;
+            readonly kdfId: 1;
+            readonly aeadId: 3;
+            readonly publicKeyBytes: 1216;
+            readonly secretKeyBytes: 32;
+            readonly encapsulatedKeyBytes: 1120;
+            readonly sharedSecretBytes: 32;
+            readonly keyBytes: 32;
+            readonly nonceBytes: 12;
+            readonly tagBytes: 16;
+            readonly pskBytes: 32;
+            readonly pskIdBytes: 32;
+        }>;
+        readonly establishedPairAead: Readonly<{
+            standardName: "XChaCha20-Poly1305-IETF";
+            kdfId: 1;
+            keyBytes: number;
+            nonceBytes: number;
+            tagBytes: number;
+        }>;
+        readonly routingTagBytes: 32;
+    }>;
+}>;
+export type PairBootstrapSuiteIdV1 = keyof typeof PAIR_BOOTSTRAP_SUITES_BY_ID;
+export declare const getPairBootstrapSuite: (suiteId: number) => typeof PAIR_BOOTSTRAP_SUITE_V1;