@noeos/verification-engine 0.0.0

package/dist/types/domain/algorithm-id.d.ts

@@ -0,0 +1,4 @@
+/** Algorithms available to protocol 1 creation and verification. */
+/** @public */
+export type AlgorithmId = "sha-256" | "sha-384" | "sha-512";
+export declare const ALGORITHM_IDS: readonly AlgorithmId[];

package/dist/types/domain/byte-view.d.ts

@@ -0,0 +1 @@
+export declare function copyBytes(value: Uint8Array): Uint8Array;

package/dist/types/domain/chain.d.ts

@@ -0,0 +1,43 @@
+import type { AlgorithmId } from "./algorithm-id.js";
+import type { DuplicatePolicy } from "./duplicate-policy.js";
+import type { PreviousLink } from "./evidence.js";
+import type { Rule } from "./rule.js";
+/** @public */
+export interface ProfileReference {
+    readonly id: string;
+    readonly version: string;
+}
+/** @public */
+export interface RecordInput {
+    readonly contextId: string;
+    readonly recordId: string;
+    readonly payload: unknown;
+    readonly profile: ProfileReference;
+    readonly algorithm: AlgorithmId;
+}
+export interface ChainConfig {
+    readonly contextId: string;
+    readonly sequenceId: string;
+    readonly profile: ProfileReference;
+    readonly algorithm: AlgorithmId;
+    readonly duplicatePolicy?: DuplicatePolicy;
+    readonly rules?: readonly Rule[];
+    readonly allowEmpty?: boolean;
+}
+/** @public */
+export interface ChainRecordInput {
+    readonly recordId: string;
+    readonly payload: unknown;
+    readonly position: number;
+    readonly previous: PreviousLink;
+}
+/** @public */
+export interface ChainSnapshot {
+    readonly contextId: string;
+    readonly sequenceId: string;
+    readonly profile: ProfileReference;
+    readonly algorithm: AlgorithmId;
+    readonly nextPosition: number;
+    readonly previous: PreviousLink;
+    readonly count: number;
+}

package/dist/types/domain/diagnostic.d.ts

@@ -0,0 +1,23 @@
+import type { DiagnosticCode, DiagnosticSeverity } from "../contracts/generated.js";
+export type { DiagnosticCode, DiagnosticSeverity } from "../contracts/generated.js";
+/** @public */
+export type DiagnosticPhase = "input" | "normalization" | "record" | "link" | "chain" | "output";
+/** @public */
+export type DiagnosticDetail = string | number | boolean | null;
+/** @public */
+export type DiagnosticDetails = Readonly<Record<string, DiagnosticDetail>>;
+/** @public */
+export declare const DIAGNOSTIC_SCHEMA: "urn:noeos:verification-engine:diagnostic:1";
+/** @public */
+export interface Diagnostic {
+    readonly $schema: typeof DIAGNOSTIC_SCHEMA;
+    readonly code: DiagnosticCode;
+    readonly severity: DiagnosticSeverity;
+    readonly phase: DiagnosticPhase;
+    readonly messageKey: string;
+    readonly path?: string;
+    readonly recordId?: string;
+    readonly position?: number;
+    readonly details?: DiagnosticDetails;
+    readonly causeCode?: string;
+}

package/dist/types/domain/digest.d.ts

@@ -0,0 +1,12 @@
+import type { AlgorithmId } from "./algorithm-id.js";
+/** @public */
+export declare class Digest {
+    readonly algorithm: AlgorithmId;
+    private readonly bytes;
+    private constructor();
+    static fromValidated(algorithm: AlgorithmId, bytes: Uint8Array): Digest;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+/** Internal framing access; the returned view never escapes the trusted frame writer. */
+export declare function digestBytesForTrustedFrame(value: Digest): Uint8Array;

package/dist/types/domain/duplicate-policy.d.ts

@@ -0,0 +1,26 @@
+/** @public */
+export type DuplicateKind = "record-id" | "content-digest" | "link-digest" | "fork";
+/** @public */
+export interface DuplicateObservation {
+    readonly kind: DuplicateKind;
+    readonly key: string;
+    readonly value?: string;
+}
+/** @public */
+export interface ExternalDuplicateIndex {
+    /** Must inspect and commit the batch atomically, with no partial write on a fatal duplicate. */
+    observe(batch: readonly DuplicateObservation[]): unknown;
+}
+/** @public */
+export type DuplicatePolicy = {
+    readonly kind: "none";
+} | {
+    readonly kind: "window";
+    readonly size: number;
+} | {
+    readonly kind: "full";
+    readonly maxRecords: number;
+} | {
+    readonly kind: "external";
+    readonly index: ExternalDuplicateIndex;
+};

package/dist/types/domain/evidence.d.ts

@@ -0,0 +1,100 @@
+import type { AlgorithmId } from "./algorithm-id.js";
+import type { Diagnostic } from "./diagnostic.js";
+/** @public */
+export declare const RECORD_EVIDENCE_SCHEMA: "urn:noeos:verification-engine:record-evidence:1";
+/** @public */
+export declare const LINK_EVIDENCE_SCHEMA: "urn:noeos:verification-engine:link-evidence:1";
+/** @public */
+export declare const CHAIN_SUMMARY_EVIDENCE_SCHEMA: "urn:noeos:verification-engine:chain-summary:1";
+/** @public */
+export interface EvidenceProfile {
+    readonly id: string;
+    readonly version: string;
+}
+/** @public */
+export interface RecordEvidenceFields {
+    readonly protocolVersion: 1;
+    readonly contextId: string;
+    readonly recordId: string;
+    readonly profile: EvidenceProfile;
+    readonly algorithm: AlgorithmId;
+    readonly normalizedByteLength: number;
+    readonly contentDigest: string;
+    readonly recordDigest: string;
+}
+/** @public */
+export interface RecordEvidence extends RecordEvidenceFields {
+    readonly $schema: typeof RECORD_EVIDENCE_SCHEMA;
+}
+/** @public */
+export type PreviousLink = {
+    readonly kind: "none";
+} | {
+    readonly kind: "digest";
+    readonly value: string;
+};
+/** @public */
+export interface LinkEvidence extends RecordEvidenceFields {
+    readonly $schema: typeof LINK_EVIDENCE_SCHEMA;
+    readonly sequenceId: string;
+    readonly position: number;
+    readonly previous: PreviousLink;
+    readonly linkDigest: string;
+}
+/** @public */
+export type BoundaryState = "verified" | "unverified" | "not-applicable";
+/** @public */
+export type VerificationStatus = "valid" | "invalid" | "indeterminate" | "aborted";
+/** @public */
+export interface DiagnosticSummary {
+    readonly errors: number;
+    readonly warnings: number;
+    readonly info: number;
+    readonly truncated: boolean;
+}
+/** @public */
+export interface ChainSummaryEvidence {
+    readonly $schema: typeof CHAIN_SUMMARY_EVIDENCE_SCHEMA;
+    readonly protocolVersion: 1;
+    readonly contextId: string;
+    readonly sequenceId: string;
+    readonly profile: EvidenceProfile;
+    readonly algorithm: AlgorithmId;
+    readonly count: number;
+    readonly firstPosition?: number;
+    readonly lastPosition?: number;
+    readonly firstLinkDigest?: string;
+    readonly finalLinkDigest?: string;
+    readonly boundaries: Readonly<{
+        readonly start: BoundaryState;
+        readonly end: BoundaryState;
+    }>;
+    readonly status: VerificationStatus;
+    readonly diagnostics: DiagnosticSummary;
+}
+/** @public */
+export type Evidence = RecordEvidence | LinkEvidence | ChainSummaryEvidence;
+/** @public */
+export interface VerificationStats {
+    readonly recordsSeen: number;
+    readonly recordsVerified: number;
+    readonly linksVerified: number;
+    readonly bytesNormalized: number;
+    readonly errors: number;
+    readonly warnings: number;
+    readonly info: number;
+}
+/** @public */
+export type VerificationMode = "complete" | "fragment" | "internal";
+/** @public */
+export interface VerificationResult<T> {
+    readonly status: VerificationStatus;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly evidence: T | undefined;
+    readonly stats: VerificationStats;
+    readonly boundaries: Readonly<{
+        readonly start: BoundaryState;
+        readonly end: BoundaryState;
+    }>;
+    readonly verificationMode: VerificationMode;
+}

package/dist/types/domain/identifiers.d.ts

@@ -0,0 +1,29 @@
+declare const recordIdBrand: unique symbol;
+declare const sequenceIdBrand: unique symbol;
+declare const contextIdBrand: unique symbol;
+declare const profileIdBrand: unique symbol;
+export declare class RecordId {
+    readonly value: string;
+    readonly [recordIdBrand] = true;
+    private constructor();
+    static fromValidated(value: string): RecordId;
+}
+export declare class SequenceId {
+    readonly value: string;
+    readonly [sequenceIdBrand] = true;
+    private constructor();
+    static fromValidated(value: string): SequenceId;
+}
+export declare class ContextId {
+    readonly value: string;
+    readonly [contextIdBrand] = true;
+    private constructor();
+    static fromValidated(value: string): ContextId;
+}
+export declare class ProfileId {
+    readonly value: string;
+    readonly [profileIdBrand] = true;
+    private constructor();
+    static fromValidated(value: string): ProfileId;
+}
+export {};

package/dist/types/domain/json-value.d.ts

@@ -0,0 +1,6 @@
+export type JsonPrimitive = null | boolean | number | string;
+export type JsonArray = readonly JsonValue[];
+export interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+export type JsonValue = JsonPrimitive | JsonArray | JsonObject;

package/dist/types/domain/limits.d.ts

@@ -0,0 +1,13 @@
+/** @public */
+export interface Limits {
+    readonly maxPayloadBytes: number;
+    readonly maxJsonDepth: number;
+    readonly maxObjectProperties: number;
+    readonly maxArrayElements: number;
+    readonly maxStringBytes: number;
+    readonly maxNdjsonLineBytes: number;
+    readonly maxDiagnostics: number;
+    readonly maxFullRecords: number;
+}
+export declare const DEFAULT_LIMITS: Limits;
+export declare const HARD_LIMITS: Limits;

package/dist/types/domain/operation-result.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from "./diagnostic.js";
+/** @public */
+export type OperationResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly diagnostics: readonly Diagnostic[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function success<T>(value: T, diagnostics?: readonly Diagnostic[]): OperationResult<T>;
+export declare function failure<T>(diagnostics: readonly Diagnostic[]): OperationResult<T>;

package/dist/types/domain/position.d.ts

@@ -0,0 +1,8 @@
+declare const positionBrand: unique symbol;
+export declare class Position {
+    readonly value: number;
+    readonly [positionBrand] = true;
+    private constructor();
+    static fromValidated(value: number): Position;
+}
+export {};

package/dist/types/domain/protocol-version.d.ts

@@ -0,0 +1,2 @@
+export type ProtocolVersion = 1;
+export declare const CURRENT_PROTOCOL_VERSION: ProtocolVersion;

package/dist/types/domain/rule.d.ts

@@ -0,0 +1,34 @@
+import type { DiagnosticDetails, DiagnosticPhase, DiagnosticSeverity } from "./diagnostic.js";
+/** @public */
+export type RulePhase = Exclude<DiagnosticPhase, "output">;
+/** @public */
+export interface ReadonlyByteView {
+    readonly byteLength: number;
+    copySlice(start?: number, end?: number): Uint8Array;
+}
+/** @public */
+export interface RuleFinding {
+    readonly messageKey: string;
+    readonly path?: string;
+    readonly details?: DiagnosticDetails;
+    readonly severity?: DiagnosticSeverity;
+}
+/** @public */
+export interface RuleContext {
+    readonly phase: RulePhase;
+    readonly input?: Readonly<Record<string, unknown>>;
+    readonly normalized?: ReadonlyByteView;
+    readonly record?: object;
+    readonly link?: object;
+    readonly chain?: object;
+    readonly recordId?: string;
+    readonly position?: number;
+}
+/** @public */
+export interface Rule {
+    readonly id: string;
+    readonly version: string;
+    readonly phases: readonly RulePhase[];
+    readonly defaultSeverity: DiagnosticSeverity;
+    evaluate(context: RuleContext): unknown;
+}

package/dist/types/domain/stream.d.ts

@@ -0,0 +1,5 @@
+import type { LinkEvidence } from "./evidence.js";
+export interface StreamOptions {
+    readonly signal?: AbortSignal;
+    readonly onEvidence?: (evidence: LinkEvidence) => void | Promise<void>;
+}

package/dist/types/domain/version.d.ts

@@ -0,0 +1,8 @@
+declare const profileVersionBrand: unique symbol;
+export declare class ProfileVersion {
+    readonly value: string;
+    readonly [profileVersionBrand] = true;
+    private constructor();
+    static fromValidated(value: string): ProfileVersion;
+}
+export {};

package/dist/types/evidence/digest-evidence.d.ts

@@ -0,0 +1,4 @@
+import type { Digest } from "../domain/digest.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function digestEvidence(value: unknown, limits: Limits): OperationResult<Digest>;

package/dist/types/evidence/evidence-parser.d.ts

@@ -0,0 +1,8 @@
+import type { ChainSummaryEvidence, Evidence, LinkEvidence, RecordEvidence } from "../domain/evidence.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function parseEvidence(value: unknown, limits: Limits): OperationResult<Evidence>;
+export declare function parseEvidenceText(value: unknown, limits: Limits): OperationResult<Evidence>;
+export declare function parseRecordEvidence(value: unknown, limits: Limits): OperationResult<RecordEvidence>;
+export declare function parseLinkEvidence(value: unknown, limits: Limits): OperationResult<LinkEvidence>;
+export declare function parseChainSummaryEvidence(value: unknown, limits: Limits): OperationResult<ChainSummaryEvidence>;

package/dist/types/framing/frame-builders.d.ts

@@ -0,0 +1,40 @@
+import type { Digest } from "../domain/digest.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export interface ContentFrameInput {
+    readonly algorithm: string;
+    readonly profileId: string;
+    readonly profileVersion: string;
+    readonly normalizedBytes: Uint8Array;
+}
+export interface RecordFrameInput {
+    readonly algorithm: string;
+    readonly contextId: string;
+    readonly recordId: string;
+    readonly profileId: string;
+    readonly profileVersion: string;
+    readonly normalizedByteLength: number;
+    readonly contentDigest: Digest;
+}
+export interface LinkFrameInput {
+    readonly algorithm: string;
+    readonly contextId: string;
+    readonly sequenceId: string;
+    readonly position: number;
+    readonly recordId: string;
+    readonly recordDigest: Digest;
+    readonly previousLinkDigest?: Digest;
+}
+export interface EvidenceFrameInput {
+    readonly algorithm: string;
+    readonly schemaUrn: string;
+    readonly evidenceJcsBytes: Uint8Array;
+}
+export declare function buildContentFrame(input: ContentFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildRecordFrame(input: RecordFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildLinkFrame(input: LinkFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildEvidenceFrame(input: EvidenceFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildTrustedContentFrame(input: ContentFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildTrustedRecordFrame(input: RecordFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildTrustedLinkFrame(input: LinkFrameInput, limits: Limits): OperationResult<Uint8Array>;
+export declare function buildTrustedEvidenceFrame(input: EvidenceFrameInput, limits: Limits): OperationResult<Uint8Array>;

package/dist/types/framing/frame-encoder.d.ts

@@ -0,0 +1,6 @@
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import type { FrameInput } from "./frame-types.js";
+export declare function encodeFrame(input: unknown, limits: Limits): OperationResult<Uint8Array>;
+/** Internal fast path. Callers must have completed positive validation. */
+export declare function encodeTrustedFrame(input: FrameInput, limits: Limits): OperationResult<Uint8Array>;

package/dist/types/framing/frame-parser.d.ts

@@ -0,0 +1,4 @@
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import type { ParsedFrame } from "./frame-types.js";
+export declare function parseFrame(input: unknown, limits: Limits): OperationResult<ParsedFrame>;

package/dist/types/framing/frame-types.d.ts

@@ -0,0 +1,27 @@
+export type FrameKind = "content" | "record" | "link" | "evidence";
+export type FrameFieldType = "bytes" | "utf8" | "uint64" | "none";
+export type FrameField = {
+    readonly tag: number;
+    readonly type: "bytes";
+    readonly value: Uint8Array;
+} | {
+    readonly tag: number;
+    readonly type: "utf8";
+    readonly value: string;
+} | {
+    readonly tag: number;
+    readonly type: "uint64";
+    readonly value: number;
+} | {
+    readonly tag: number;
+    readonly type: "none";
+};
+export interface FrameInput {
+    readonly kind: FrameKind;
+    readonly fields: readonly FrameField[];
+}
+export interface ParsedFrame {
+    readonly kind: FrameKind;
+    readonly protocolVersion: 1;
+    readonly fields: readonly FrameField[];
+}

package/dist/types/hashing/hash-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { AlgorithmId } from "../domain/algorithm-id.js";
+import type { Digest } from "../domain/digest.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export interface HashSink {
+    update(value: Uint8Array): void;
+    digest(): Digest;
+}
+export declare function createHashSink(algorithm: unknown, limits: Limits): OperationResult<HashSink>;
+export declare function hashBytes(algorithm: unknown, input: unknown, limits: Limits): OperationResult<Digest>;
+export declare function hashValidatedBytes(algorithm: AlgorithmId, input: Uint8Array): OperationResult<Digest>;
+export declare function hashChunks(algorithm: unknown, chunks: Iterable<Uint8Array>, limits: Limits): OperationResult<Digest>;

package/dist/types/hashing/hash-frame.d.ts

@@ -0,0 +1,6 @@
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import type { Digest } from "../domain/digest.js";
+import { hashValidatedBytes } from "./hash-adapter.js";
+export declare function hashFrame(algorithm: unknown, frame: OperationResult<Uint8Array>, limits: Limits): OperationResult<Digest>;
+export declare function hashTrustedFrame(algorithm: Parameters<typeof hashValidatedBytes>[0], frame: OperationResult<Uint8Array>): OperationResult<Digest>;

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { DIAGNOSTIC_CODES } from "./contracts/generated.js";
+export type { DiagnosticCode, DiagnosticFamily, DiagnosticSeverity, } from "./contracts/generated.js";
+export { createEngine, EngineConfigurationError } from "./api/engine.js";
+export { BUILTIN_PROFILES } from "./profiles.js";
+export type { BuiltinProfile } from "./profiles.js";
+export type { ByteSink, ChainBuilder, ChainConfig, ChainVerificationConfig, Engine, EngineEvent, EngineEventName, EngineOptions, NormalizationProfile, ProfileManifest, StreamOptions, VerifyChainInput, VerifyChainRecord, VerifyRecordInput, VerifyStreamInput, } from "./api/types.js";
+export type { AlgorithmId, BoundaryState, ChainRecordInput, ChainSummaryEvidence, ChainSnapshot, Diagnostic, DiagnosticDetail, DiagnosticDetails, DiagnosticSummary, DiagnosticPhase, DuplicateKind, DuplicateObservation, DuplicatePolicy, ExternalDuplicateIndex, Digest, Evidence, EvidenceProfile, LinkEvidence, Limits, OperationResult, ProfileReference, PreviousLink, RecordEvidence, RecordEvidenceFields, RecordInput, Rule, RuleContext, RuleFinding, RulePhase, ReadonlyByteView, VerificationResult, VerificationMode, VerificationStats, VerificationStatus, NormalizationInputKind, NormalizationStats, } from "./api/types.js";
+export { CHAIN_SUMMARY_EVIDENCE_SCHEMA, DIAGNOSTIC_SCHEMA, LINK_EVIDENCE_SCHEMA, RECORD_EVIDENCE_SCHEMA, } from "./api/types.js";

package/dist/types/normalization/byte-sink.d.ts

@@ -0,0 +1,19 @@
+export interface ByteSink {
+    readonly byteLength: number;
+    write(value: Uint8Array): void;
+}
+export declare class ByteArraySink implements ByteSink {
+    private readonly maximum;
+    private buffer;
+    private written;
+    constructor(maximum: number, initialCapacity?: number);
+    get byteLength(): number;
+    write(value: Uint8Array): void;
+    writeByte(value: number): void;
+    writeAscii(value: string): void;
+    writeText(value: string): void;
+    toBytes(): Uint8Array;
+    /** Internal ownership transfer; the returned view is never exposed to callers. */
+    takeBytes(): Uint8Array;
+    private ensureCapacity;
+}

package/dist/types/normalization/jcs-profile.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from "../domain/json-value.js";
+import type { NormalizationProfile } from "./profile.js";
+export declare const jcsProfile: NormalizationProfile<JsonValue>;

package/dist/types/normalization/normalize.d.ts

@@ -0,0 +1,11 @@
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import { ByteArraySink } from "./byte-sink.js";
+import type { NormalizationProfile, NormalizationStats, NormalizedBytes } from "./profile.js";
+interface RegisteredNormalizationProfile {
+    normalize(input: unknown, sink: ByteArraySink, limits: Limits): OperationResult<NormalizationStats>;
+    normalizeValidated?(input: unknown, sink: ByteArraySink, limits: Limits): OperationResult<NormalizationStats>;
+}
+export declare function normalizeToBytes<I>(profile: NormalizationProfile<I>, input: unknown, limits: Limits): OperationResult<NormalizedBytes>;
+export declare function normalizeRegisteredToBytes(profile: RegisteredNormalizationProfile, input: unknown, limits: Limits): OperationResult<NormalizedBytes>;
+export {};

package/dist/types/normalization/profile-registry.d.ts

@@ -0,0 +1,26 @@
+import type { OperationResult } from "../domain/operation-result.js";
+import type { ProfileId } from "../domain/identifiers.js";
+import type { Limits } from "../domain/limits.js";
+import type { ProfileVersion } from "../domain/version.js";
+import type { ByteSink } from "./byte-sink.js";
+import type { NormalizationProfile, NormalizationStats } from "./profile.js";
+interface RegisteredProfile {
+    readonly id: ProfileId;
+    readonly version: ProfileVersion;
+    readonly inputKind: NormalizationProfile["inputKind"];
+    validate(input: unknown, limits: Limits): OperationResult<unknown>;
+    normalize(input: unknown, sink: ByteSink, limits: Limits): OperationResult<NormalizationStats>;
+    normalizeValidated(input: unknown, sink: ByteSink, limits: Limits): OperationResult<NormalizationStats>;
+}
+export declare class ProfileRegistry {
+    private readonly profiles;
+    constructor(additional?: readonly NormalizationProfile[]);
+    register<I>(profile: NormalizationProfile<I>): OperationResult<void>;
+    resolve(id: ProfileId, version: ProfileVersion): OperationResult<RegisteredProfile>;
+    resolveValidated(reference: Readonly<{
+        readonly id: string;
+        readonly version: string;
+    }>): OperationResult<RegisteredProfile>;
+    private registerBuiltin;
+}
+export {};

package/dist/types/normalization/profile.d.ts

@@ -0,0 +1,22 @@
+import type { ProfileId } from "../domain/identifiers.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import type { ProfileVersion } from "../domain/version.js";
+import type { ByteSink } from "./byte-sink.js";
+/** @public */
+export type NormalizationInputKind = "json" | "bytes";
+/** @public */
+export interface NormalizationStats {
+    readonly byteLength: number;
+}
+export interface NormalizationProfile<I = unknown> {
+    readonly id: ProfileId;
+    readonly version: ProfileVersion;
+    readonly inputKind: NormalizationInputKind;
+    validate(input: unknown, limits: Limits): OperationResult<I>;
+    normalize(input: I, sink: ByteSink, limits: Limits): OperationResult<NormalizationStats>;
+}
+export interface NormalizedBytes {
+    readonly bytes: Uint8Array;
+    readonly stats: NormalizationStats;
+}

package/dist/types/normalization/raw-bytes-profile.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizationProfile } from "./profile.js";
+export declare const rawBytesProfile: NormalizationProfile<Uint8Array>;

package/dist/types/profiles.d.ts

@@ -0,0 +1,8 @@
+/** @public */
+export interface BuiltinProfile {
+    readonly id: string;
+    readonly version: string;
+    readonly inputKind: "json" | "bytes";
+}
+/** @public */
+export declare const BUILTIN_PROFILES: readonly BuiltinProfile[];

package/dist/types/records/record-service.d.ts

@@ -0,0 +1,38 @@
+import type { RecordEvidence } from "../domain/evidence.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import type { AlgorithmId } from "../domain/algorithm-id.js";
+import type { Digest } from "../domain/digest.js";
+import type { ProfileRegistry } from "../normalization/profile-registry.js";
+import type { RuleSet } from "../rules/rule-set.js";
+export interface RecordServiceOptions {
+    readonly limits: Limits;
+    readonly profiles: ProfileRegistry;
+    readonly rules?: RuleSet;
+}
+export interface ComputedRecord {
+    readonly evidence: RecordEvidence;
+    /** Internal trusted values reused by chain construction before public encoding. */
+    readonly contentDigest: Digest;
+    readonly recordDigest: Digest;
+}
+interface ValidatedRecordInput {
+    readonly contextId: string;
+    readonly recordId: string;
+    readonly payload: unknown;
+    readonly profile: Readonly<{
+        readonly id: string;
+        readonly version: string;
+    }>;
+    readonly algorithm: AlgorithmId;
+}
+export declare function hashRecord(input: unknown, options: RecordServiceOptions): OperationResult<RecordEvidence>;
+export declare function computeRecord(input: unknown, options: RecordServiceOptions): OperationResult<ComputedRecord>;
+export declare function verifyComputedRecord(expected: RecordEvidence, payload: unknown, options: RecordServiceOptions): OperationResult<RecordEvidence>;
+export declare function validateRecordInput(value: unknown, limits: Limits): OperationResult<ValidatedRecordInput>;
+export declare function validateProfile(value: unknown, limits: Limits): OperationResult<Readonly<{
+    readonly id: string;
+    readonly version: string;
+}>>;
+export declare function freezeRecordEvidence(value: RecordEvidence): RecordEvidence;
+export {};

package/dist/types/rules/rule-set.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic } from "../domain/diagnostic.js";
+import type { Limits } from "../domain/limits.js";
+import type { OperationResult } from "../domain/operation-result.js";
+import type { ReadonlyByteView, Rule, RuleContext } from "../domain/rule.js";
+export declare class RuleSet {
+    private readonly rules;
+    private constructor();
+    static create(value: unknown, limits: Limits): OperationResult<RuleSet>;
+    evaluate(context: RuleContext, limits: Limits): readonly Diagnostic[];
+    hasRules(): boolean;
+    toArray(): readonly Rule[];
+}
+export declare function createReadonlyByteView(bytes: Uint8Array): ReadonlyByteView;

package/dist/types/schemas.d.ts

@@ -0,0 +1,2 @@
+export { SCHEMA_ASSETS } from "./contracts/schema-assets.js";
+export type { SchemaId, SchemaName } from "./contracts/schema-assets.js";

package/dist/types/validation/algorithm-validation.d.ts

@@ -0,0 +1,3 @@
+import type { AlgorithmId } from "../domain/algorithm-id.js";
+import type { OperationResult } from "../domain/operation-result.js";
+export declare function validateAlgorithmId(value: unknown): OperationResult<AlgorithmId>;