@ts-runtypes/core 0.10.0 → 0.11.0

package/README.md

@@ -0,0 +1,31 @@
+# @ts-runtypes/core
+
+**Compile-time runtime types for TypeScript 7 / typescript-go (tsgo).**
+
+TypeScript throws your types away before your code ever runs. RunTypes reads them
+first, at build time, and hands the runtime back what it lost: validators, JSON and
+binary (de)serializers, mock data, and reflection.
+
+This is the runtime package: the sentinel markers the compiler looks for, plus the
+small helper runtime the generated code calls into. It has **zero dependencies**.
+The build-time half lives in
+[`@ts-runtypes/devtools`](https://www.npmjs.com/package/@ts-runtypes/devtools).
+
+## Documentation
+
+Install, guides, the factory reference, and benchmarks live at
+**[runtypes.pages.dev](https://runtypes.pages.dev/)**.
+
+- [Quick start](https://runtypes.pages.dev/introduction/quick-start)
+- [Configuration](https://runtypes.pages.dev/introduction/configuration)
+- [Source and issues](https://github.com/MionKit/ts-run-types)
+
+## Status
+
+Experimental.
+
+## License
+
+Proprietary — all rights reserved. No use, copying, or distribution without prior
+written authorization. See
+[LICENSE](https://github.com/MionKit/ts-run-types/blob/main/LICENSE).

package/dist/cjs/createRTFBinary.d.ts

@@ -22,15 +22,15 @@ export interface BinaryEncoderOptions {
 export interface BinaryDecoderOptions {
     cacheKey?: string;
 }
-export declare function createBinaryEncoder<T>(schema: RunType<T>, options: InitialSizeOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderSizeFn;
-export declare function createBinaryEncoder<T>(val: T | undefined, options: InitialSizeOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderSizeFn;
-export declare function createBinaryEncoder<T>(schema: RunType<T>, options: IntoBufferOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderIntoFn;
-export declare function createBinaryEncoder<T>(val: T | undefined, options: IntoBufferOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderIntoFn;
-export declare function createBinaryEncoder<T>(schema: RunType<T>, options?: BinaryEncoderOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderFn;
-export declare function createBinaryEncoder<T>(val?: T, options?: BinaryEncoderOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderFn;
+export declare function createBinaryEncoderFn<T>(schema: RunType<T>, options: InitialSizeOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderSizeFn;
+export declare function createBinaryEncoderFn<T>(val: T | undefined, options: InitialSizeOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderSizeFn;
+export declare function createBinaryEncoderFn<T>(schema: RunType<T>, options: IntoBufferOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderIntoFn;
+export declare function createBinaryEncoderFn<T>(val: T | undefined, options: IntoBufferOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderIntoFn;
+export declare function createBinaryEncoderFn<T>(schema: RunType<T>, options?: BinaryEncoderOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderFn;
+export declare function createBinaryEncoderFn<T>(val?: T, options?: BinaryEncoderOptions, id?: InjectTypeFnArgs<T, 'tb'>): BinaryEncoderFn;
 export type BinarySizerFn = (value: unknown) => number;
-export declare function createBinarySizer<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, 'tb'>): BinarySizerFn;
-export declare function createBinarySizer<T>(val?: T, id?: InjectTypeFnArgs<T, 'tb'>): BinarySizerFn;
-export declare function createBinaryDecoder<T>(schema: RunType<T>, options?: BinaryDecoderOptions, id?: InjectTypeFnArgs<T, 'fb'>): BinaryDecoderFn<DataOnly<T>>;
-export declare function createBinaryDecoder<T>(val?: T, options?: BinaryDecoderOptions, id?: InjectTypeFnArgs<T, 'fb'>): BinaryDecoderFn<DataOnly<T>>;
+export declare function createBinarySizerFn<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, 'tb'>): BinarySizerFn;
+export declare function createBinarySizerFn<T>(val?: T, id?: InjectTypeFnArgs<T, 'tb'>): BinarySizerFn;
+export declare function createBinaryDecoderFn<T>(schema: RunType<T>, options?: BinaryDecoderOptions, id?: InjectTypeFnArgs<T, 'fb'>): BinaryDecoderFn<DataOnly<T>>;
+export declare function createBinaryDecoderFn<T>(val?: T, options?: BinaryDecoderOptions, id?: InjectTypeFnArgs<T, 'fb'>): BinaryDecoderFn<DataOnly<T>>;
 export {};

package/dist/cjs/createRTFBinary.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBinaryEncoder = createBinaryEncoder;
-exports.createBinarySizer = createBinarySizer;
-exports.createBinaryDecoder = createBinaryDecoder;
+exports.createBinaryEncoderFn = createBinaryEncoderFn;
+exports.createBinarySizerFn = createBinarySizerFn;
+exports.createBinaryDecoderFn = createBinaryDecoderFn;
 const rtUtils_ts_1 = require("./runtypes/rtUtils.js");
 const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
 const dataView_ts_1 = require("./runtypes/dataView.js");
 const noopToBinaryFn = (_v, Ser) => Ser;
 const noopFromBinaryFn = (ret) => ret;
 function fixedBufferTooSmall(capacity) {
-    return new RangeError(`createBinaryEncoder: the payload does not fit in the ${capacity}-byte buffer. ` +
-        `Use createBinarySizer<T>() to compute the exact size, enlarge the buffer, or use sizeStrategy 'dynamic' / 'precalculate'.`);
+    return new RangeError(`createBinaryEncoderFn: the payload does not fit in the ${capacity}-byte buffer. ` +
+        `Use createBinarySizerFn<T>() to compute the exact size, enlarge the buffer, or use sizeStrategy 'dynamic' / 'precalculate'.`);
 }
 function encodeFixed(encodeFn, value, ser, capacity) {
     try {
@@ -32,10 +32,10 @@ function binarySizingKey(schemaId, injected) {
         return (0, entryTuple_ts_1.entryTupleKey)(injected).slice(entryTuple_ts_1.FN_HASH_LEN + 1);
     return 'unknown';
 }
-function createBinaryEncoder(valOrSchema, options, id) {
+function createBinaryEncoderFn(valOrSchema, options, id) {
     const schemaId = (0, rtUtils_ts_1.isRunTypeSchema)(valOrSchema) ? valOrSchema.id : undefined;
     const cacheKey = options?.cacheKey ?? binarySizingKey(schemaId, id);
-    const encodeFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createBinaryEncoder', noopToBinaryFn, schemaId, id);
+    const encodeFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createBinaryEncoderFn', noopToBinaryFn, schemaId, id);
     const sizeStrategy = options?.sizeStrategy ?? 'dynamic';
     if (sizeStrategy === 'precalculate') {
         const fn = (value) => {
@@ -51,7 +51,7 @@ function createBinaryEncoder(valOrSchema, options, id) {
     if (sizeStrategy === 'initialSize') {
         const fn = (value, size) => {
             if (typeof size !== 'number')
-                throw new Error("createBinaryEncoder: sizeStrategy 'initialSize' requires a numeric `size` argument.");
+                throw new Error("createBinaryEncoderFn: sizeStrategy 'initialSize' requires a numeric `size` argument.");
             return encodeFixed(encodeFn, value, (0, dataView_ts_1.createDataViewSerializer)(cacheKey, { size, grow: false }), size);
         };
         return fn;
@@ -59,7 +59,7 @@ function createBinaryEncoder(valOrSchema, options, id) {
     if (sizeStrategy === 'intoBuffer') {
         const fn = (value, into) => {
             if (!(into instanceof ArrayBuffer))
-                throw new Error("createBinaryEncoder: sizeStrategy 'intoBuffer' requires an ArrayBuffer `into` argument.");
+                throw new Error("createBinaryEncoderFn: sizeStrategy 'intoBuffer' requires an ArrayBuffer `into` argument.");
             return encodeFixed(encodeFn, value, (0, dataView_ts_1.createDataViewSerializer)(cacheKey, { buffer: into }), into.byteLength);
         };
         return fn;
@@ -73,20 +73,20 @@ function createBinaryEncoder(valOrSchema, options, id) {
     };
     return fn;
 }
-function createBinarySizer(valOrSchema, id) {
+function createBinarySizerFn(valOrSchema, id) {
     const schemaId = (0, rtUtils_ts_1.isRunTypeSchema)(valOrSchema) ? valOrSchema.id : undefined;
     const cacheKey = binarySizingKey(schemaId, id);
-    const encodeFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createBinarySizer', noopToBinaryFn, schemaId, id);
+    const encodeFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createBinarySizerFn', noopToBinaryFn, schemaId, id);
     return (value) => {
         const sizer = (0, dataView_ts_1.createSizingSerializer)(cacheKey);
         encodeFn(value, sizer);
         return sizer.getLength();
     };
 }
-function createBinaryDecoder(valOrSchema, options, id) {
+function createBinaryDecoderFn(valOrSchema, options, id) {
     const schemaId = (0, rtUtils_ts_1.isRunTypeSchema)(valOrSchema) ? valOrSchema.id : undefined;
     const cacheKey = options?.cacheKey ?? binarySizingKey(schemaId, id);
-    const decodeFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createBinaryDecoder', noopFromBinaryFn, schemaId, id);
+    const decodeFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createBinaryDecoderFn', noopFromBinaryFn, schemaId, id);
     return ((input) => {
         let des;
         if (input && typeof input.desString === 'function') {

package/dist/cjs/createRTFunctions.d.ts

@@ -6,6 +6,7 @@ export interface ValidateOptions {
     noLiterals?: boolean;
     noIsArrayCheck?: boolean;
     rejectCircularRefs?: boolean;
+    numberMode?: 'isFinite' | 'typeof' | 'notNaN';
 }
 export type ValidateFn<T = unknown> = (value: unknown) => value is DataOnly<T>;
 export interface RTPathSegment {
@@ -52,16 +53,16 @@ export type JsonDecoderStrategy = 'strip' | 'preserve' | 'compact';
 export type JsonDecoderOptions = {
     strategy?: JsonDecoderStrategy;
 };
-export declare const createValidate: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "val">) => ValidateFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "val">) => ValidateFn<T>);
-export declare const createGetValidationErrors: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "verr">) => GetValidationErrorsFn) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "verr">) => GetValidationErrorsFn);
-export declare const createHasUnknownKeys: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<HasUnknownKeysCompileOptions>, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn) & (<T>(val?: T, options?: CompTimeFnArgs<HasUnknownKeysCompileOptions>, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn);
-export declare const createCloneExactShape: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "ces">) => CloneExactShapeFn<T>) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "ces">) => CloneExactShapeFn<T>);
-export declare const createUnknownKeyErrors: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn);
-export declare const createFormatTransform: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "fmt">) => FormatTransformFn<T>) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "fmt">) => FormatTransformFn<T>);
-export declare function createJsonEncoder<T>(schema: RunType<T>, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
-export declare function createJsonEncoder<T>(val?: T, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
-export declare function createJsonDecoder<T>(schema: RunType<T>, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
-export declare function createJsonDecoder<T>(val?: T, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
+export declare const createValidateFn: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "val">) => ValidateFn<T>) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "val">) => ValidateFn<T>);
+export declare const createGetValidationErrorsFn: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "verr">) => GetValidationErrorsFn) & (<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, id?: InjectTypeFnArgs<T, "verr">) => GetValidationErrorsFn);
+export declare const createHasUnknownKeysFn: (<T>(schema: RunType<T>, options?: CompTimeFnArgs<HasUnknownKeysCompileOptions>, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn) & (<T>(val?: T, options?: CompTimeFnArgs<HasUnknownKeysCompileOptions>, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn);
+export declare const createCloneExactShapeFn: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "ces">) => CloneExactShapeFn<T>) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "ces">) => CloneExactShapeFn<T>);
+export declare const createUnknownKeyErrorsFn: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn);
+export declare const createFormatTransformFn: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "fmt">) => FormatTransformFn<T>) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "fmt">) => FormatTransformFn<T>);
+export declare function createJsonEncoderFn<T>(schema: RunType<T>, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
+export declare function createJsonEncoderFn<T>(val?: T, options?: CompTimeFnArgs<JsonEncoderOptions>, id?: InjectTypeFnArgs<T, 'jsonEncoder'>): JsonEncoderFn;
+export declare function createJsonDecoderFn<T>(schema: RunType<T>, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
+export declare function createJsonDecoderFn<T>(val?: T, options?: CompTimeFnArgs<JsonDecoderOptions>, id?: InjectTypeFnArgs<T, 'jsonDecoder'>): JsonDecoderFn<DataOnly<T>>;
 export interface RTFunctionByKey {
     val: ValidateFn;
     verr: GetValidationErrorsFn;

package/dist/cjs/createRTFunctions.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFormatTransform = exports.createUnknownKeyErrors = exports.createCloneExactShape = exports.createHasUnknownKeys = exports.createGetValidationErrors = exports.createValidate = void 0;
-exports.createJsonEncoder = createJsonEncoder;
-exports.createJsonDecoder = createJsonDecoder;
+exports.createFormatTransformFn = exports.createUnknownKeyErrorsFn = exports.createCloneExactShapeFn = exports.createHasUnknownKeysFn = exports.createGetValidationErrorsFn = exports.createValidateFn = void 0;
+exports.createJsonEncoderFn = createJsonEncoderFn;
+exports.createJsonDecoderFn = createJsonDecoderFn;
 exports.getRTFunction = getRTFunction;
 const rtUtils_ts_1 = require("./runtypes/rtUtils.js");
 const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
@@ -19,19 +19,19 @@ function createRTFunction(fnName, identityFn) {
 const identityValueFn = (v) => v;
 const getValidationErrorsIdentity = () => [];
 const unknownKeyErrorsIdentity = () => [];
-exports.createValidate = createTypeFnArgsFunction('createValidate', (() => true));
-exports.createGetValidationErrors = createTypeFnArgsFunction('createGetValidationErrors', getValidationErrorsIdentity);
-exports.createHasUnknownKeys = createTypeFnArgsFunction('createHasUnknownKeys', () => false);
-exports.createCloneExactShape = createRTFunction('createCloneExactShape', identityValueFn);
-exports.createUnknownKeyErrors = createRTFunction('createUnknownKeyErrors', unknownKeyErrorsIdentity);
-exports.createFormatTransform = createRTFunction('createFormatTransform', identityValueFn);
+exports.createValidateFn = createTypeFnArgsFunction('createValidateFn', (() => true));
+exports.createGetValidationErrorsFn = createTypeFnArgsFunction('createGetValidationErrorsFn', getValidationErrorsIdentity);
+exports.createHasUnknownKeysFn = createTypeFnArgsFunction('createHasUnknownKeysFn', () => false);
+exports.createCloneExactShapeFn = createRTFunction('createCloneExactShapeFn', identityValueFn);
+exports.createUnknownKeyErrorsFn = createRTFunction('createUnknownKeyErrorsFn', unknownKeyErrorsIdentity);
+exports.createFormatTransformFn = createRTFunction('createFormatTransformFn', identityValueFn);
 const jsonStringifyFallback = (v) => JSON.stringify(v);
 const jsonParseFallback = (s) => JSON.parse(s);
-function createJsonEncoder(valOrSchema, _options, id) {
-    return resolveTupleEntry('createJsonEncoder', jsonStringifyFallback, valOrSchema, id);
+function createJsonEncoderFn(valOrSchema, _options, id) {
+    return resolveTupleEntry('createJsonEncoderFn', jsonStringifyFallback, valOrSchema, id);
 }
-function createJsonDecoder(valOrSchema, options, id) {
-    return resolveTupleEntry('createJsonDecoder', jsonParseFallback, valOrSchema, id);
+function createJsonDecoderFn(valOrSchema, options, id) {
+    return resolveTupleEntry('createJsonDecoderFn', jsonParseFallback, valOrSchema, id);
 }
 function getRTFunction(injected, fallback) {
     const identityFn = (fallback ?? ((value) => value));

package/dist/cjs/enrich/createFriendlyText.js

@@ -188,6 +188,25 @@ function renderErrors(state, errs) {
         const sourceNode = state.source ? nodeAt(state.source, group.path) : undefined;
         const label = node?.rt$label || sourceNode?.rt$label || rawLabel(group.path);
         const index = numericIndex(group.path);
+        const first = group.errors[0];
+        const firstVal = primitiveVal(first.format?.val);
+        const rootProvides = resolveTemplate(node, constraintKey(first.format), firstVal, state.rootLocale) !== undefined;
+        const defaultNode = rootProvides ? node : sourceNode;
+        const defaultLocale = rootProvides ? state.rootLocale : state.sourceLocale;
+        const catchAll = leafTemplate(defaultNode?.rt$errors?.rt$default, firstVal, defaultLocale);
+        if (catchAll !== undefined) {
+            out.push({
+                path: group.pathStr,
+                label,
+                message: interpolate(catchAll, {
+                    label,
+                    valText: renderBoundText(state, first.format, firstVal),
+                    path: group.pathStr,
+                    index,
+                }),
+            });
+            continue;
+        }
         for (const err of group.errors) {
             const key = constraintKey(err.format);
             const val = primitiveVal(err.format?.val);

package/dist/cjs/fnHash.d.ts

@@ -3,6 +3,7 @@ export type FnHashKey = keyof typeof FN_HASHES;
 export interface FnHashOptions {
     noLiterals?: boolean;
     noIsArrayCheck?: boolean;
+    numberMode?: string;
     strategy?: string;
     runsAfterValidation?: boolean;
     rejectCircularRefs?: boolean;

package/dist/cjs/fnHash.js

@@ -2,13 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFnHash = getFnHash;
 const fnHashes_generated_ts_1 = require("./go-generated/fnHashes.generated.js");
+function numberModeOptionName(mode) {
+    if (mode === 'typeof')
+        return 'numberTypeof';
+    if (mode === 'notNaN')
+        return 'numberNotNaN';
+    return '';
+}
 function validateVariantToken(options) {
     if (!options)
         return '';
+    const numberModeName = numberModeOptionName(options.numberMode);
     let suffix = 'N';
     let hit = false;
     for (const [name, letter] of fnHashes_generated_ts_1.VALIDATE_OPTION_LETTERS) {
-        if (options[name]) {
+        const present = name === numberModeName || options[name];
+        if (present) {
             suffix += letter;
             hit = true;
         }

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

@@ -119,10 +119,34 @@ export declare const FN_HASHES: {
             readonly C: "cCe";
             readonly NA: "WeU";
             readonly NAC: "fJb";
+            readonly NAM: "D77";
+            readonly NAMC: "ASI";
+            readonly NAT: "CG0";
+            readonly NATC: "jH9";
+            readonly NATM: "zd5";
+            readonly NATMC: "UQE";
             readonly NL: "N7J";
             readonly NLA: "GYK";
             readonly NLAC: "z9t";
+            readonly NLAM: "rXx";
+            readonly NLAMC: "oaW";
+            readonly NLAT: "qwq";
+            readonly NLATC: "XZn";
+            readonly NLATM: "TDn";
+            readonly NLATMC: "w46";
             readonly NLC: "iai";
+            readonly NLM: "iWy";
+            readonly NLMC: "HZv";
+            readonly NLT: "hvr";
+            readonly NLTC: "qOW";
+            readonly NLTM: "CEc";
+            readonly NLTMC: "TDx";
+            readonly NM: "ycI";
+            readonly NMC: "nzd";
+            readonly NT: "xLB";
+            readonly NTC: "WoE";
+            readonly NTM: "OOM";
+            readonly NTMC: "flj";
         };
     };
     readonly verr: {
@@ -133,12 +157,36 @@ export declare const FN_HASHES: {
             readonly C: "a8A";
             readonly NA: "UKg";
             readonly NAC: "F3L";
+            readonly NAM: "Vtr";
+            readonly NAMC: "OsE";
+            readonly NAT: "U2k";
+            readonly NATC: "xh1";
+            readonly NATM: "ZxF";
+            readonly NATMC: "eIg";
             readonly NL: "LD5";
             readonly NLA: "Yk4";
             readonly NLAC: "NJl";
+            readonly NLAM: "Rh7";
+            readonly NLAMC: "y2C";
+            readonly NLAT: "QQ0";
+            readonly NLATC: "hRZ";
+            readonly NLATM: "hdf";
+            readonly NLATMC: "eGg";
             readonly NLC: "IuS";
+            readonly NLM: "AiS";
+            readonly NLMC: "Vzn";
+            readonly NLT: "zRL";
+            readonly NLTC: "EoO";
+            readonly NLTM: "cYM";
+            readonly NLTMC: "dv9";
+            readonly NM: "wI4";
+            readonly NMC: "NTN";
+            readonly NT: "vhX";
+            readonly NTC: "wIe";
+            readonly NTM: "ga6";
+            readonly NTMC: "tVb";
         };
     };
 };
-export declare const VALIDATE_OPTION_LETTERS: readonly [readonly ["noLiterals", "L"], readonly ["noIsArrayCheck", "A"]];
+export declare const VALIDATE_OPTION_LETTERS: readonly [readonly ["noLiterals", "L"], readonly ["noIsArrayCheck", "A"], readonly ["numberTypeof", "T"], readonly ["numberNotNaN", "M"]];
 export declare const HAS_UNKNOWN_KEYS_OPTION_LETTERS: readonly [readonly ["runsAfterValidation", "V"]];

package/dist/cjs/go-generated/fnHashes.generated.js

@@ -34,16 +34,84 @@ exports.FN_HASHES = {
     val: {
         axis: 'validateOptions',
         circularGuarded: true,
-        variants: { '': 'nPZ', C: 'cCe', NA: 'WeU', NAC: 'fJb', NL: 'N7J', NLA: 'GYK', NLAC: 'z9t', NLC: 'iai' },
+        variants: {
+            '': 'nPZ',
+            C: 'cCe',
+            NA: 'WeU',
+            NAC: 'fJb',
+            NAM: 'D77',
+            NAMC: 'ASI',
+            NAT: 'CG0',
+            NATC: 'jH9',
+            NATM: 'zd5',
+            NATMC: 'UQE',
+            NL: 'N7J',
+            NLA: 'GYK',
+            NLAC: 'z9t',
+            NLAM: 'rXx',
+            NLAMC: 'oaW',
+            NLAT: 'qwq',
+            NLATC: 'XZn',
+            NLATM: 'TDn',
+            NLATMC: 'w46',
+            NLC: 'iai',
+            NLM: 'iWy',
+            NLMC: 'HZv',
+            NLT: 'hvr',
+            NLTC: 'qOW',
+            NLTM: 'CEc',
+            NLTMC: 'TDx',
+            NM: 'ycI',
+            NMC: 'nzd',
+            NT: 'xLB',
+            NTC: 'WoE',
+            NTM: 'OOM',
+            NTMC: 'flj',
+        },
     },
     verr: {
         axis: 'validateOptions',
         circularGuarded: true,
-        variants: { '': 'pBb', C: 'a8A', NA: 'UKg', NAC: 'F3L', NL: 'LD5', NLA: 'Yk4', NLAC: 'NJl', NLC: 'IuS' },
+        variants: {
+            '': 'pBb',
+            C: 'a8A',
+            NA: 'UKg',
+            NAC: 'F3L',
+            NAM: 'Vtr',
+            NAMC: 'OsE',
+            NAT: 'U2k',
+            NATC: 'xh1',
+            NATM: 'ZxF',
+            NATMC: 'eIg',
+            NL: 'LD5',
+            NLA: 'Yk4',
+            NLAC: 'NJl',
+            NLAM: 'Rh7',
+            NLAMC: 'y2C',
+            NLAT: 'QQ0',
+            NLATC: 'hRZ',
+            NLATM: 'hdf',
+            NLATMC: 'eGg',
+            NLC: 'IuS',
+            NLM: 'AiS',
+            NLMC: 'Vzn',
+            NLT: 'zRL',
+            NLTC: 'EoO',
+            NLTM: 'cYM',
+            NLTMC: 'dv9',
+            NM: 'wI4',
+            NMC: 'NTN',
+            NT: 'vhX',
+            NTC: 'wIe',
+            NTM: 'ga6',
+            NTMC: 'tVb',
+        },
     },
 };
 exports.VALIDATE_OPTION_LETTERS = [
     ['noLiterals', 'L'],
     ['noIsArrayCheck', 'A'],
+    ['numberTypeof', 'T'],
+    ['numberNotNaN', 'M'],
 ];
 exports.HAS_UNKNOWN_KEYS_OPTION_LETTERS = [['runsAfterValidation', 'V']];

package/dist/cjs/go-generated/typeFormats.generated.d.ts

@@ -0,0 +1,80 @@
+import { type RunTypeKindValue } from './runTypeKind.generated.ts';
+export interface TypeFormatMeta {
+    readonly name: FormatName;
+    readonly kind: RunTypeKindValue;
+}
+export declare const typeFormats: {
+    readonly bigintFormat: {
+        readonly name: "bigintFormat";
+        readonly kind: 9;
+    };
+    readonly date: {
+        readonly name: "date";
+        readonly kind: 5;
+    };
+    readonly dateTime: {
+        readonly name: "dateTime";
+        readonly kind: 5;
+    };
+    readonly domain: {
+        readonly name: "domain";
+        readonly kind: 5;
+    };
+    readonly email: {
+        readonly name: "email";
+        readonly kind: 5;
+    };
+    readonly ip: {
+        readonly name: "ip";
+        readonly kind: 5;
+    };
+    readonly nativeDate: {
+        readonly name: "nativeDate";
+        readonly kind: 20;
+    };
+    readonly numberFormat: {
+        readonly name: "numberFormat";
+        readonly kind: 6;
+    };
+    readonly stringFormat: {
+        readonly name: "stringFormat";
+        readonly kind: 5;
+    };
+    readonly temporalInstant: {
+        readonly name: "temporalInstant";
+        readonly kind: 20;
+    };
+    readonly temporalPlainDate: {
+        readonly name: "temporalPlainDate";
+        readonly kind: 20;
+    };
+    readonly temporalPlainDateTime: {
+        readonly name: "temporalPlainDateTime";
+        readonly kind: 20;
+    };
+    readonly temporalPlainTime: {
+        readonly name: "temporalPlainTime";
+        readonly kind: 20;
+    };
+    readonly temporalPlainYearMonth: {
+        readonly name: "temporalPlainYearMonth";
+        readonly kind: 20;
+    };
+    readonly temporalZonedDateTime: {
+        readonly name: "temporalZonedDateTime";
+        readonly kind: 20;
+    };
+    readonly time: {
+        readonly name: "time";
+        readonly kind: 5;
+    };
+    readonly url: {
+        readonly name: "url";
+        readonly kind: 5;
+    };
+    readonly uuid: {
+        readonly name: "uuid";
+        readonly kind: 5;
+    };
+};
+export type FormatName = keyof typeof typeFormats;

package/dist/cjs/go-generated/typeFormats.generated.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeFormats = void 0;
+const runTypeKind_generated_ts_1 = require("./runTypeKind.generated.js");
+exports.typeFormats = {
+    bigintFormat: { name: 'bigintFormat', kind: runTypeKind_generated_ts_1.RunTypeKind.bigint },
+    date: { name: 'date', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    dateTime: { name: 'dateTime', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    domain: { name: 'domain', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    email: { name: 'email', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    ip: { name: 'ip', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    nativeDate: { name: 'nativeDate', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    numberFormat: { name: 'numberFormat', kind: runTypeKind_generated_ts_1.RunTypeKind.number },
+    stringFormat: { name: 'stringFormat', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    temporalInstant: { name: 'temporalInstant', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainDate: { name: 'temporalPlainDate', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainDateTime: { name: 'temporalPlainDateTime', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainTime: { name: 'temporalPlainTime', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainYearMonth: { name: 'temporalPlainYearMonth', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalZonedDateTime: { name: 'temporalZonedDateTime', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    time: { name: 'time', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    url: { name: 'url', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    uuid: { name: 'uuid', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+};

package/dist/cjs/index.d.ts

@@ -1,5 +1,7 @@
 export { type InjectRunTypeId, type InjectTypeFnArgs, type InjectPureFnHash, type CompTimeArgs, type CompTimeFnArgs, type PureFunction, type PureFunctionFactory, getRunTypeId, } from './markers.ts';
 export { getRTUtils, getRTFnCaches, type RTUtils } from './runtypes/rtUtils.ts';
+export { type CompiledFnData, type CompiledTypeFn, type InitializedTypeFn, type CompiledFnArgs, type CompiledPureFunction, type PureFunctionData, type AnyFn, } from './runtypes/types.ts';
+export { buildFactoryFromCode, buildPureFnFactoryFromCode, entryCode } from './runtypes/rtUtils.ts';
 export { type RunType } from './runtypes/types.ts';
 export { getRunType } from './getRunType.ts';
 export { type DataOnly } from './runtypes/dataOnly.ts';
@@ -18,11 +20,13 @@ 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 RunTypeKindName, type RunTypeKindValue, RunTypeSubKind, type RunTypeSubKindName, type RunTypeSubKindValue, } from './go-generated/runTypeKind.generated.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, type HasUnknownKeysCompileOptions, createCloneExactShape, type CloneExactShapeFn, createUnknownKeyErrors, type UnknownKeyErrorsFn, 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 { typeFormats, type FormatName, type TypeFormatMeta } from './go-generated/typeFormats.generated.ts';
+export { getRTFunction, type RTFunctionByKey, type RTFunctionKey, createValidateFn, type ValidateFn, type ValidateOptions, createGetValidationErrorsFn, type GetValidationErrorsFn, type RTValidationError, type TypeFormatError, type RTValidationErrorPathSegment, type RTPathSegment, createHasUnknownKeysFn, type HasUnknownKeysFn, type HasUnknownKeysOptions, type HasUnknownKeysCompileOptions, createCloneExactShapeFn, type CloneExactShapeFn, createUnknownKeyErrorsFn, type UnknownKeyErrorsFn, createFormatTransformFn, type FormatTransformFn, createJsonEncoderFn, type JsonEncoderFn, type JsonEncoderOptions, createJsonDecoderFn, type JsonDecoderFn, type JsonDecoderOptions, type PrepareForJsonFn, type RestoreFromJsonFn, type StringifyJsonFn, } from './createRTFunctions.ts';
+export { createBinaryEncoderFn, type BinaryEncoderFn, type BinaryEncoderSizeFn, type BinaryEncoderIntoFn, type BinaryEncoderOptions, createBinarySizerFn, type BinarySizerFn, createBinaryDecoderFn, type BinaryDecoderFn, type BinaryDecoderOptions, type ToBinaryFn, type FromBinaryFn, } from './createRTFBinary.ts';
 export { overrideValidate, overrideGetValidationErrors, overrideHasUnknownKeys, overrideCloneExactShape, overrideUnknownKeyErrors, overrideFormatTransform, overrideBinaryEncoder, overrideBinaryDecoder, overrideJsonEncoder, overrideJsonDecoder, } from './overrideRTFunctions.ts';
-export { createMockData } from './mocking/createMockData.ts';
+export { createMockDataFn } from './mocking/createMockData.ts';
 export type { MockOptions, MockTypeFn, RunTypeMockOptions } from './mocking/mockTypes.ts';
+export { MockRandom } from './mocking/mockRandom.ts';
 export { createStandardSchema, type RTStandardSchemaV1, type RTValidationResult, type RTValidationFailureResult, } from './standard/createStandardSchema.ts';
 export { runTypeErrorsToIssues, type IssueMappingOptions, type RTValidationIssue } from './standard/issueMapping.ts';
 export { type StandardSchemaV1, type StandardSchemaProps, type StandardSchemaResult, type StandardSchemaSuccessResult, type StandardSchemaFailureResult, type StandardSchemaIssue, type StandardSchemaPathSegment, type StandardSchemaTypes, type StandardSchemaInferInput, type StandardSchemaInferOutput, } from './standard/spec.ts';