@hypequery/protocol 0.1.0 → 0.2.1

package/dist/schemas/validate.js

@@ -0,0 +1,391 @@
+import { ProtocolIdentifierError, parseProtocolIdentifier } from '../identifiers/index.js';
+import { ProtocolValueError, encodeCanonicalValueToString, validateCanonicalValue, } from '../values/index.js';
+import { schemaError } from './errors.js';
+import { resolveSchemaLimits } from './limits.js';
+const textEncoder = new TextEncoder();
+const ANNOTATIONS = ['description', 'default'];
+function requireRecord(input, path) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        schemaError('HQ_SCHEMA_TYPE', path);
+    }
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null)
+        schemaError('HQ_SCHEMA_UNSAFE_OBJECT', path);
+    if (Object.getOwnPropertySymbols(input).length > 0)
+        schemaError('HQ_SCHEMA_UNSAFE_OBJECT', path);
+    for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(input))) {
+        if (!descriptor.enumerable || !('value' in descriptor))
+            schemaError('HQ_SCHEMA_UNSAFE_OBJECT', path);
+    }
+    return input;
+}
+function requireArray(input, path, state) {
+    if (!Array.isArray(input))
+        schemaError('HQ_SCHEMA_TYPE', path);
+    if (Object.getPrototypeOf(input) !== Array.prototype || Object.getOwnPropertySymbols(input).length > 0) {
+        schemaError('HQ_SCHEMA_UNSAFE_OBJECT', path);
+    }
+    if (input.length > state.limits.maxCollectionItems)
+        schemaError('HQ_SCHEMA_TOO_MANY_ITEMS', path);
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    for (let index = 0; index < input.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+            schemaError('HQ_SCHEMA_UNSAFE_OBJECT', `${path}[${index}]`);
+        }
+    }
+    if (Object.keys(input).length !== input.length)
+        schemaError('HQ_SCHEMA_UNSAFE_OBJECT', path);
+    return input;
+}
+function exactFields(value, required, optional, path) {
+    const allowed = new Set([...required, ...optional]);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key))
+            schemaError('HQ_SCHEMA_UNKNOWN_FIELD', `${path}.${key}`);
+    }
+    for (const key of required) {
+        if (!Object.hasOwn(value, key))
+            schemaError('HQ_SCHEMA_TYPE', `${path}.${key}`);
+    }
+}
+function enter(value, depth, state, path) {
+    if (depth > state.limits.maxDepth)
+        schemaError('HQ_SCHEMA_TOO_DEEP', path);
+    state.nodes += 1;
+    if (state.nodes > state.limits.maxNodes)
+        schemaError('HQ_SCHEMA_TOO_MANY_NODES', path);
+    if (state.active.has(value))
+        schemaError('HQ_SCHEMA_UNSAFE_OBJECT', path);
+    state.active.add(value);
+}
+function freezeRecord(entries) {
+    return Object.freeze(Object.assign(Object.create(null), entries));
+}
+function validateAnnotations(value, result, state, path, allowDefault = true) {
+    if (value.description !== undefined) {
+        if (typeof value.description !== 'string')
+            schemaError('HQ_SCHEMA_TYPE', `${path}.description`);
+        // UTF-16 code units are a conservative allocation-free lower bound on UTF-8 bytes.
+        if (value.description.length > state.limits.maxDescriptionBytes) {
+            schemaError('HQ_SCHEMA_TOO_LARGE', `${path}.description`);
+        }
+        if (textEncoder.encode(value.description).byteLength > state.limits.maxDescriptionBytes) {
+            schemaError('HQ_SCHEMA_TOO_LARGE', `${path}.description`);
+        }
+        const description = canonicalValue(value.description, `${path}.description`);
+        result.description = description;
+    }
+    if (value.default !== undefined) {
+        if (!allowDefault)
+            schemaError('HQ_SCHEMA_INVALID_VALUE', `${path}.default`);
+        try {
+            result.default = validateCanonicalValue(value.default);
+        }
+        catch (error) {
+            if (error instanceof ProtocolValueError)
+                schemaError('HQ_SCHEMA_INVALID_VALUE', `${path}.default`);
+            throw error;
+        }
+    }
+}
+function nonNegativeInteger(value, path) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+    }
+    return value;
+}
+function finiteNumber(value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || Object.is(value, -0)) {
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+    }
+    return value;
+}
+function copyRange(value, result, minimumKey, maximumKey, path, integer) {
+    if (value[minimumKey] !== undefined) {
+        const number = finiteNumber(value[minimumKey], `${path}.${minimumKey}`);
+        if (integer && !Number.isSafeInteger(number))
+            schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', `${path}.${minimumKey}`);
+        result[minimumKey] = number;
+    }
+    if (value[maximumKey] !== undefined) {
+        const number = finiteNumber(value[maximumKey], `${path}.${maximumKey}`);
+        if (integer && !Number.isSafeInteger(number))
+            schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', `${path}.${maximumKey}`);
+        result[maximumKey] = number;
+    }
+}
+function copyNonNegativeRange(value, result, minimumKey, maximumKey, path) {
+    if (value[minimumKey] !== undefined) {
+        result[minimumKey] = nonNegativeInteger(value[minimumKey], `${path}.${minimumKey}`);
+    }
+    if (value[maximumKey] !== undefined) {
+        result[maximumKey] = nonNegativeInteger(value[maximumKey], `${path}.${maximumKey}`);
+    }
+}
+function assertOrderedBounds(result, path) {
+    if (result.minimum !== undefined && result.exclusiveMinimum !== undefined) {
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+    }
+    if (result.maximum !== undefined && result.exclusiveMaximum !== undefined) {
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+    }
+    const lower = result.exclusiveMinimum ?? result.minimum;
+    const upper = result.exclusiveMaximum ?? result.maximum;
+    const emptyAtEqual = lower === upper
+        && (result.exclusiveMinimum !== undefined || result.exclusiveMaximum !== undefined);
+    if (lower !== undefined && upper !== undefined
+        && (lower > upper || emptyAtEqual)) {
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+    }
+}
+function validateSchema(input, path, depth, state) {
+    const value = requireRecord(input, path);
+    enter(value, depth, state, path);
+    try {
+        if (typeof value.kind !== 'string')
+            schemaError('HQ_SCHEMA_TYPE', `${path}.kind`);
+        const kind = value.kind;
+        const result = { kind };
+        switch (kind) {
+            case 'any':
+            case 'null':
+            case 'boolean':
+                exactFields(value, ['kind'], ANNOTATIONS, path);
+                validateAnnotations(value, result, state, path);
+                break;
+            case 'void':
+                exactFields(value, ['kind'], ['description'], path);
+                validateAnnotations(value, result, state, path, false);
+                break;
+            case 'string': {
+                exactFields(value, ['kind'], [...ANNOTATIONS, 'minLength', 'maxLength'], path);
+                validateAnnotations(value, result, state, path);
+                copyNonNegativeRange(value, result, 'minLength', 'maxLength', path);
+                if (result.minLength !== undefined && result.maxLength !== undefined
+                    && result.minLength > result.maxLength) {
+                    schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+                }
+                break;
+            }
+            case 'number':
+            case 'integer':
+                exactFields(value, ['kind'], [
+                    ...ANNOTATIONS, 'minimum', 'exclusiveMinimum', 'maximum', 'exclusiveMaximum',
+                ], path);
+                validateAnnotations(value, result, state, path);
+                copyRange(value, result, 'minimum', 'maximum', path, kind === 'integer');
+                copyRange(value, result, 'exclusiveMinimum', 'exclusiveMaximum', path, kind === 'integer');
+                assertOrderedBounds(result, path);
+                break;
+            case 'literal':
+                exactFields(value, ['kind', 'value'], ANNOTATIONS, path);
+                validateAnnotations(value, result, state, path);
+                result.value = canonicalValue(value.value, `${path}.value`);
+                break;
+            case 'enum':
+                exactFields(value, ['kind', 'values'], ANNOTATIONS, path);
+                validateAnnotations(value, result, state, path);
+                result.values = validateEnum(value.values, `${path}.values`, state);
+                break;
+            case 'array': {
+                exactFields(value, ['kind', 'items'], [...ANNOTATIONS, 'minItems', 'maxItems'], path);
+                validateAnnotations(value, result, state, path);
+                result.items = validateSchema(value.items, `${path}.items`, depth + 1, state);
+                copyNonNegativeRange(value, result, 'minItems', 'maxItems', path);
+                if (result.minItems !== undefined && result.maxItems !== undefined
+                    && result.minItems > result.maxItems) {
+                    schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+                }
+                break;
+            }
+            case 'object':
+                validateObject(value, result, path, depth, state);
+                break;
+            case 'record':
+                exactFields(value, ['kind', 'values'], ANNOTATIONS, path);
+                validateAnnotations(value, result, state, path);
+                result.values = validateSchema(value.values, `${path}.values`, depth + 1, state);
+                break;
+            case 'union': {
+                exactFields(value, ['kind', 'variants'], ANNOTATIONS, path);
+                validateAnnotations(value, result, state, path);
+                const variants = requireArray(value.variants, `${path}.variants`, state);
+                if (variants.length < 2)
+                    schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', `${path}.variants`);
+                result.variants = Object.freeze(variants.map((variant, index) => validateSchema(variant, `${path}.variants[${index}]`, depth + 1, state)));
+                break;
+            }
+            default:
+                schemaError('HQ_SCHEMA_UNKNOWN_KIND', `${path}.kind`);
+        }
+        validateDefault(result, path);
+        return freezeRecord(result);
+    }
+    finally {
+        state.active.delete(value);
+    }
+}
+function canonicalValue(input, path) {
+    try {
+        return validateCanonicalValue(input);
+    }
+    catch (error) {
+        if (error instanceof ProtocolValueError)
+            schemaError('HQ_SCHEMA_INVALID_VALUE', path);
+        throw error;
+    }
+}
+function validateEnum(input, path, state) {
+    const values = requireArray(input, path, state);
+    if (values.length === 0)
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', path);
+    const validated = values.map((value, index) => canonicalValue(value, `${path}[${index}]`));
+    const encoded = validated.map(value => encodeCanonicalValueToString(value));
+    if (new Set(encoded).size !== encoded.length)
+        schemaError('HQ_SCHEMA_DUPLICATE_VALUE', path);
+    return Object.freeze(validated);
+}
+function validateObject(value, result, path, depth, state) {
+    exactFields(value, ['kind', 'properties', 'required', 'unknownProperties'], ANNOTATIONS, path);
+    validateAnnotations(value, result, state, path);
+    const properties = requireRecord(value.properties, `${path}.properties`);
+    if (state.active.has(properties))
+        schemaError('HQ_SCHEMA_UNSAFE_OBJECT', `${path}.properties`);
+    state.active.add(properties);
+    const propertyEntries = Object.entries(properties);
+    if (propertyEntries.length > state.limits.maxCollectionItems) {
+        schemaError('HQ_SCHEMA_TOO_MANY_ITEMS', `${path}.properties`);
+    }
+    const snapshot = Object.create(null);
+    try {
+        for (const [name, schema] of propertyEntries) {
+            try {
+                parseProtocolIdentifier(name);
+            }
+            catch (error) {
+                if (error instanceof ProtocolIdentifierError)
+                    schemaError('HQ_SCHEMA_INVALID_IDENTIFIER', `${path}.properties`);
+                throw error;
+            }
+            snapshot[name] = validateSchema(schema, `${path}.properties.${name}`, depth + 1, state);
+        }
+    }
+    finally {
+        state.active.delete(properties);
+    }
+    result.properties = Object.freeze(snapshot);
+    const required = requireArray(value.required, `${path}.required`, state);
+    const requiredNames = required.map((name, index) => {
+        if (typeof name !== 'string' || !Object.hasOwn(snapshot, name)) {
+            schemaError('HQ_SCHEMA_INVALID_REQUIRED', `${path}.required[${index}]`);
+        }
+        return name;
+    });
+    if (new Set(requiredNames).size !== requiredNames.length) {
+        schemaError('HQ_SCHEMA_INVALID_REQUIRED', `${path}.required`);
+    }
+    result.required = Object.freeze(requiredNames);
+    if (value.unknownProperties !== 'reject' && value.unknownProperties !== 'strip'
+        && value.unknownProperties !== 'preserve') {
+        schemaError('HQ_SCHEMA_INVALID_CONSTRAINT', `${path}.unknownProperties`);
+    }
+    result.unknownProperties = value.unknownProperties;
+}
+function validateDefault(schema, path) {
+    if (schema.default === undefined)
+        return;
+    if (!matchesSchema(schema, schema.default)) {
+        schemaError('HQ_SCHEMA_INVALID_VALUE', `${path}.default`);
+    }
+}
+function matchesSchema(schema, value) {
+    switch (schema.kind) {
+        case 'any':
+            return true;
+        case 'void':
+            return false;
+        case 'null':
+            return value === null;
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'string': {
+            if (typeof value !== 'string')
+                return false;
+            const length = [...value].length;
+            return (schema.minLength === undefined || length >= schema.minLength)
+                && (schema.maxLength === undefined || length <= schema.maxLength);
+        }
+        case 'number':
+        case 'integer':
+            return matchesNumber(schema, value);
+        case 'literal':
+            return encodeCanonicalValueToString(value) === encodeCanonicalValueToString(schema.value);
+        case 'enum': {
+            const encoded = encodeCanonicalValueToString(value);
+            return schema.values.some(item => encodeCanonicalValueToString(item) === encoded);
+        }
+        case 'array': {
+            const values = taggedValues(value, 'array');
+            return values !== undefined
+                && (schema.minItems === undefined || values.length >= schema.minItems)
+                && (schema.maxItems === undefined || values.length <= schema.maxItems)
+                && values.every(item => matchesSchema(schema.items, item));
+        }
+        case 'object': {
+            const entries = taggedEntries(value);
+            if (!entries)
+                return false;
+            const found = new Set();
+            for (const [key, item] of entries) {
+                if (typeof key !== 'string')
+                    return false;
+                const property = schema.properties[key];
+                if (property) {
+                    if (!matchesSchema(property, item))
+                        return false;
+                    found.add(key);
+                }
+                else if (schema.unknownProperties === 'reject' || schema.unknownProperties === 'strip') {
+                    return false;
+                }
+            }
+            return schema.required.every(name => found.has(name));
+        }
+        case 'record': {
+            const entries = taggedEntries(value);
+            return entries !== undefined
+                && entries.every(([key, item]) => typeof key === 'string' && matchesSchema(schema.values, item));
+        }
+        case 'union':
+            return schema.variants.some(variant => matchesSchema(variant, value));
+    }
+}
+function matchesNumber(schema, value) {
+    if (typeof value !== 'number' || (schema.kind === 'integer' && !Number.isSafeInteger(value))) {
+        return false;
+    }
+    return (schema.minimum === undefined || value >= schema.minimum)
+        && (schema.exclusiveMinimum === undefined || value > schema.exclusiveMinimum)
+        && (schema.maximum === undefined || value <= schema.maximum)
+        && (schema.exclusiveMaximum === undefined || value < schema.exclusiveMaximum);
+}
+function taggedValues(value, type) {
+    if (typeof value !== 'object' || value === null || !('$hypequery' in value))
+        return undefined;
+    const tag = value.$hypequery;
+    return tag.type === type ? tag.values : undefined;
+}
+function taggedEntries(value) {
+    if (typeof value !== 'object' || value === null || !('$hypequery' in value))
+        return undefined;
+    const tag = value.$hypequery;
+    return tag.type === 'map' ? tag.entries : undefined;
+}
+export function validateProtocolSchema(input, options = {}) {
+    return validateSchema(input, '$', 1, {
+        limits: resolveSchemaLimits(options),
+        active: new WeakSet(),
+        nodes: 0,
+    });
+}

package/dist/values/codec.d.ts

@@ -0,0 +1,13 @@
+import type { CanonicalValue, CanonicalValueOptions } from './types.js';
+/** Validates plain data and returns exact RFC 8785 canonical UTF-8 bytes. */
+export declare function encodeCanonicalValue(input: unknown, options?: CanonicalValueOptions): Uint8Array;
+/** String form of the exact bytes returned by `encodeCanonicalValue`. */
+export declare function encodeCanonicalValueToString(input: unknown, options?: CanonicalValueOptions): string;
+/**
+ * Parses duplicate-aware UTF-8/JSON and returns a validated, deeply frozen
+ * canonical value. Input need not already use canonical object-key ordering.
+ */
+export declare function decodeCanonicalValue(input: string | Uint8Array, options?: CanonicalValueOptions): CanonicalValue;
+/** Raw conformance hash only; deployment and cache domains are specified later. */
+export declare function hashCanonicalValue(input: unknown, options?: CanonicalValueOptions): string;
+//# sourceMappingURL=codec.d.ts.map

package/dist/values/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/values/codec.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA0BxE,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAEZ;AAED,yEAAyE;AACzE,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,UAAU,EAC1B,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAQhB;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAER"}

package/dist/values/codec.js

@@ -0,0 +1,39 @@
+import { sha256 } from '@noble/hashes/sha2';
+import { bytesToHex } from '@noble/hashes/utils';
+import { valueError } from './errors.js';
+import { serializeJcs } from './jcs.js';
+import { resolveLimits } from './limits.js';
+import { parseDuplicateAwareJson } from './parser.js';
+import { validateCanonicalValueWithLimits, validateParsedCanonicalValue, } from './validate.js';
+const textEncoder = new TextEncoder();
+function prepare(input, options) {
+    const limits = resolveLimits(options);
+    const value = validateCanonicalValueWithLimits(input, limits, options.declaredClickHouseType);
+    const canonical = serializeJcs(value);
+    const bytes = textEncoder.encode(canonical);
+    if (bytes.byteLength > limits.maxCanonicalBytes) {
+        valueError('HQ_VALUE_TOO_LARGE');
+    }
+    return { value, canonical, bytes };
+}
+/** Validates plain data and returns exact RFC 8785 canonical UTF-8 bytes. */
+export function encodeCanonicalValue(input, options = {}) {
+    return prepare(input, options).bytes;
+}
+/** String form of the exact bytes returned by `encodeCanonicalValue`. */
+export function encodeCanonicalValueToString(input, options = {}) {
+    return prepare(input, options).canonical;
+}
+/**
+ * Parses duplicate-aware UTF-8/JSON and returns a validated, deeply frozen
+ * canonical value. Input need not already use canonical object-key ordering.
+ */
+export function decodeCanonicalValue(input, options = {}) {
+    const limits = resolveLimits(options);
+    const parsed = parseDuplicateAwareJson(input, limits);
+    return validateParsedCanonicalValue(parsed, limits, options.declaredClickHouseType);
+}
+/** Raw conformance hash only; deployment and cache domains are specified later. */
+export function hashCanonicalValue(input, options = {}) {
+    return bytesToHex(sha256(prepare(input, options).bytes));
+}

package/dist/values/errors.d.ts

@@ -0,0 +1,8 @@
+export type ProtocolValueErrorCode = 'HQ_VALUE_INVALID_JSON' | 'HQ_VALUE_DUPLICATE_KEY' | 'HQ_VALUE_INVALID_UNICODE' | 'HQ_VALUE_CONTROL_CHARACTER' | 'HQ_VALUE_NON_FINITE_FLOAT' | 'HQ_VALUE_NEGATIVE_ZERO' | 'HQ_VALUE_INTEGER_TAG_REQUIRED' | 'HQ_VALUE_RAW_COMPOSITE' | 'HQ_VALUE_UNKNOWN_TAG' | 'HQ_VALUE_UNKNOWN_TAG_VERSION' | 'HQ_VALUE_UNKNOWN_FIELD' | 'HQ_VALUE_INVALID_FORMAT' | 'HQ_VALUE_OUT_OF_RANGE' | 'HQ_VALUE_TYPE_MISMATCH' | 'HQ_VALUE_TOO_DEEP' | 'HQ_VALUE_TOO_MANY_NODES' | 'HQ_VALUE_TOO_MANY_ITEMS' | 'HQ_VALUE_TOO_LARGE' | 'HQ_VALUE_UNSAFE_OBJECT';
+export declare class ProtocolValueError extends TypeError {
+    readonly code: ProtocolValueErrorCode;
+    readonly path: string;
+    constructor(code: ProtocolValueErrorCode, path?: string);
+}
+export declare function valueError(code: ProtocolValueErrorCode, path?: string): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/values/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/values/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAC9B,uBAAuB,GACvB,wBAAwB,GACxB,0BAA0B,GAC1B,4BAA4B,GAC5B,2BAA2B,GAC3B,wBAAwB,GACxB,+BAA+B,GAC/B,wBAAwB,GACxB,sBAAsB,GACtB,8BAA8B,GAC9B,wBAAwB,GACxB,yBAAyB,GACzB,uBAAuB,GACvB,wBAAwB,GACxB,mBAAmB,GACnB,yBAAyB,GACzB,yBAAyB,GACzB,oBAAoB,GACpB,wBAAwB,CAAC;AAE7B,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,sBAAsB,EAAE,IAAI,SAAM;CAMrD;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,sBAAsB,EAC5B,IAAI,SAAM,GACT,KAAK,CAEP"}

package/dist/values/errors.js

@@ -0,0 +1,13 @@
+export class ProtocolValueError extends TypeError {
+    code;
+    path;
+    constructor(code, path = '$') {
+        super(`${code} at ${path}`);
+        this.name = 'ProtocolValueError';
+        this.code = code;
+        this.path = path;
+    }
+}
+export function valueError(code, path = '$') {
+    throw new ProtocolValueError(code, path);
+}

package/dist/values/index.d.ts

@@ -0,0 +1,7 @@
+export { decodeCanonicalValue, encodeCanonicalValue, encodeCanonicalValueToString, hashCanonicalValue, } from './codec.js';
+export { ProtocolValueError } from './errors.js';
+export type { ProtocolValueErrorCode } from './errors.js';
+export { DEFAULT_CANONICAL_VALUE_LIMITS } from './limits.js';
+export { validateCanonicalValue } from './validate.js';
+export type { ArrayTaggedValue, BytesTaggedValue, CanonicalValue, CanonicalValueLimits, CanonicalValueOptions, DateTaggedValue, DatetimeTaggedValue, DecimalTaggedValue, EnumTaggedValue, IntegerTaggedValue, MapTaggedValue, TaggedValue, TupleTaggedValue, UuidTaggedValue, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/values/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/values/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,4BAA4B,EAC5B,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/dist/values/index.js

@@ -0,0 +1,4 @@
+export { decodeCanonicalValue, encodeCanonicalValue, encodeCanonicalValueToString, hashCanonicalValue, } from './codec.js';
+export { ProtocolValueError } from './errors.js';
+export { DEFAULT_CANONICAL_VALUE_LIMITS } from './limits.js';
+export { validateCanonicalValue } from './validate.js';

package/dist/values/jcs.d.ts

@@ -0,0 +1,2 @@
+export declare function serializeJcs(value: unknown): string;
+//# sourceMappingURL=jcs.d.ts.map

package/dist/values/jcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jcs.d.ts","sourceRoot":"","sources":["../../src/values/jcs.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAsBnD"}

package/dist/values/jcs.js

@@ -0,0 +1,23 @@
+import { valueError } from './errors.js';
+export function serializeJcs(value) {
+    if (value === null
+        || typeof value === 'boolean'
+        || typeof value === 'string'
+        || typeof value === 'number') {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined)
+            valueError('HQ_VALUE_INVALID_FORMAT');
+        return encoded;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(serializeJcs).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const object = value;
+        return `{${Object.keys(object)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${serializeJcs(object[key])}`)
+            .join(',')}}`;
+    }
+    valueError('HQ_VALUE_INVALID_FORMAT');
+}

package/dist/values/limits.d.ts

@@ -0,0 +1,4 @@
+import type { CanonicalValueLimits, CanonicalValueOptions } from './types.js';
+export declare const DEFAULT_CANONICAL_VALUE_LIMITS: Readonly<CanonicalValueLimits>;
+export declare function resolveLimits(options?: CanonicalValueOptions): Readonly<CanonicalValueLimits>;
+//# sourceMappingURL=limits.d.ts.map

package/dist/values/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/values/limits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAM9E,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,oBAAoB,CAQxE,CAAC;AAEH,wBAAgB,aAAa,CAC3B,OAAO,GAAE,qBAA0B,GAClC,QAAQ,CAAC,oBAAoB,CAAC,CAuBhC"}

package/dist/values/limits.js

@@ -0,0 +1,26 @@
+export const DEFAULT_CANONICAL_VALUE_LIMITS = Object.freeze({
+    maxInputBytes: 1_048_576,
+    maxCanonicalBytes: 1_048_576,
+    maxDepth: 16,
+    maxNodes: 10_000,
+    maxCollectionItems: 1_000,
+    maxStringBytes: 65_536,
+    maxDecodedBytes: 65_536,
+});
+export function resolveLimits(options = {}) {
+    const resolved = { ...DEFAULT_CANONICAL_VALUE_LIMITS };
+    if (!options.limits) {
+        return resolved;
+    }
+    for (const key of Object.keys(options.limits)) {
+        const value = options.limits[key];
+        if (value === undefined
+            || !Number.isSafeInteger(value)
+            || value < 1
+            || value > DEFAULT_CANONICAL_VALUE_LIMITS[key]) {
+            throw new RangeError(`${key} must be a positive integer no greater than the protocol v1 maximum`);
+        }
+        resolved[key] = value;
+    }
+    return Object.freeze(resolved);
+}

package/dist/values/parser.d.ts

@@ -0,0 +1,3 @@
+import type { CanonicalValueLimits } from './types.js';
+export declare function parseDuplicateAwareJson(input: string | Uint8Array, limits: Readonly<CanonicalValueLimits>): unknown;
+//# sourceMappingURL=parser.d.ts.map

package/dist/values/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/values/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAoPvD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GAAG,UAAU,EAC1B,MAAM,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GACrC,OAAO,CA6BT"}