@ts-runtypes/core 0.9.1 → 0.9.3

package/dist/cjs/fnHash.d.ts

@@ -0,0 +1,8 @@
+import { FN_HASHES } from './fnHashes.generated.ts';
+export type FnHashKey = keyof typeof FN_HASHES;
+export interface FnHashOptions {
+    noLiterals?: boolean;
+    noIsArrayCheck?: boolean;
+    strategy?: string;
+}
+export declare function getFnHash(fnKey: FnHashKey | (string & {}), options?: FnHashOptions): string;

package/dist/cjs/fnHash.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFnHash = getFnHash;
+const fnHashes_generated_ts_1 = require("./fnHashes.generated.js");
+function validateVariantToken(options) {
+    if (!options)
+        return '';
+    let suffix = 'N';
+    let hit = false;
+    for (const [name, letter] of fnHashes_generated_ts_1.VALIDATE_OPTION_LETTERS) {
+        if (options[name]) {
+            suffix += letter;
+            hit = true;
+        }
+    }
+    return hit ? suffix : '';
+}
+function getFnHash(fnKey, options) {
+    const entry = fnHashes_generated_ts_1.FN_HASHES[fnKey];
+    if (!entry)
+        throw new Error(`getFnHash: unknown fnKey ${JSON.stringify(fnKey)}`);
+    let token = '';
+    if (entry.axis === 'validateOptions')
+        token = validateVariantToken(options);
+    else if (entry.axis === 'jsonStrategy')
+        token = options?.strategy ?? entry.defaultVariant ?? '';
+    const hash = entry.variants[token];
+    if (hash === undefined)
+        throw new Error(`getFnHash: fnKey ${JSON.stringify(fnKey)} has no ${JSON.stringify(token)} variant`);
+    return hash;
+}

package/dist/cjs/fnHashes.generated.d.ts

@@ -0,0 +1,130 @@
+export type FnHashAxis = 'none' | 'validateOptions' | 'jsonStrategy';
+export interface FnHashEntry {
+    readonly axis: FnHashAxis;
+    readonly defaultVariant?: string;
+    readonly variants: Readonly<Record<string, string>>;
+}
+export declare const FN_HASHES: {
+    readonly cj: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "xnN";
+        };
+    };
+    readonly cjr: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "Siw";
+        };
+    };
+    readonly fb: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "mY6";
+        };
+    };
+    readonly fmt: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "SS6";
+        };
+    };
+    readonly huk: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "trR";
+        };
+    };
+    readonly jsonDecoder: {
+        readonly axis: "jsonStrategy";
+        readonly defaultVariant: "strip";
+        readonly variants: {
+            readonly compact: "MCy";
+            readonly preserve: "J5l";
+            readonly strip: "fDV";
+        };
+    };
+    readonly jsonEncoder: {
+        readonly axis: "jsonStrategy";
+        readonly defaultVariant: "clone";
+        readonly variants: {
+            readonly clone: "wUi";
+            readonly compact: "yeS";
+            readonly direct: "y0u";
+            readonly mutate: "z1L";
+        };
+    };
+    readonly pj: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "tt1";
+        };
+    };
+    readonly pjs: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "oak";
+        };
+    };
+    readonly rj: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "X13";
+        };
+    };
+    readonly sj: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "qm4";
+        };
+    };
+    readonly suk: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "rRP";
+        };
+    };
+    readonly tb: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "plZ";
+        };
+    };
+    readonly uke: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "XFJ";
+        };
+    };
+    readonly uku: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "emC";
+        };
+    };
+    readonly ukuw: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "N3x";
+        };
+    };
+    readonly val: {
+        readonly axis: "validateOptions";
+        readonly variants: {
+            readonly '': "nPZ";
+            readonly NA: "WeU";
+            readonly NL: "N7J";
+            readonly NLA: "GYK";
+        };
+    };
+    readonly verr: {
+        readonly axis: "validateOptions";
+        readonly variants: {
+            readonly '': "pBb";
+            readonly NA: "UKg";
+            readonly NL: "LD5";
+            readonly NLA: "Yk4";
+        };
+    };
+};
+export declare const VALIDATE_OPTION_LETTERS: readonly [readonly ["noLiterals", "L"], readonly ["noIsArrayCheck", "A"]];

package/dist/cjs/fnHashes.generated.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALIDATE_OPTION_LETTERS = exports.FN_HASHES = void 0;
+exports.FN_HASHES = {
+    cj: { axis: 'none', variants: { '': 'xnN' } },
+    cjr: { axis: 'none', variants: { '': 'Siw' } },
+    fb: { axis: 'none', variants: { '': 'mY6' } },
+    fmt: { axis: 'none', variants: { '': 'SS6' } },
+    huk: { axis: 'none', variants: { '': 'trR' } },
+    jsonDecoder: { axis: 'jsonStrategy', defaultVariant: 'strip', variants: { compact: 'MCy', preserve: 'J5l', strip: 'fDV' } },
+    jsonEncoder: {
+        axis: 'jsonStrategy',
+        defaultVariant: 'clone',
+        variants: { clone: 'wUi', compact: 'yeS', direct: 'y0u', mutate: 'z1L' },
+    },
+    pj: { axis: 'none', variants: { '': 'tt1' } },
+    pjs: { axis: 'none', variants: { '': 'oak' } },
+    rj: { axis: 'none', variants: { '': 'X13' } },
+    sj: { axis: 'none', variants: { '': 'qm4' } },
+    suk: { axis: 'none', variants: { '': 'rRP' } },
+    tb: { axis: 'none', variants: { '': 'plZ' } },
+    uke: { axis: 'none', variants: { '': 'XFJ' } },
+    uku: { axis: 'none', variants: { '': 'emC' } },
+    ukuw: { axis: 'none', variants: { '': 'N3x' } },
+    val: { axis: 'validateOptions', variants: { '': 'nPZ', NA: 'WeU', NL: 'N7J', NLA: 'GYK' } },
+    verr: { axis: 'validateOptions', variants: { '': 'pBb', NA: 'UKg', NL: 'LD5', NLA: 'Yk4' } },
+};
+exports.VALIDATE_OPTION_LETTERS = [
+    ['noLiterals', 'L'],
+    ['noIsArrayCheck', 'A'],
+];

package/dist/cjs/formats/string/stringFormats.d.ts

@@ -147,6 +147,7 @@ export interface DomainParams {
     mockSamples?: readonly string[];
     names?: DomainPartParams;
     tld?: DomainPartParams;
+    allowedValues?: AllowedValuesParam;
 }
 export type Domain = TypeFormat<string, 'domain', {
     pattern: typeof DOMAIN_PATTERN;

package/dist/cjs/index.d.ts

@@ -9,6 +9,7 @@ import type { FriendlyText } from './enrich/friendlyText.ts';
 export type FriendlyType<T> = FriendlyText<T>;
 export { type MockData, type MockNode } from './enrich/mockData.ts';
 export { createFriendlyText, createFriendlyTextI18n, resolveLocale, type FriendlyMessage, type FriendlyRenderer, type FriendlyI18nOptions, } from './enrich/createFriendlyText.ts';
+export { getFnHash, type FnHashKey, type FnHashOptions } from './fnHash.ts';
 export { registerPureFnFactory, type PureFnId } from './runtypes/pureFn.ts';
 import './runtypes/pure-fns-utils.ts';
 export { registerClassSerializer, type ClassSerializerHandler, type AnyClass, type SerializableClass, type DeserializeClassFn, } from './runtypes/classSerializerRegistry.ts';
@@ -16,7 +17,7 @@ export { type TypeFormat, type TypeFormatBase, type TypeFormatParams } from './r
 export { type FormatAnnotation } from './runtypes/formatAnnotation.ts';
 export { registerMockingFunction, type MockFormatFn } from './mocking/mockRegistry.ts';
 export { registerFormatPattern, type FormatPattern, type StringPatternArgs } from './runtypes/formatPattern.ts';
-export { RunTypeKind, type RunTypeKindValue } from './runTypeKind.ts';
+export { RunTypeKind, type RunTypeKindName, type RunTypeKindValue, RunTypeSubKind, type RunTypeSubKindName, type RunTypeSubKindValue, } from './runTypeKind.ts';
 export { getRTFunction, type RTFunctionByKey, type RTFunctionKey, createValidate, type ValidateFn, type ValidateOptions, createGetValidationErrors, type GetValidationErrorsFn, type RTValidationError, type TypeFormatError, type RTValidationErrorPathSegment, type RTPathSegment, createHasUnknownKeys, type HasUnknownKeysFn, type HasUnknownKeysOptions, createStripUnknownKeys, type StripUnknownKeysFn, createUnknownKeyErrors, type UnknownKeyErrorsFn, createUnknownKeysToUndefined, type UnknownKeysToUndefinedFn, createFormatTransform, type FormatTransformFn, createJsonEncoder, type JsonEncoderFn, type JsonEncoderOptions, createJsonDecoder, type JsonDecoderFn, type JsonDecoderOptions, type PrepareForJsonFn, type RestoreFromJsonFn, type StringifyJsonFn, } from './createRTFunctions.ts';
 export { createBinaryEncoder, type BinaryEncoderFn, type BinaryEncoderSizeFn, type BinaryEncoderIntoFn, type BinaryEncoderOptions, createBinarySizer, type BinarySizerFn, createBinaryDecoder, type BinaryDecoderFn, type BinaryDecoderOptions, type ToBinaryFn, type FromBinaryFn, } from './createRTFBinary.ts';
 export { overrideValidate, overrideGetValidationErrors, overrideHasUnknownKeys, overrideStripUnknownKeys, overrideUnknownKeyErrors, overrideUnknownKeysToUndefined, overrideFormatTransform, overrideBinaryEncoder, overrideBinaryDecoder, overrideJsonEncoder, overrideJsonDecoder, } from './overrideRTFunctions.ts';

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSerializationOptions = exports.createDataViewDeserializer = exports.createDataViewSerializer = exports.CircularReferenceError = exports.isRejectCircularRefsEnabled = exports.setRejectCircularRefs = exports.runTypeErrorsToIssues = exports.createStandardSchema = exports.createMockData = exports.overrideJsonDecoder = exports.overrideJsonEncoder = exports.overrideBinaryDecoder = exports.overrideBinaryEncoder = exports.overrideFormatTransform = exports.overrideUnknownKeysToUndefined = exports.overrideUnknownKeyErrors = exports.overrideStripUnknownKeys = exports.overrideHasUnknownKeys = exports.overrideGetValidationErrors = exports.overrideValidate = exports.createBinaryDecoder = exports.createBinarySizer = exports.createBinaryEncoder = exports.createJsonDecoder = exports.createJsonEncoder = exports.createFormatTransform = exports.createUnknownKeysToUndefined = exports.createUnknownKeyErrors = exports.createStripUnknownKeys = exports.createHasUnknownKeys = exports.createGetValidationErrors = exports.createValidate = exports.getRTFunction = exports.RunTypeKind = exports.registerFormatPattern = exports.registerMockingFunction = exports.registerClassSerializer = exports.registerPureFnFactory = exports.resolveLocale = exports.createFriendlyTextI18n = exports.createFriendlyText = exports.getRunType = exports.getRTFnCaches = exports.getRTUtils = exports.getRunTypeId = void 0;
+exports.setSerializationOptions = exports.createDataViewDeserializer = exports.createDataViewSerializer = exports.CircularReferenceError = exports.isRejectCircularRefsEnabled = exports.setRejectCircularRefs = exports.runTypeErrorsToIssues = exports.createStandardSchema = exports.createMockData = exports.overrideJsonDecoder = exports.overrideJsonEncoder = exports.overrideBinaryDecoder = exports.overrideBinaryEncoder = exports.overrideFormatTransform = exports.overrideUnknownKeysToUndefined = exports.overrideUnknownKeyErrors = exports.overrideStripUnknownKeys = exports.overrideHasUnknownKeys = exports.overrideGetValidationErrors = exports.overrideValidate = exports.createBinaryDecoder = exports.createBinarySizer = exports.createBinaryEncoder = exports.createJsonDecoder = exports.createJsonEncoder = exports.createFormatTransform = exports.createUnknownKeysToUndefined = exports.createUnknownKeyErrors = exports.createStripUnknownKeys = exports.createHasUnknownKeys = exports.createGetValidationErrors = exports.createValidate = exports.getRTFunction = exports.RunTypeSubKind = exports.RunTypeKind = exports.registerFormatPattern = exports.registerMockingFunction = exports.registerClassSerializer = exports.registerPureFnFactory = exports.getFnHash = exports.resolveLocale = exports.createFriendlyTextI18n = exports.createFriendlyText = exports.getRunType = exports.getRTFnCaches = exports.getRTUtils = exports.getRunTypeId = void 0;
 var markers_ts_1 = require("./markers.js");
 Object.defineProperty(exports, "getRunTypeId", { enumerable: true, get: function () { return markers_ts_1.getRunTypeId; } });
 var rtUtils_ts_1 = require("./runtypes/rtUtils.js");
@@ -12,6 +12,8 @@ var createFriendlyText_ts_1 = require("./enrich/createFriendlyText.js");
 Object.defineProperty(exports, "createFriendlyText", { enumerable: true, get: function () { return createFriendlyText_ts_1.createFriendlyText; } });
 Object.defineProperty(exports, "createFriendlyTextI18n", { enumerable: true, get: function () { return createFriendlyText_ts_1.createFriendlyTextI18n; } });
 Object.defineProperty(exports, "resolveLocale", { enumerable: true, get: function () { return createFriendlyText_ts_1.resolveLocale; } });
+var fnHash_ts_1 = require("./fnHash.js");
+Object.defineProperty(exports, "getFnHash", { enumerable: true, get: function () { return fnHash_ts_1.getFnHash; } });
 var pureFn_ts_1 = require("./runtypes/pureFn.js");
 Object.defineProperty(exports, "registerPureFnFactory", { enumerable: true, get: function () { return pureFn_ts_1.registerPureFnFactory; } });
 require("./runtypes/pure-fns-utils.js");
@@ -23,6 +25,7 @@ var formatPattern_ts_1 = require("./runtypes/formatPattern.js");
 Object.defineProperty(exports, "registerFormatPattern", { enumerable: true, get: function () { return formatPattern_ts_1.registerFormatPattern; } });
 var runTypeKind_ts_1 = require("./runTypeKind.js");
 Object.defineProperty(exports, "RunTypeKind", { enumerable: true, get: function () { return runTypeKind_ts_1.RunTypeKind; } });
+Object.defineProperty(exports, "RunTypeSubKind", { enumerable: true, get: function () { return runTypeKind_ts_1.RunTypeSubKind; } });
 var createRTFunctions_ts_1 = require("./createRTFunctions.js");
 Object.defineProperty(exports, "getRTFunction", { enumerable: true, get: function () { return createRTFunctions_ts_1.getRTFunction; } });
 Object.defineProperty(exports, "createValidate", { enumerable: true, get: function () { return createRTFunctions_ts_1.createValidate; } });

package/dist/cjs/mocking/mockStringFormat.js

@@ -44,7 +44,8 @@ function mockStringParams(params) {
     if (charSet)
         return randomStringFrom(charSet, Math.max(1, pickMockLength(params)));
     if (params.pattern !== undefined) {
-        throw new Error('StringFormat: a `pattern` requires `mockSamples` to mock — none provided.');
+        throw new Error('StringFormat: a `pattern` requires `mockSamples` compatible with the length bounds to mock — ' +
+            'none provided, or every sample violates length/minLength/maxLength.');
     }
     return randomString(pickMockLength(params));
 }
@@ -57,7 +58,7 @@ function filterSamplesByLength(samples, params) {
         return samples;
     if (params.length === undefined && params.minLength === undefined && params.maxLength === undefined)
         return samples;
-    const kept = samples.filter((sample) => {
+    return samples.filter((sample) => {
         if (params.length !== undefined && sample.length !== params.length)
             return false;
         if (params.minLength !== undefined && sample.length < params.minLength)
@@ -66,7 +67,6 @@ function filterSamplesByLength(samples, params) {
             return false;
         return true;
     });
-    return kept.length > 0 ? kept : samples;
 }
 function pickSample(samples) {
     if (!samples || samples.length === 0)
@@ -164,6 +164,11 @@ function randomPort() {
     return Math.floor(Math.random() * 65536);
 }
 function mockDomain(params) {
+    if (params.allowedValues) {
+        const allowed = pickSample(params.allowedValues.val);
+        if (allowed !== undefined)
+            return allowed;
+    }
     if (params.names || params.tld) {
         const name = pickSample(domainPartSamples(params.names)) ?? 'example';
         const tld = pickSample(domainPartSamples(params.tld)) ?? 'com';

package/dist/cjs/mocking/mockType.js

@@ -28,9 +28,9 @@ function mockRunType(runType, options, stack = []) {
         stack.pop();
     }
 }
-const FORMAT_TRANSFORM_PREFIX = 'fmt_';
+const FORMAT_TRANSFORM_FAMILY = 'fmt';
 function lookupFormatTransform(id) {
-    const entry = (0, rtUtils_ts_1.getRTUtils)().getRT(FORMAT_TRANSFORM_PREFIX + id);
+    const entry = (0, rtUtils_ts_1.getRTUtils)().findRTForType(FORMAT_TRANSFORM_FAMILY, id);
     if (!entry || entry.isNoop || !entry.fn)
         return undefined;
     return entry.fn;

package/dist/cjs/runtypes/classSerializerRegistry.d.ts

@@ -21,7 +21,7 @@ export declare function registerClassSerializer<T>(cls: SerializableClass<T>, ha
 export declare function registerClassSerializer<T>(cls: AnyClass<T>, handler: ClassSerializerHandler<T> & {
     deserialize(data: DataOnly<T>): T;
 }, id?: InjectRunTypeId<T>): void;
-export declare function getClassSerializer(typeId: string): ClassSerializerEntry | undefined;
+export declare function getClassSerializer(typeId: string, className?: string): ClassSerializerEntry | undefined;
 export declare function isClassSerializerRegistered(cls: AnyClass): boolean;
 export declare function deserializeClass<T>(entry: ClassSerializerEntry<T>, data: DataOnly<T>): T;
 export declare function unregisterClassSerializer(cls: AnyClass): void;

package/dist/cjs/runtypes/classSerializerRegistry.js

@@ -8,8 +8,11 @@ exports.deserializeClass = deserializeClass;
 exports.unregisterClassSerializer = unregisterClassSerializer;
 exports.clearClassSerializers = clearClassSerializers;
 const entryTuple_ts_1 = require("./entryTuple.js");
+const rtUtils_ts_1 = require("./rtUtils.js");
 const classSerializers = new Map();
-const classToKey = new Map();
+const classSerializersByName = new Map();
+const classStates = new Map();
+const warnedAmbiguousNames = new Set();
 let epoch = 0;
 function classSerializerEpoch() {
     return epoch;
@@ -23,28 +26,62 @@ function classSerializerKey(id, cls) {
         return id;
     throw new Error(`[ts-runtypes] registerClassSerializer(${cls.name || '<anonymous>'}): no type id injected. ` +
         `The ts-runtypes-devtools plugin must process the registration file so the class's ` +
-        `type id can be injected (the registry is keyed by type id, not name).`);
+        `type id can be injected (the registry is keyed by type id + class name).`);
+}
+function classSerializerName(key, cls) {
+    const node = (0, rtUtils_ts_1.getRTUtils)().getRunType(key);
+    const typeName = node?.typeName;
+    if (typeof typeName === 'string' && typeName.length > 0)
+        return typeName;
+    return cls.name || undefined;
+}
+function indexByName(name, entry) {
+    let entries = classSerializersByName.get(name);
+    if (!entries) {
+        entries = new Set();
+        classSerializersByName.set(name, entries);
+    }
+    entries.add(entry);
+    if (entries.size > 1 && !warnedAmbiguousNames.has(name)) {
+        warnedAmbiguousNames.add(name);
+        console.warn(`[ts-runtypes] registerClassSerializer: ${entries.size} different classes named "${name}" are registered. ` +
+            `The class-name fallback is disabled for "${name}" — only exact-instantiation matches will use the registry ` +
+            `(other generic instantiations of these classes fall back to structural decode).`);
+    }
 }
 function registerClassSerializer(cls, handler, id) {
     if (typeof cls !== 'function')
         throw new Error('registerClassSerializer: cls must be a class constructor');
     const key = classSerializerKey(id, cls);
-    const prior = classToKey.get(cls);
-    if (prior && prior !== key)
-        classSerializers.delete(prior);
-    classSerializers.set(key, {
-        cls,
-        serialize: handler?.serialize,
-        deserialize: handler?.deserialize,
-    });
-    classToKey.set(cls, key);
+    let state = classStates.get(cls);
+    if (!state) {
+        state = { entry: { cls }, keys: new Set() };
+        classStates.set(cls, state);
+    }
+    state.entry.serialize = handler?.serialize;
+    state.entry.deserialize = handler?.deserialize;
+    state.keys.add(key);
+    classSerializers.set(key, state.entry);
+    const name = classSerializerName(key, cls);
+    if (name && state.name === undefined) {
+        state.name = name;
+        indexByName(name, state.entry);
+    }
     epoch++;
 }
-function getClassSerializer(typeId) {
-    return classSerializers.get(typeId);
+function getClassSerializer(typeId, className) {
+    const exact = classSerializers.get(typeId);
+    if (exact)
+        return exact;
+    if (!className)
+        return undefined;
+    const entries = classSerializersByName.get(className);
+    if (!entries || entries.size !== 1)
+        return undefined;
+    return entries.values().next().value;
 }
 function isClassSerializerRegistered(cls) {
-    return classToKey.has(cls);
+    return classStates.has(cls);
 }
 function deserializeClass(entry, data) {
     if (entry.deserialize)
@@ -62,15 +99,24 @@ function deserializeClass(entry, data) {
     }
 }
 function unregisterClassSerializer(cls) {
-    const key = classToKey.get(cls);
-    if (key === undefined)
+    const state = classStates.get(cls);
+    if (!state)
         return;
-    classSerializers.delete(key);
-    classToKey.delete(cls);
+    for (const key of state.keys)
+        classSerializers.delete(key);
+    if (state.name !== undefined) {
+        const entries = classSerializersByName.get(state.name);
+        entries?.delete(state.entry);
+        if (entries && entries.size === 0)
+            classSerializersByName.delete(state.name);
+    }
+    classStates.delete(cls);
     epoch++;
 }
 function clearClassSerializers() {
     classSerializers.clear();
-    classToKey.clear();
+    classSerializersByName.clear();
+    classStates.clear();
+    warnedAmbiguousNames.clear();
     epoch++;
 }

package/dist/cjs/runtypes/entryTuple.d.ts

@@ -8,7 +8,7 @@ declare const KIND_RUN_TYPE_FACADE = 5;
 export declare const FN_HASH_LEN = 3;
 export type EntryDepsThunk = () => readonly EntryTuple[];
 export type RunTypeIni = (rtu: RTUtils) => void;
-declare const RUN_TYPE_FIELD_KEYS: readonly ["id", "kind", "subKind", "typeName", "name", "literal", "optional", "readonly", "isAbstract", "isStatic", "visibility", "isSafeName", "position", "isCircular", "flags", "description", "defaultVal", "enumVal", "values", "notSupported"];
+declare const RUN_TYPE_FIELD_KEYS: readonly ["id", "kind", "subKind", "typeName", "name", "literal", "optional", "readonly", "isAbstract", "isStatic", "visibility", "isSafeName", "position", "isCircular", "flags", "description", "defaultVal", "enumVal", "values", "notSupported", "nonEnumerable"];
 export type RunTypeRowRecord = Pick<RunType, (typeof RUN_TYPE_FIELD_KEYS)[number]>;
 type RunTypeRel = number | string | object;
 export type RunTypeRelRow = readonly (RunTypeRel | readonly RunTypeRel[] | undefined)[];
@@ -56,7 +56,7 @@ type TupleFrom<R, K extends readonly (keyof R)[]> = {
 declare const ENTRY_HEAD_KEYS: readonly ["entryKind", "deps", "ini"];
 type RunTypeRowRequiredKeys = readonly ['id', 'kind'];
 type RunTypeRowTrimmedKeys = typeof RUN_TYPE_FIELD_KEYS extends readonly [unknown, unknown, ...infer Rest] ? Rest : never;
-export declare const RUN_TYPE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "id", "kind", "subKind", "typeName", "name", "literal", "optional", "readonly", "isAbstract", "isStatic", "visibility", "isSafeName", "position", "isCircular", "flags", "description", "defaultVal", "enumVal", "values", "notSupported"];
+export declare const RUN_TYPE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "id", "kind", "subKind", "typeName", "name", "literal", "optional", "readonly", "isAbstract", "isStatic", "visibility", "isSafeName", "position", "isCircular", "flags", "description", "defaultVal", "enumVal", "values", "notSupported", "nonEnumerable"];
 export declare const RUN_TYPE_BUNDLE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key", "rows", "rels"];
 export declare const RUN_TYPE_FACADE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key"];
 declare const FN_TYPE_REQUIRED_KEYS: readonly ["familyTag", "deps", "ini", "rtFnHash", "typeName", "code"];

package/dist/cjs/runtypes/entryTuple.js

@@ -36,6 +36,7 @@ const RUN_TYPE_FIELD_KEYS = [
     'enumVal',
     'values',
     'notSupported',
+    'nonEnumerable',
 ];
 const RUN_TYPE_REL_KEYS = [
     'child',

package/dist/cjs/runtypes/rtUtils.d.ts

@@ -8,6 +8,7 @@ declare const rtUtils: {
     addToRTCache(comp: CompiledTypeFn): void;
     removeFromRTCache(comp: CompiledTypeFn): void;
     getRT(rtFnHash: string): InitializedTypeFn | undefined;
+    findRTForType(familyTag: string, typeId: string): InitializedTypeFn | undefined;
     getRTFn(rtFnHash: string): (...args: any[]) => any;
     hasRTFn(rtFnHash: string): boolean;
     addPureFn(key: string, compiledFn: CompiledPureFunction): CompiledPureFunction;
@@ -22,7 +23,7 @@ declare const rtUtils: {
     useRunType(id: string): RunType;
     hasRunType(id: string): boolean;
     alwaysThrowFactory(message: string): () => never;
-    getClassSerializer(typeId: string): ClassSerializerEntry | undefined;
+    getClassSerializer(typeId: string, className?: string): ClassSerializerEntry | undefined;
     csEpoch(): number;
     deserializeClass<T>(entry: ClassSerializerEntry<T>, data: DataOnly<T>): T;
 };

package/dist/cjs/runtypes/rtUtils.js

@@ -31,6 +31,19 @@ const rtUtils = {
         materializeRTFn(entry);
         return entry;
     },
+    findRTForType(familyTag, typeId) {
+        const suffix = '_' + typeId;
+        for (const key of Object.keys(rtFnsCache)) {
+            if (!key.endsWith(suffix))
+                continue;
+            const entry = rtFnsCache[key];
+            if (!entry || entry.familyTag !== familyTag)
+                continue;
+            materializeRTFn(entry);
+            return entry;
+        }
+        return undefined;
+    },
     getRTFn(rtFnHash) {
         const entry = rtFnsCache[rtFnHash];
         if (!entry)
@@ -114,8 +127,8 @@ const rtUtils = {
             throw new Error(message);
         };
     },
-    getClassSerializer(typeId) {
-        return (0, classSerializerRegistry_ts_1.getClassSerializer)(typeId);
+    getClassSerializer(typeId, className) {
+        return (0, classSerializerRegistry_ts_1.getClassSerializer)(typeId, className);
     },
     csEpoch() {
         return (0, classSerializerRegistry_ts_1.classSerializerEpoch)();

package/dist/cjs/runtypes/types.d.ts

@@ -25,6 +25,7 @@ export interface RunType<T = unknown> {
     literal?: unknown;
     optional?: unknown;
     readonly?: unknown;
+    nonEnumerable?: boolean;
     isAbstract?: unknown;
     isStatic?: unknown;
     visibility?: unknown;

package/dist/fnHash.d.ts

@@ -0,0 +1,9 @@
+import { FN_HASHES } from './fnHashes.generated.ts';
+export type FnHashKey = keyof typeof FN_HASHES;
+export interface FnHashOptions {
+    noLiterals?: boolean;
+    noIsArrayCheck?: boolean;
+    strategy?: string;
+}
+export declare function getFnHash(fnKey: FnHashKey | (string & {}), options?: FnHashOptions): string;
+//# sourceMappingURL=fnHash.d.ts.map

package/dist/fnHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fnHash.d.ts","sourceRoot":"","sources":["../src/fnHash.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAC,SAAS,EAA4C,MAAM,yBAAyB,CAAC;AAK7F,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,SAAS,CAAC;AAO/C,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAuBD,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAS3F"}

package/dist/fnHash.js

@@ -0,0 +1,29 @@
+import { FN_HASHES, VALIDATE_OPTION_LETTERS } from "./fnHashes.generated.js";
+function validateVariantToken(options) {
+    if (!options)
+        return '';
+    let suffix = 'N';
+    let hit = false;
+    for (const [name, letter] of VALIDATE_OPTION_LETTERS) {
+        if (options[name]) {
+            suffix += letter;
+            hit = true;
+        }
+    }
+    return hit ? suffix : '';
+}
+export function getFnHash(fnKey, options) {
+    const entry = FN_HASHES[fnKey];
+    if (!entry)
+        throw new Error(`getFnHash: unknown fnKey ${JSON.stringify(fnKey)}`);
+    let token = '';
+    if (entry.axis === 'validateOptions')
+        token = validateVariantToken(options);
+    else if (entry.axis === 'jsonStrategy')
+        token = options?.strategy ?? entry.defaultVariant ?? '';
+    const hash = entry.variants[token];
+    if (hash === undefined)
+        throw new Error(`getFnHash: fnKey ${JSON.stringify(fnKey)} has no ${JSON.stringify(token)} variant`);
+    return hash;
+}
+//# sourceMappingURL=fnHash.js.map

package/dist/fnHash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fnHash.js","sourceRoot":"","sources":["../src/fnHash.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAC,SAAS,EAAE,uBAAuB,EAAmB,MAAM,yBAAyB,CAAC;AAsB7F,SAAS,oBAAoB,CAAC,OAAkC;IAC9D,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IACxB,IAAI,MAAM,GAAG,GAAG,CAAC;IACjB,IAAI,GAAG,GAAG,KAAK,CAAC;IAChB,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,uBAAuB,EAAE,CAAC;QACrD,IAAI,OAAO,CAAC,IAAuC,CAAC,EAAE,CAAC;YACrD,MAAM,IAAI,MAAM,CAAC;YACjB,GAAG,GAAG,IAAI,CAAC;QACb,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AAC3B,CAAC;AAMD,MAAM,UAAU,SAAS,CAAC,KAAgC,EAAE,OAAuB;IACjF,MAAM,KAAK,GAAG,SAAS,CAAC,KAAkB,CAA4B,CAAC;IACvE,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACjF,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,IAAI,KAAK,CAAC,IAAI,KAAK,iBAAiB;QAAE,KAAK,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;SACvE,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc;QAAE,KAAK,GAAG,OAAO,EAAE,QAAQ,IAAI,KAAK,CAAC,cAAc,IAAI,EAAE,CAAC;IAChG,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACnC,IAAI,IAAI,KAAK,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAC7H,OAAO,IAAI,CAAC;AACd,CAAC"}