@ts-runtypes/core 0.9.3 → 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, options?.rejectCircularRefs);
+    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 {
@@ -28,10 +29,12 @@ export type GetValidationErrorsFn = (value: unknown, path?: RTValidationErrorPat
 export interface HasUnknownKeysOptions {
     checkNonRTProps?: boolean;
 }
+export interface HasUnknownKeysCompileOptions {
+    runsAfterValidation?: boolean;
+}
 export type HasUnknownKeysFn = (value: unknown, options?: HasUnknownKeysOptions) => boolean;
-export type StripUnknownKeysFn = (value: unknown) => unknown;
+export type CloneExactShapeFn<T = unknown> = (value: T) => T;
 export type UnknownKeyErrorsFn = (value: unknown, path?: RTValidationErrorPathSegment[], errors?: RTValidationError[]) => RTValidationError[];
-export type UnknownKeysToUndefinedFn = (value: unknown) => unknown;
 export type FormatTransformValue<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer E)[] ? FormatTransformValue<E>[] : T extends object ? {
     [K in keyof T]: FormatTransformValue<T[K]>;
 } : T;
@@ -50,24 +53,22 @@ 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>, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "huk">) => HasUnknownKeysFn);
-export declare const createStripUnknownKeys: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "suk">) => StripUnknownKeysFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "suk">) => StripUnknownKeysFn);
-export declare const createUnknownKeyErrors: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "uke">) => UnknownKeyErrorsFn);
-export declare const createUnknownKeysToUndefined: (<T>(schema: RunType<T>, id?: InjectTypeFnArgs<T, "uku">) => UnknownKeysToUndefinedFn) & (<T>(val?: T, id?: InjectTypeFnArgs<T, "uku">) => UnknownKeysToUndefinedFn);
-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;
     huk: HasUnknownKeysFn;
-    suk: StripUnknownKeysFn;
+    ces: CloneExactShapeFn;
     uke: UnknownKeyErrorsFn;
-    uku: UnknownKeysToUndefinedFn;
     fmt: FormatTransformFn<unknown>;
     jsonEncoder: JsonEncoderFn;
     jsonDecoder: JsonDecoderFn;

package/dist/cjs/createRTFunctions.js

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFormatTransform = exports.createUnknownKeysToUndefined = exports.createUnknownKeyErrors = exports.createStripUnknownKeys = 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");
-function resolveTupleEntry(fnName, identityFn, val, args, rejectCircularRefs) {
+function resolveTupleEntry(fnName, identityFn, val, args) {
     const schemaId = (0, rtUtils_ts_1.isRunTypeSchema)(val) ? val.id : undefined;
-    return (0, entryTuple_ts_1.resolveEntryTupleFn)(fnName, identityFn, schemaId, args, rejectCircularRefs);
-}
-function readRejectCircularRefs(options) {
-    return options?.rejectCircularRefs;
+    return (0, entryTuple_ts_1.resolveEntryTupleFn)(fnName, identityFn, schemaId, args);
 }
 function createTypeFnArgsFunction(fnName, identityFn) {
-    return (val, options, args) => resolveTupleEntry(fnName, identityFn, val, args, readRejectCircularRefs(options));
+    return (val, _options, args) => resolveTupleEntry(fnName, identityFn, val, args);
 }
 function createRTFunction(fnName, identityFn) {
     return (val, args) => resolveTupleEntry(fnName, identityFn, val, args);
@@ -22,20 +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 = createRTFunction('createHasUnknownKeys', () => false);
-exports.createStripUnknownKeys = createRTFunction('createStripUnknownKeys', identityValueFn);
-exports.createUnknownKeyErrors = createRTFunction('createUnknownKeyErrors', unknownKeyErrorsIdentity);
-exports.createUnknownKeysToUndefined = createRTFunction('createUnknownKeysToUndefined', identityValueFn);
-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, options?.rejectCircularRefs);
+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

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

package/dist/cjs/fnHash.js

@@ -1,13 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFnHash = getFnHash;
-const fnHashes_generated_ts_1 = require("./fnHashes.generated.js");
+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) {
+        const present = name === numberModeName || options[name];
+        if (present) {
+            suffix += letter;
+            hit = true;
+        }
+    }
+    return hit ? suffix : '';
+}
+function hasUnknownKeysVariantToken(options) {
+    if (!options)
+        return '';
+    let suffix = 'O';
+    let hit = false;
+    for (const [name, letter] of fnHashes_generated_ts_1.HAS_UNKNOWN_KEYS_OPTION_LETTERS) {
         if (options[name]) {
             suffix += letter;
             hit = true;
@@ -24,6 +46,10 @@ function getFnHash(fnKey, options) {
         token = validateVariantToken(options);
     else if (entry.axis === 'jsonStrategy')
         token = options?.strategy ?? entry.defaultVariant ?? '';
+    else if (entry.axis === 'hasUnknownKeysOptions')
+        token = hasUnknownKeysVariantToken(options);
+    if (entry.circularGuarded && options?.rejectCircularRefs)
+        token += 'C';
     const hash = entry.variants[token];
     if (hash === undefined)
         throw new Error(`getFnHash: fnKey ${JSON.stringify(fnKey)} has no ${JSON.stringify(token)} variant`);