sealed-lattice 0.0.10 → 0.0.12

package/README.md

@@ -2,6 +2,10 @@
 
 This package is the only published npm surface in the workspace.
 
-The current public runtime facade is intentionally empty. The package exists so
-packaging, documentation, smoke checks, and release workflow can stabilize
-before broader protocol-facing APIs are introduced.
+The current public runtime facade exposes the safe transcript core fixture
+verifier plus the threshold, lifecycle, poll specification, capability,
+board-consistency, target-finality, roster-manifest, cast receipt, close
+record, first-valid ordering, and recovery-epoch helpers. It does not expose raw
+hashing, object mutation, generic cryptography, ballots, local replay record
+checks, semantic target acceptance, decryption-share shell checks,
+decryption, or protocol internals.

package/dist/index.d.ts

@@ -1 +1,23 @@
-export {};
+import type { ActionCurrentForRecoveryEpochInput, ActionCurrentForRecoveryEpochResult, BoardConsistencyInput, BoardConsistencyVerification, CastReceiptVerification, CastReceiptVerificationInput, CapabilityContext, CapabilityDecision, CloseRecordVerification, CloseRecordVerificationInput, FirstValidOrderingInput, FirstValidOrderingVerification, FutureProtocolOperationResult, LifecycleLabelInput, LifecycleLabels, LifecycleTransition, PollSpecInput, PollSpecValidation, ProtocolAction, RecoveryEpochVerification, RecoveryEpochVerificationInput, ThresholdProfile, ThresholdProfileInput, TranscriptCoreFixture, TranscriptCoreVerificationResult, RosterManifestTranscriptInput, RosterManifestTranscriptVerification, RosterExternalAcceptanceVerification, RosterExternalAcceptanceVerificationInput, TargetFinalityVerification, TargetFinalityVerificationInput } from './internal/types.js';
+export type { AcceptedTargetFinalityCheckpoint, ActionContext, ActionCurrentForRecoveryEpochInput, ActionCurrentForRecoveryEpochResult, TargetBoundShareSelectionProfile, AppendOnlyConsistencyProof, BaseClaimProfile, BoardConsistencyInput, BoardConsistencyVerification, BoardEntryMerklePathStep, CanonicalError, CanonicalErrorCode, CanonicalSignedRootObject, CapabilityContext, CapabilityDecision, CastReceipt, CastReceiptVerification, CastReceiptVerificationInput, CloseRecord, CloseRecordKind, CloseRecordVerification, CloseRecordVerificationInput, ConflictingHeadEvidence, ConflictingManifestEvidence, DuplicateBallotPolicy, ElectionManifest, DecryptionShareFilteringMode, DecryptionShareSelectionRule, EvaluationProofMode, FailureStatusLabel, FirstValidOrderingInput, FirstValidOrderingVerification, FutureProtocolOperationResult, GoldenTranscriptCoreFixture, GoldenTranscriptCoreFixtureVerification, HeBackendCorruptionModel, InclusionProof, LifecycleLabelInput, LifecycleLabels, LifecycleState, LifecycleTransition, MalformedObjectFixture, MalformedObjectFixtureVerification, ManifestOpaqueBindings, ManifestPolicyDigests, MheSecurityClosure, MlDsaSignatureMode, MlDsaSignatureProfile, ModeStatusLabel, PollSpec, PollSpecInput, PollSpecValidation, PollSpecValidationError, PollSpecValidationErrorCode, PrimaryStatusLabel, ProtocolAction, ProtocolDigest, ProtocolObjectType, ProtocolRefusalCode, ProtocolSignatureEnvelope, ProtocolVerificationStatusLabel, ReceiverKeyRegistration, RecoveryEpochMapEntry, RecoveryEpochUpdate, RecoveryEpochVerification, RecoveryEpochVerificationInput, RecoveryState, RefusalReason, RefusalRecord, RegistrationEntry, ResultClaimLabel, RosterExternalAcceptance, RosterExternalAcceptanceVerification, RosterExternalAcceptanceVerificationInput, RosterManifestTranscriptInput, RosterManifestTranscriptVerification, RosterProfileKind, ScoreDomain, SignatureVerificationResult, SignedBoardHead, SignedObjectType, SignerRole, StructuredProtocolVerificationResult, TargetFinalityPolicy, TargetFinalityCheckpoint, TargetFinalityRecord, TargetFinalityVerification, TargetFinalityVerificationInput, TargetProposal, ThresholdProfile, ThresholdProfileInput, ThresholdWarning, TiePolicy, TranscriptCoreAnalysis, TranscriptCoreFixture, TranscriptCoreFixtureVerification, TranscriptCoreMheSecurityClosure, TranscriptCoreReplayFixture, TranscriptCoreStatusLabel, TranscriptCoreVerificationLabel, TranscriptCoreVerificationResult, TrusteeSetupEntry, ValidatedFirstValidObject, WitnessCheckpoint, WitnessPolicy, } from './internal/types.js';
+export declare const deriveThresholdProfile: (input: ThresholdProfileInput) => ThresholdProfile;
+export declare function validatePollSpec(input: PollSpecInput): PollSpecValidation;
+export declare function validatePollSpec(input: unknown): PollSpecValidation;
+export declare const isValidLifecycleTransition: (transition: LifecycleTransition) => boolean;
+export declare const deriveLifecycleLabels: (input: LifecycleLabelInput) => LifecycleLabels;
+export declare const evaluateActionCapability: (action: ProtocolAction, context: CapabilityContext) => CapabilityDecision;
+export declare const verifyTranscript: () => FutureProtocolOperationResult;
+export declare const createBridgeProof: () => FutureProtocolOperationResult;
+export declare const verifyBridgeProof: () => FutureProtocolOperationResult;
+export declare const verifyOneShotSharePolicy: () => FutureProtocolOperationResult;
+export declare const verifyBoardConsistency: (input: BoardConsistencyInput) => BoardConsistencyVerification;
+export declare const verifyCastReceiptShell: (input: CastReceiptVerificationInput) => CastReceiptVerification;
+export declare const verifyCloseRecordShell: (input: CloseRecordVerificationInput) => CloseRecordVerification;
+export declare const verifyTargetFinality: (input: TargetFinalityVerificationInput) => TargetFinalityVerification;
+export declare const deriveValidatedFirstValidOrder: (input: FirstValidOrderingInput) => FirstValidOrderingVerification;
+export declare const verifyFirstValidPolicy: (input: FirstValidOrderingInput) => FirstValidOrderingVerification;
+export declare const verifyRosterExternalAcceptance: (input: RosterExternalAcceptanceVerificationInput) => RosterExternalAcceptanceVerification;
+export declare const verifyRosterManifestTranscript: (input: RosterManifestTranscriptInput) => RosterManifestTranscriptVerification;
+export declare const isActionCurrentForRecoveryEpoch: (input: ActionCurrentForRecoveryEpochInput) => ActionCurrentForRecoveryEpochResult;
+export declare const verifyRecoveryEpochUpdate: (input: RecoveryEpochVerificationInput) => RecoveryEpochVerification;
+export declare const verifyTranscriptCoreFixture: (fixture: TranscriptCoreFixture) => Promise<TranscriptCoreVerificationResult>;

package/dist/index.js

@@ -1,2 +1,58 @@
-export {};
+import { deriveValidatedFirstValidOrder as deriveValidatedFirstValidOrderInternal, deriveLifecycleLabels as deriveLifecycleLabelsInternal, deriveThresholdProfile as deriveThresholdProfileInternal, evaluateActionCapability as evaluateActionCapabilityInternal, verifyCastReceiptShell as verifyCastReceiptShellInternal, verifyCloseRecordShell as verifyCloseRecordShellInternal, isValidLifecycleTransition as isValidLifecycleTransitionInternal, isActionCurrentForRecoveryEpoch as isActionCurrentForRecoveryEpochInternal, validatePollSpec as validatePollSpecInternal, verifyBoardConsistency as verifyBoardConsistencyInternal, verifyFirstValidPolicy as verifyFirstValidPolicyInternal, verifyRecoveryEpochUpdate as verifyRecoveryEpochUpdateInternal, verifyRosterExternalAcceptance as verifyRosterExternalAcceptanceInternal, verifyRosterManifestTranscript as verifyRosterManifestTranscriptInternal, verifyTargetFinality as verifyTargetFinalityInternal, } from './internal/election-foundation/index.js';
+import { loadTranscriptCoreKernel } from './kernel.js';
+export const deriveThresholdProfile = (input) => deriveThresholdProfileInternal(input);
+export function validatePollSpec(input) {
+    return validatePollSpecInternal(input);
+}
+export const isValidLifecycleTransition = (transition) => isValidLifecycleTransitionInternal(transition);
+export const deriveLifecycleLabels = (input) => deriveLifecycleLabelsInternal(input);
+export const evaluateActionCapability = (action, context) => evaluateActionCapabilityInternal(action, context);
+const unavailableFutureProtocolOperation = (operation) => ({
+    ok: false,
+    statusLabels: [],
+    acceptedDigests: [],
+    refusedObjects: [
+        {
+            code: 'OperationUnavailable',
+            message: `${operation} is reserved for later protocol implementation and is not implemented in this package version.`,
+        },
+    ],
+    unresolvedReason: 'OperationUnavailable',
+    operation,
+});
+export const verifyTranscript = () => unavailableFutureProtocolOperation('verifyTranscript');
+export const createBridgeProof = () => unavailableFutureProtocolOperation('createBridgeProof');
+export const verifyBridgeProof = () => unavailableFutureProtocolOperation('verifyBridgeProof');
+export const verifyOneShotSharePolicy = () => unavailableFutureProtocolOperation('verifyOneShotSharePolicy');
+export const verifyBoardConsistency = (input) => verifyBoardConsistencyInternal(input);
+export const verifyCastReceiptShell = (input) => verifyCastReceiptShellInternal(input);
+export const verifyCloseRecordShell = (input) => verifyCloseRecordShellInternal(input);
+export const verifyTargetFinality = (input) => verifyTargetFinalityInternal(input);
+export const deriveValidatedFirstValidOrder = (input) => deriveValidatedFirstValidOrderInternal(input);
+export const verifyFirstValidPolicy = (input) => verifyFirstValidPolicyInternal(input);
+export const verifyRosterExternalAcceptance = (input) => verifyRosterExternalAcceptanceInternal(input);
+export const verifyRosterManifestTranscript = (input) => verifyRosterManifestTranscriptInternal(input);
+export const isActionCurrentForRecoveryEpoch = (input) => isActionCurrentForRecoveryEpochInternal(input);
+export const verifyRecoveryEpochUpdate = (input) => verifyRecoveryEpochUpdateInternal(input);
+export const verifyTranscriptCoreFixture = async (fixture) => {
+    const kernel = await loadTranscriptCoreKernel();
+    const verification = kernel.verifyFixture(fixture);
+    if ('expectedErrorCode' in verification) {
+        return {
+            caseName: verification.caseName,
+            label: 'TranscriptCoreRejected',
+            statusLabels: [],
+            rejection: {
+                code: verification.expectedErrorCode,
+            },
+        };
+    }
+    return {
+        caseName: verification.caseName,
+        label: 'TranscriptCoreVerified',
+        objectHash512: verification.objectHash512,
+        chunkRoot: verification.chunkRoot,
+        statusLabels: verification.statusLabels,
+    };
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/internal/board-target.d.ts

@@ -0,0 +1,325 @@
+import type { ProtocolDigest } from './protocol-digest.js';
+import type { ConflictingHeadEvidence, ProtocolObjectType, ProtocolSignatureEnvelope, StructuredProtocolVerificationResult } from './protocol-objects.js';
+export type SignedBoardHead = {
+    readonly objectType: 'BoardHead';
+    readonly objectVersion: 1;
+    readonly headDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly boardSequence: number;
+    readonly boardRoot: ProtocolDigest;
+    readonly previousHeadDigest: ProtocolDigest | null;
+    readonly boardPolicyDigest: ProtocolDigest;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type BoardEntryMerklePathStep = {
+    readonly siblingPosition: 'Left' | 'Right';
+    readonly siblingDigest: ProtocolDigest;
+};
+export type InclusionProof = {
+    readonly boardHeadDigest: ProtocolDigest;
+    readonly boardSequence: number;
+    readonly boardPosition: number;
+    readonly includedObjectType: ProtocolObjectType;
+    readonly includedObjectDigest: ProtocolDigest;
+    readonly boardEntryDigest: ProtocolDigest;
+    readonly boardRoot: ProtocolDigest;
+    readonly boardEntryCount?: number;
+    readonly boardEntryMerklePath?: readonly BoardEntryMerklePathStep[];
+    readonly boardEntryDigests?: readonly ProtocolDigest[];
+    readonly inclusionProofDigest: ProtocolDigest;
+};
+export type AppendOnlyConsistencyProof = {
+    readonly proofType: 'SignedHeadChain';
+    readonly fromBoardHeadDigest: ProtocolDigest | null;
+    readonly toBoardHeadDigest: ProtocolDigest;
+    readonly signedBoardHeads: readonly SignedBoardHead[];
+};
+export type BoardConsistencyInput = {
+    readonly ceremonyId: string;
+    readonly boardPolicyDigest: ProtocolDigest;
+    readonly signedBoardHeads: readonly SignedBoardHead[];
+    readonly expectedBoardPublicKeyDigest: ProtocolDigest;
+    readonly inclusionProofs?: readonly InclusionProof[];
+    readonly consistencyProofs?: readonly AppendOnlyConsistencyProof[];
+    readonly conflictingHeadEvidence?: readonly ConflictingHeadEvidence[];
+};
+export type BoardConsistencyVerification = StructuredProtocolVerificationResult & {
+    readonly verifiedHeadDigests: readonly ProtocolDigest[];
+};
+export type CastReceipt = {
+    readonly objectType: 'CastReceipt';
+    readonly objectVersion: 1;
+    readonly castReceiptDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly voterIdentity: string;
+    readonly ballotPackageDigest: ProtocolDigest;
+    readonly boardSequence: number;
+    readonly boardPosition: number;
+    readonly recoveryEpoch: number;
+    readonly deviceEpoch: number;
+    readonly contextDigest: ProtocolDigest;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type CloseRecordKind = 'RegistrationClosed' | 'VotingClosed';
+export type CloseRecord = {
+    readonly objectType: 'CloseRecord';
+    readonly objectVersion: 1;
+    readonly closeRecordDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly closeKind: CloseRecordKind;
+    readonly closedBoardHeadDigest: ProtocolDigest;
+    readonly postVotingClosedContextDigest: ProtocolDigest | null;
+    readonly boardSequence: number;
+    readonly boardPosition: number;
+    readonly organizerIdentity: string;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type CastReceiptVerificationInput = {
+    readonly boardEvidence: BoardConsistencyInput;
+    readonly receipt: CastReceipt;
+    readonly receiptInclusionProof: InclusionProof;
+    readonly expectedElectionManifestDigest: ProtocolDigest;
+    readonly expectedVoterPublicKeyDigest: ProtocolDigest;
+};
+export type CastReceiptVerification = StructuredProtocolVerificationResult & {
+    readonly castReceiptDigest?: ProtocolDigest;
+};
+export type CloseRecordVerificationInput = {
+    readonly boardEvidence: BoardConsistencyInput;
+    readonly closeRecord: CloseRecord;
+    readonly closeRecordInclusionProof: InclusionProof;
+    readonly expectedElectionManifestDigest: ProtocolDigest;
+    readonly expectedOrganizerIdentity: string;
+    readonly expectedOrganizerPublicKeyDigest: ProtocolDigest;
+};
+export type CloseRecordVerification = StructuredProtocolVerificationResult & {
+    readonly closeRecordDigest?: ProtocolDigest;
+    readonly postVotingClosedContextDigest?: ProtocolDigest;
+};
+export type WitnessPolicy = {
+    readonly witnessPolicyDigest: ProtocolDigest;
+    readonly witnessIdentities: readonly string[];
+    readonly witnessQuorum: number;
+    readonly totalWitnesses: number;
+};
+export type TargetFinalityPolicy = {
+    readonly targetFinalityPolicyDigest: ProtocolDigest;
+    readonly targetFinalityScope: string;
+    readonly witnessQuorum: number;
+    readonly totalWitnesses: number;
+};
+export type TargetProposal = {
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly evaluationContextDigest: ProtocolDigest;
+    readonly topKEvaluationRecordDigest: ProtocolDigest;
+    readonly topKCiphertextDigest: ProtocolDigest;
+    readonly publicSlotMaskDigest: ProtocolDigest;
+    readonly targetCiphertextDigest: ProtocolDigest;
+    readonly targetLayoutDigest: ProtocolDigest;
+    readonly evaluationProofProfileDigest: ProtocolDigest;
+    readonly targetFinalityPolicyDigest: ProtocolDigest;
+};
+export type TargetFinalityCheckpoint = TargetProposal & {
+    readonly objectType: 'TargetFinalityCheckpoint';
+    readonly objectVersion: 1;
+    readonly targetFinalityCheckpointDigest: ProtocolDigest;
+    readonly boardPolicyDigest: ProtocolDigest;
+    readonly finalizedBoardHeadDigest: ProtocolDigest;
+    readonly witnessPolicyDigest: ProtocolDigest;
+};
+export type WitnessCheckpoint = {
+    readonly objectType: 'WitnessCheckpoint';
+    readonly objectVersion: 1;
+    readonly checkpointDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly targetFinalityScope: string;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly targetFinalityCheckpointDigest: ProtocolDigest;
+    readonly witnessPolicyDigest: ProtocolDigest;
+    readonly targetFinalityPolicyDigest: ProtocolDigest;
+    readonly witnessIdentity: string;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type TargetFinalityRecord = {
+    readonly objectType: 'TargetFinalityRecord';
+    readonly objectVersion: 1;
+    readonly targetFinalityRecordDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly targetFinalityScope: string;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly targetFinalityCheckpoint: TargetFinalityCheckpoint;
+    readonly witnessPolicyDigest: ProtocolDigest;
+    readonly targetFinalityPolicyDigest: ProtocolDigest;
+    readonly inclusionProof: InclusionProof;
+    readonly witnessCheckpoints: readonly WitnessCheckpoint[];
+};
+export type TargetFinalityVerificationInput = {
+    readonly boardEvidence: BoardConsistencyInput;
+    readonly record: TargetFinalityRecord;
+    readonly targetFinalityPolicy: TargetFinalityPolicy;
+    readonly witnessPolicy: WitnessPolicy;
+    readonly witnessPublicKeyDigests: Readonly<Record<string, ProtocolDigest>>;
+    readonly conflictingRecords?: readonly TargetFinalityRecord[];
+};
+export type TargetFinalityVerification = StructuredProtocolVerificationResult & {
+    readonly targetFinalityRecordDigest?: ProtocolDigest;
+    readonly targetProposalDigest?: ProtocolDigest;
+    readonly targetFinalityCheckpointDigest?: ProtocolDigest;
+    readonly validWitnessIdentities: readonly string[];
+    readonly equivocatingWitnessIdentities: readonly string[];
+};
+export type AcceptedTargetFinalityCheckpoint = {
+    readonly targetFinalityRecordDigest: ProtocolDigest;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly targetFinalityCheckpointDigest: ProtocolDigest;
+    readonly finalizedBoardHeadDigest: ProtocolDigest;
+    readonly topKEvaluationRecordDigest: ProtocolDigest;
+    readonly evaluationContextDigest: ProtocolDigest;
+    readonly topKCiphertextDigest: ProtocolDigest;
+    readonly publicSlotMaskDigest: ProtocolDigest;
+    readonly targetCiphertextDigest: ProtocolDigest;
+    readonly targetLayoutDigest: ProtocolDigest;
+    readonly evaluationProofProfileDigest: ProtocolDigest;
+    readonly targetFinalityScope: string;
+    readonly witnessPolicyDigest: ProtocolDigest;
+    readonly targetFinalityPolicyDigest: ProtocolDigest;
+};
+export type EvaluationProofRecord = {
+    readonly objectType: 'EvaluationProofRecord';
+    readonly objectVersion: 1;
+    readonly evaluationProofRecordDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly topKEvaluationRecordDigest: ProtocolDigest;
+    readonly targetFinalityRecordDigest: ProtocolDigest;
+    readonly evaluationProofProfileDigest: ProtocolDigest;
+    readonly evaluationContextDigest: ProtocolDigest;
+    readonly topKCiphertextDigest: ProtocolDigest;
+    readonly publicSlotMaskDigest: ProtocolDigest;
+    readonly targetCiphertextDigest: ProtocolDigest;
+    readonly targetLayoutDigest: ProtocolDigest;
+    readonly proofRoot: ProtocolDigest;
+    readonly boardSequence: number;
+    readonly boardPosition: number;
+};
+export type LocalReplayRecord = {
+    readonly objectType: 'LocalReplayRecord';
+    readonly objectVersion: 1;
+    readonly localReplayRecordDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly participantIdentity: string;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly targetFinalityRecordDigest: ProtocolDigest;
+    readonly evaluationProofRecordDigest: ProtocolDigest;
+    readonly replayContextDigest: ProtocolDigest;
+    readonly recoveryEpoch: number;
+    readonly deviceEpoch: number;
+    readonly mobileReplayCertDigest: ProtocolDigest;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type TargetAcceptedRecord = {
+    readonly objectType: 'TargetAcceptedRecord';
+    readonly objectVersion: 1;
+    readonly targetAcceptedRecordDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly targetFinalityScope: string;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly topKEvaluationRecordDigest: ProtocolDigest;
+    readonly targetContextDigest: ProtocolDigest;
+    readonly targetFinalityRecordDigest: ProtocolDigest;
+    readonly targetFinalityCheckpointDigest: ProtocolDigest;
+    readonly evaluationProofRecordDigest: ProtocolDigest;
+    readonly evaluationProofProfileDigest: ProtocolDigest;
+    readonly targetPreimageDigest: ProtocolDigest;
+    readonly targetCiphertextDigest: ProtocolDigest;
+    readonly targetLayoutDigest: ProtocolDigest;
+    readonly cpadProfileDigest: ProtocolDigest;
+    readonly cpadProfileId: string;
+    readonly thresholdDecryptionProfileDigest: ProtocolDigest;
+    readonly thresholdDecryptionProfileId: string;
+    readonly bgvAsyncThresholdCPADProfileDigest: ProtocolDigest;
+    readonly targetBasisDigest: ProtocolDigest;
+    readonly acceptanceMode: 'evaluation-proof';
+    readonly boardSequence: number;
+    readonly boardPosition: number;
+    readonly organizerIdentity: string;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type TopKDecryptionShareShell = {
+    readonly objectType: 'TopKDecryptionShare';
+    readonly objectVersion: 1;
+    readonly topKDecryptionShareDigest: ProtocolDigest;
+    readonly ceremonyId: string;
+    readonly electionManifestDigest: ProtocolDigest;
+    readonly trusteeIdentity: string;
+    readonly targetAcceptedRecordDigest: ProtocolDigest;
+    readonly targetProposalDigest: ProtocolDigest;
+    readonly targetPreimageDigest: ProtocolDigest;
+    readonly targetFinalityRecordDigest: ProtocolDigest;
+    readonly targetFinalityCheckpointDigest: ProtocolDigest;
+    readonly evaluationProofRecordDigest: ProtocolDigest;
+    readonly topKEvaluationRecordDigest: ProtocolDigest;
+    readonly targetContextDigest: ProtocolDigest;
+    readonly targetCiphertextDigest: ProtocolDigest;
+    readonly cpadProfileDigest: ProtocolDigest;
+    readonly thresholdDecryptionProfileDigest: ProtocolDigest;
+    readonly bgvAsyncThresholdCPADProfileDigest: ProtocolDigest;
+    readonly targetDecryptionPreparationRecordDigest: ProtocolDigest;
+    readonly targetDecryptionCiphertextDigest: ProtocolDigest;
+    readonly targetBasisDigest: ProtocolDigest;
+    readonly thresholdShareVerificationKeyRoot: ProtocolDigest;
+    readonly thresholdShareVerificationKeyDigest: ProtocolDigest;
+    readonly trusteeThresholdVerificationKeyDigest: ProtocolDigest;
+    readonly boardSequence: number;
+    readonly boardPosition: number;
+    readonly recoveryEpoch: number;
+    readonly deviceEpoch: number;
+    readonly shareRoot: ProtocolDigest;
+    readonly signature: ProtocolSignatureEnvelope;
+};
+export type LocalReplayRecordVerificationInput = {
+    readonly boardEvidence: BoardConsistencyInput;
+    readonly record: LocalReplayRecord;
+    readonly recordInclusionProof: InclusionProof;
+    readonly targetFinalityRecord: TargetFinalityRecord;
+    readonly targetFinalityVerification: TargetFinalityVerification;
+    readonly evaluationProofRecord: EvaluationProofRecord;
+    readonly expectedSignerPublicKeyDigest: ProtocolDigest;
+};
+export type LocalReplayRecordVerification = StructuredProtocolVerificationResult & {
+    readonly localReplayRecordDigest?: ProtocolDigest;
+    readonly targetFinalityRecordDigest?: ProtocolDigest;
+};
+export type TargetAcceptedRecordVerificationInput = {
+    readonly boardEvidence: BoardConsistencyInput;
+    readonly targetAcceptedRecord: TargetAcceptedRecord;
+    readonly targetAcceptedRecordInclusionProof: InclusionProof;
+    readonly targetFinalityRecord: TargetFinalityRecord;
+    readonly targetFinalityVerification: TargetFinalityVerification;
+    readonly evaluationProofRecord: EvaluationProofRecord;
+    readonly expectedOrganizerPublicKeyDigest: ProtocolDigest;
+};
+export type TargetAcceptedRecordVerification = StructuredProtocolVerificationResult & {
+    readonly targetAcceptedRecordDigest?: ProtocolDigest;
+    readonly targetFinalityRecordDigest?: ProtocolDigest;
+};
+export type TopKDecryptionShareShellVerificationInput = {
+    readonly boardEvidence: BoardConsistencyInput;
+    readonly decryptionShare: TopKDecryptionShareShell;
+    readonly decryptionShareInclusionProof: InclusionProof;
+    readonly targetAcceptedRecord: TargetAcceptedRecord;
+    readonly targetAcceptedRecordVerification: TargetAcceptedRecordVerification;
+    readonly expectedTrusteePublicKeyDigest: ProtocolDigest;
+};
+export type TopKDecryptionShareShellVerification = StructuredProtocolVerificationResult & {
+    readonly topKDecryptionShareDigest?: ProtocolDigest;
+    readonly targetAcceptedRecordDigest?: ProtocolDigest;
+    readonly targetFinalityRecordDigest?: ProtocolDigest;
+};

package/dist/internal/board-target.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/crypto/canonical-json.js

@@ -0,0 +1,111 @@
+import { shake256 } from '@noble/hashes/sha3.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+const textEncoder = new TextEncoder();
+const hash512PreimagePrefix = textEncoder.encode('sealed.vote/v1/hash512');
+const isCanonicalInteger = (value) => Number.isSafeInteger(value) && !Object.is(value, -0);
+const isPlainObject = (value) => typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype;
+const hasOwnProperty = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const containsLoneSurrogate = (value) => {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const nextCodeUnit = value.charCodeAt(index + 1);
+            if (index + 1 >= value.length ||
+                nextCodeUnit < 0xdc00 ||
+                nextCodeUnit > 0xdfff) {
+                return true;
+            }
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return true;
+        }
+    }
+    return false;
+};
+const normalizeCanonicalString = (value) => {
+    if (containsLoneSurrogate(value)) {
+        throw new TypeError('Canonical strings cannot contain lone UTF-16 surrogates.');
+    }
+    return value.normalize('NFC');
+};
+const normalizeCanonicalValue = (value) => {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return normalizeCanonicalString(value);
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!isCanonicalInteger(value)) {
+            throw new TypeError('Canonical numeric fields must be safe integers.');
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const normalized = [];
+        for (let index = 0; index < value.length; index += 1) {
+            if (!hasOwnProperty(value, index)) {
+                throw new TypeError('Canonical arrays cannot be sparse.');
+            }
+            normalized.push(normalizeCanonicalValue(value[index]));
+        }
+        return normalized;
+    }
+    if (isPlainObject(value)) {
+        const normalized = Object.create(null);
+        for (const key of Object.keys(value).sort()) {
+            const normalizedKey = normalizeCanonicalString(key);
+            if (hasOwnProperty(normalized, normalizedKey)) {
+                throw new TypeError('Canonical object keys must be unique after NFC normalization.');
+            }
+            const entry = value[key];
+            if (entry === undefined) {
+                throw new TypeError('Canonical objects cannot contain undefined.');
+            }
+            normalized[normalizedKey] = normalizeCanonicalValue(entry);
+        }
+        return normalized;
+    }
+    throw new TypeError('Unsupported canonical value.');
+};
+export const canonicalJson = (value) => JSON.stringify(normalizeCanonicalValue(value));
+const appendVarUint = (output, value) => {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError('Varuint values must be non-negative safe integers.');
+    }
+    let remainingValue = value;
+    for (;;) {
+        let byte = remainingValue & 0x7f;
+        remainingValue = Math.floor(remainingValue / 128);
+        if (remainingValue !== 0) {
+            byte |= 0x80;
+        }
+        output.push(byte);
+        if (remainingValue === 0) {
+            break;
+        }
+    }
+};
+const appendBytes = (output, value) => {
+    appendVarUint(output, value.byteLength);
+    for (let index = 0; index < value.byteLength; index += 1) {
+        output.push(value[index] ?? 0);
+    }
+};
+export const hash512 = (domain, parts) => {
+    const preimage = Array.from(hash512PreimagePrefix);
+    appendBytes(preimage, textEncoder.encode(domain));
+    appendVarUint(preimage, parts.length);
+    for (const part of parts) {
+        appendBytes(preimage, part);
+    }
+    return shake256(Uint8Array.from(preimage), { dkLen: 64 });
+};
+export const hash512Hex = (domain, parts) => bytesToHex(hash512(domain, parts));

package/dist/internal/crypto/digests.js

@@ -0,0 +1,29 @@
+import { protocolDigestNamespaceValues } from '../types.js';
+import { canonicalJson, hash512Hex } from './canonical-json.js';
+export { protocolDigestNamespaceValues };
+const textEncoder = new TextEncoder();
+const protocolDigestNamespaceSet = new Set(protocolDigestNamespaceValues);
+const pascalCaseToKebabCase = (value) => value
+    .replace(/([A-Z]+)([A-Z][a-z])/gu, '$1-$2')
+    .replace(/([a-z0-9])([A-Z])/gu, '$1-$2')
+    .toLowerCase();
+const reservedProtocolDigestDomainSet = new Set(protocolDigestNamespaceValues.map((reservedNamespace) => `sealed-lattice-root/${pascalCaseToKebabCase(reservedNamespace)}-v1`));
+export const resolveProtocolDigestDomain = (namespace) => {
+    if (protocolDigestNamespaceSet.has(namespace)) {
+        return `sealed-lattice-root/${pascalCaseToKebabCase(namespace)}-v1`;
+    }
+    if (namespace.startsWith('sealed-lattice-root/')) {
+        if (reservedProtocolDigestDomainSet.has(namespace)) {
+            return namespace;
+        }
+        throw new TypeError('Protocol digest namespace domain must be reserved in the transcript-core registry.');
+    }
+    if (!/^[A-Z][A-Za-z0-9]*$/u.test(namespace)) {
+        throw new TypeError('Protocol digest namespace must be a reserved PascalCase name.');
+    }
+    throw new TypeError('Protocol digest namespace must be reserved in the transcript-core registry.');
+};
+export const deriveProtocolDigest = (namespace, value) => hash512Hex(resolveProtocolDigestDomain(namespace), [
+    textEncoder.encode(canonicalJson(value)),
+]);
+export const derivePolicyDigest = (namespace, policy) => deriveProtocolDigest(namespace, policy);

package/dist/internal/crypto/index.js

@@ -0,0 +1,3 @@
+export { canonicalJson, hash512, hash512Hex } from './canonical-json.js';
+export { derivePolicyDigest, deriveProtocolDigest, protocolDigestNamespaceValues, resolveProtocolDigestDomain, } from './digests.js';
+export { createMlDsaKeyPairFixture, createMlDsaSignatureProfileFixture, createProtocolSignatureFixture, deriveCanonicalSignedRootDigest, deriveMlDsaContextByteLength, deriveMlDsaPublicKeyDigest, deriveProtocolSignatureDigest, verifySignedObjectSignature, } from './signatures.js';