@mionjs/run-types 0.8.10 → 0.13.0

package/dist/cjs/runtypes/classSerializerRegistry.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classSerializerEpoch = classSerializerEpoch;
+exports.registerClassSerializer = registerClassSerializer;
+exports.getClassSerializer = getClassSerializer;
+exports.isClassSerializerRegistered = isClassSerializerRegistered;
+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 classSerializersByName = new Map();
+const classStates = new Map();
+const warnedAmbiguousNames = new Set();
+let epoch = 0;
+function classSerializerEpoch() {
+    return epoch;
+}
+function classSerializerIdentity(id, cls) {
+    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
+        (0, entryTuple_ts_1.initFromTuple)(id);
+        const key = (0, entryTuple_ts_1.entryTupleKey)(id);
+        const separator = key.indexOf('_');
+        if (separator === entryTuple_ts_1.FN_HASH_LEN)
+            return { typeId: key.slice(entryTuple_ts_1.FN_HASH_LEN + 1), entryKey: key };
+        return { typeId: key };
+    }
+    if (typeof id === 'string' && id.length > 0)
+        return { typeId: id };
+    throw new Error(`[mion] registerClassSerializer(${cls.name || '<anonymous>'}): no type id injected. ` +
+        `The @mionjs/devtools plugin must process the registration file so the class's ` +
+        `type id can be injected (the registry is keyed by type id + class name).`);
+}
+function classSerializerName(identity, cls) {
+    if (identity.entryKey !== undefined) {
+        const typeName = (0, rtUtils_ts_1.getRTFnCaches)().rtFnsCache[identity.entryKey]?.typeName;
+        if (typeof typeName === 'string' && typeName.length > 0)
+            return typeName;
+    }
+    const node = (0, rtUtils_ts_1.getRTUtils)().getRunType(identity.typeId);
+    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(`[mion] 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 identity = classSerializerIdentity(id, cls);
+    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(identity.typeId);
+    classSerializers.set(identity.typeId, state.entry);
+    const name = classSerializerName(identity, cls);
+    if (name && state.name === undefined) {
+        state.name = name;
+        indexByName(name, state.entry);
+    }
+    epoch++;
+}
+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 classStates.has(cls);
+}
+function deserializeClass(entry, data, keys) {
+    if (entry.deserialize)
+        return entry.deserialize(data);
+    let instance;
+    try {
+        instance = new entry.cls();
+    }
+    catch (err) {
+        const original = err instanceof Error ? err.message : String(err);
+        const name = entry.cls.name || '<anonymous>';
+        throw new Error(`[data-class-constructor-failed] Cannot reconstruct class "${name}": the automatic \`new ${name}()\` failed, ` +
+            `so its constructor needs arguments. Register a \`deserialize\` handler: ` +
+            `registerClassSerializer(${name}, {deserialize: (data) => new ${name}(/* … */)}). ` +
+            `Original error: ${original}`);
+    }
+    const source = data;
+    const target = instance;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = source[key];
+        if (value !== undefined)
+            target[key] = value;
+    }
+    return instance;
+}
+function unregisterClassSerializer(cls) {
+    const state = classStates.get(cls);
+    if (!state)
+        return;
+    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();
+    classSerializersByName.clear();
+    classStates.clear();
+    warnedAmbiguousNames.clear();
+    epoch++;
+}

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

@@ -0,0 +1,29 @@
+import type { __rtFormatName, __rtContains, __rtPatternProps, __rtPropNames } from './sentinelKeys.ts';
+type DataOnlyUrl = typeof globalThis extends {
+    URL: {
+        prototype: infer I;
+    };
+} ? I : never;
+export interface DataOnlyNativeExtra {
+    url: DataOnlyUrl;
+}
+type DataOnlyNative = Date | DataOnlyNativeExtra[keyof DataOnlyNativeExtra];
+type DataOnlyStripped = symbol | RegExp | ((...args: never[]) => unknown) | (abstract new (...args: never[]) => unknown) | {
+    then: (...args: never[]) => unknown;
+} | ArrayBuffer | SharedArrayBuffer | ArrayBufferView;
+type _DataOnlyDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+export type DataOnly<T, Depth extends number = 8> = Depth extends 0 ? T : unknown extends T ? T : T extends DataOnlyStripped ? never : T extends string | number | boolean | bigint | null | undefined | DataOnlyNative ? T : DataOnlySentinelKept<T> extends true ? T : DataOnlyLadder<T, Depth>;
+type DataOnlySentinelKeys = typeof __rtFormatName | typeof __rtContains | typeof __rtPatternProps | typeof __rtPropNames;
+type DataOnlySentinelKept<T> = Extract<keyof T, DataOnlySentinelKeys> extends never ? (string extends keyof T ? DataOnlyRecordSentinelKept<T> : false) : true;
+type DataOnlySentinelProbe<X, Shape> = [X] extends [never] ? false : X extends Shape ? true : false;
+type DataOnlyProperStringLiteral<X> = [X] extends [never] ? false : string extends X ? false : X extends string ? true : false;
+type DataOnlyRecordSentinelKept<T> = true extends DataOnlyProperStringLiteral<NonNullable<T[typeof __rtFormatName & keyof T]>> | DataOnlySentinelProbe<NonNullable<T[typeof __rtPatternProps & keyof T]>, Record<string, {
+    rt$value: unknown;
+}>> | DataOnlySentinelProbe<NonNullable<T[typeof __rtPropNames & keyof T]>, string> ? true : false;
+type DataOnlyLadder<T, Depth extends number> = T extends ReadonlyMap<any, any> ? T extends ReadonlyMap<infer K, infer V> ? T extends Map<any, any> ? Map<DataOnly<K, _DataOnlyDepth[Depth]>, DataOnly<V, _DataOnlyDepth[Depth]>> : ReadonlyMap<DataOnly<K, _DataOnlyDepth[Depth]>, DataOnly<V, _DataOnlyDepth[Depth]>> : never : T extends ReadonlySet<any> ? T extends ReadonlySet<infer U> ? T extends Set<any> ? Set<DataOnly<U, _DataOnlyDepth[Depth]>> : ReadonlySet<DataOnly<U, _DataOnlyDepth[Depth]>> : never : T extends readonly unknown[] ? {
+    -readonly [K in keyof T]: DataOnly<T[K], _DataOnlyDepth[Depth]>;
+} : T extends object ? [keyof T] extends [never] ? T : {
+    [K in keyof T as K extends symbol | '__proto__' ? never : [DataOnly<T[K], _DataOnlyDepth[Depth]>] extends [undefined] ? [DataOnly<T[K], _DataOnlyDepth[Depth]>] extends [never] ? never : DataOnlyOptionalStripped<T, K> extends true ? never : K : K]: DataOnly<T[K], _DataOnlyDepth[Depth]>;
+} : T;
+type DataOnlyOptionalStripped<T, K extends keyof T> = [T[K]] extends [undefined] ? false : {} extends Record<K, never> ? false : {} extends Pick<T, K> ? true : false;
+export {};

package/dist/cjs/runtypes/dataOnly.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,101 @@
+import type { RTUtils } from './rtUtils.ts';
+import type { AnyFn, CompiledFnArgs, CompiledFnData, CompiledPureFunction, CompiledTypeFn, RunType } from './types.ts';
+declare const KIND_RUN_TYPE = 0;
+declare const KIND_PURE_FN = 2;
+declare const KIND_MISSING = 3;
+declare const KIND_RUN_TYPE_BUNDLE = 4;
+declare const KIND_RUN_TYPE_FACADE = 5;
+export declare const FN_HASH_LEN = 4;
+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", "nonEnumerable", "jsonMaxBytes"];
+export type RunTypeRowRecord = Pick<RunType, (typeof RUN_TYPE_FIELD_KEYS)[number]>;
+type RunTypeRel = number | string | object;
+export type RunTypeRelRow = readonly (RunTypeRel | readonly RunTypeRel[] | undefined)[];
+export interface RunTypeRecord extends RunTypeRowRecord {
+    entryKind: typeof KIND_RUN_TYPE;
+    deps: EntryDepsThunk | undefined;
+    ini: RunTypeIni | undefined;
+}
+export interface RunTypeBundleRecord {
+    entryKind: typeof KIND_RUN_TYPE_BUNDLE;
+    deps: EntryDepsThunk | undefined;
+    ini: RunTypeIni | undefined;
+    key: string;
+    rows: readonly RunTypeRow[];
+    rels: readonly (RunTypeRelRow | undefined)[];
+}
+export interface RunTypeFacadeRecord {
+    entryKind: typeof KIND_RUN_TYPE_FACADE;
+    deps: EntryDepsThunk | undefined;
+    ini: undefined;
+    key: string;
+}
+export interface FnTypeRecord extends Pick<CompiledTypeFn, 'rtFnHash' | 'typeName' | 'isNoop' | 'rtDependencies' | 'pureFnDependencies' | 'createRTFn' | 'alwaysThrowMessage'> {
+    familyTag: string;
+    deps: EntryDepsThunk | undefined;
+    ini: undefined;
+    code: CompiledFnData['code'] | undefined;
+}
+export interface PureFnRecord extends Pick<CompiledPureFunction, 'paramNames' | 'code' | 'pureFnDependencies' | 'createPureFn'> {
+    entryKind: typeof KIND_PURE_FN;
+    deps: EntryDepsThunk | undefined;
+    ini: undefined;
+    key: string;
+}
+export interface MissingRecord {
+    entryKind: typeof KIND_MISSING;
+    deps: undefined;
+    ini: undefined;
+    key: string;
+}
+type TupleFrom<R, K extends readonly (keyof R)[]> = {
+    [I in keyof K]: R[K[I]];
+};
+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", "nonEnumerable", "jsonMaxBytes"];
+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"];
+declare const FN_TYPE_TRIMMED_KEYS: readonly ["code", "isNoop", "rtDependencies", "pureFnDependencies", "createRTFn", "alwaysThrowMessage"];
+export declare const FN_TYPE_TUPLE_KEYS: readonly ["familyTag", "deps", "ini", "rtFnHash", "typeName", "code", "isNoop", "rtDependencies", "pureFnDependencies", "createRTFn", "alwaysThrowMessage"];
+declare const PURE_FN_REQUIRED_KEYS: readonly ["entryKind", "deps", "ini", "key", "paramNames", "code", "pureFnDependencies"];
+declare const PURE_FN_TRIMMED_KEYS: readonly ["createPureFn"];
+export declare const PURE_FN_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key", "paramNames", "code", "pureFnDependencies", "createPureFn"];
+declare const MISSING_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key"];
+export type RunTypeRow = readonly [
+    ...TupleFrom<RunTypeRowRecord, RunTypeRowRequiredKeys>,
+    ...Partial<TupleFrom<RunTypeRowRecord, RunTypeRowTrimmedKeys>>
+];
+export type RunTypeTuple = readonly [
+    ...TupleFrom<RunTypeRecord, readonly [...typeof ENTRY_HEAD_KEYS, ...RunTypeRowRequiredKeys]>,
+    ...Partial<TupleFrom<RunTypeRecord, RunTypeRowTrimmedKeys>>
+];
+export type RunTypeBundleTuple = readonly [...TupleFrom<RunTypeBundleRecord, typeof RUN_TYPE_BUNDLE_TUPLE_KEYS>];
+export type RunTypeFacadeTuple = readonly [...TupleFrom<RunTypeFacadeRecord, typeof RUN_TYPE_FACADE_TUPLE_KEYS>];
+export type FnTypeTuple = readonly [
+    ...TupleFrom<FnTypeRecord, typeof FN_TYPE_REQUIRED_KEYS>,
+    ...Partial<TupleFrom<FnTypeRecord, typeof FN_TYPE_TRIMMED_KEYS>>
+];
+export type PureFnTuple = readonly [
+    ...TupleFrom<PureFnRecord, typeof PURE_FN_REQUIRED_KEYS>,
+    ...Partial<TupleFrom<PureFnRecord, typeof PURE_FN_TRIMMED_KEYS>>
+];
+export type MissingTuple = readonly [...TupleFrom<MissingRecord, typeof MISSING_TUPLE_KEYS>];
+export type EntryTuple = RunTypeTuple | RunTypeBundleTuple | RunTypeFacadeTuple | FnTypeTuple | PureFnTuple | MissingTuple;
+export declare function isEntryTuple(value: unknown): value is EntryTuple;
+export declare function entryTupleKey(tuple: EntryTuple): string;
+export declare function isMissingTuple(value: unknown): boolean;
+interface FamilyMeta {
+    fnID: string;
+    args: () => CompiledFnArgs;
+    defaultParamValues: () => CompiledFnArgs;
+    noop: AnyFn;
+}
+export declare const familyMeta: Record<string, FamilyMeta>;
+export declare function initFromTuple(root: EntryTuple): void;
+export declare function entryTupleAt(injected: unknown, index: number): EntryTuple | undefined;
+export declare function resolveEntryTupleFn<F extends AnyFn>(fnName: string, identityFn: F, runTypeId: string | undefined, injected: unknown): F;
+export {};

package/dist/cjs/runtypes/entryTuple.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.familyMeta = exports.PURE_FN_TUPLE_KEYS = exports.FN_TYPE_TUPLE_KEYS = exports.RUN_TYPE_FACADE_TUPLE_KEYS = exports.RUN_TYPE_BUNDLE_TUPLE_KEYS = exports.RUN_TYPE_TUPLE_KEYS = exports.FN_HASH_LEN = void 0;
+exports.isEntryTuple = isEntryTuple;
+exports.entryTupleKey = entryTupleKey;
+exports.isMissingTuple = isMissingTuple;
+exports.initFromTuple = initFromTuple;
+exports.entryTupleAt = entryTupleAt;
+exports.resolveEntryTupleFn = resolveEntryTupleFn;
+const rtUtils_ts_1 = require("./rtUtils.js");
+const KIND_RUN_TYPE = 0;
+const KIND_PURE_FN = 2;
+const KIND_MISSING = 3;
+const KIND_RUN_TYPE_BUNDLE = 4;
+const KIND_RUN_TYPE_FACADE = 5;
+exports.FN_HASH_LEN = 4;
+const RUN_TYPE_FIELD_KEYS = [
+    'id',
+    'kind',
+    'subKind',
+    'typeName',
+    'name',
+    'literal',
+    'optional',
+    'readonly',
+    'isAbstract',
+    'isStatic',
+    'visibility',
+    'isSafeName',
+    'position',
+    'isCircular',
+    'flags',
+    'description',
+    'defaultVal',
+    'enumVal',
+    'values',
+    'notSupported',
+    'nonEnumerable',
+    'jsonMaxBytes',
+];
+const RUN_TYPE_REL_KEYS = [
+    'child',
+    'children',
+    'index',
+    'return',
+    'indexType',
+    'parameters',
+    'safeUnionChildren',
+    'unionDiscriminators',
+    'typeMeta',
+    'typeArguments',
+    'arguments',
+    'extendsArguments',
+    'implements',
+    'extends',
+];
+const RUN_TYPE_REL_IS_ARRAY = [
+    false,
+    true,
+    false,
+    false,
+    false,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+];
+const ENTRY_HEAD_KEYS = ['entryKind', 'deps', 'ini'];
+exports.RUN_TYPE_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, ...RUN_TYPE_FIELD_KEYS];
+exports.RUN_TYPE_BUNDLE_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, 'key', 'rows', 'rels'];
+exports.RUN_TYPE_FACADE_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, 'key'];
+const FN_TYPE_REQUIRED_KEYS = ['familyTag', 'deps', 'ini', 'rtFnHash', 'typeName'];
+const FN_TYPE_TRIMMED_KEYS = [
+    'code',
+    'isNoop',
+    'rtDependencies',
+    'pureFnDependencies',
+    'createRTFn',
+    'alwaysThrowMessage',
+];
+exports.FN_TYPE_TUPLE_KEYS = [...FN_TYPE_REQUIRED_KEYS, ...FN_TYPE_TRIMMED_KEYS];
+const PURE_FN_REQUIRED_KEYS = [...ENTRY_HEAD_KEYS, 'key', 'paramNames', 'code', 'pureFnDependencies'];
+const PURE_FN_TRIMMED_KEYS = ['createPureFn'];
+exports.PURE_FN_TUPLE_KEYS = [...PURE_FN_REQUIRED_KEYS, ...PURE_FN_TRIMMED_KEYS];
+const MISSING_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, 'key'];
+const SLOT_KIND = 0;
+const SLOT_DEPS = 1;
+const SLOT_KEY = 3;
+const SLOT_ROWS = 4;
+const SLOT_RELS = 5;
+const _pinBundleRels = exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_RELS];
+void _pinBundleRels;
+const _pinBundleHead = [
+    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_KIND],
+    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_DEPS],
+    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[2],
+    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_KEY],
+    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_ROWS],
+];
+const _pinFacadeHead = [
+    exports.RUN_TYPE_FACADE_TUPLE_KEYS[SLOT_KIND],
+    exports.RUN_TYPE_FACADE_TUPLE_KEYS[SLOT_DEPS],
+    exports.RUN_TYPE_FACADE_TUPLE_KEYS[2],
+    exports.RUN_TYPE_FACADE_TUPLE_KEYS[SLOT_KEY],
+];
+const _pinFnTypeHead = [
+    exports.FN_TYPE_TUPLE_KEYS[SLOT_KIND],
+    exports.FN_TYPE_TUPLE_KEYS[SLOT_DEPS],
+    exports.FN_TYPE_TUPLE_KEYS[2],
+    exports.FN_TYPE_TUPLE_KEYS[SLOT_KEY],
+];
+const _pinPureFnHead = [
+    exports.PURE_FN_TUPLE_KEYS[SLOT_KIND],
+    exports.PURE_FN_TUPLE_KEYS[SLOT_DEPS],
+    exports.PURE_FN_TUPLE_KEYS[2],
+    exports.PURE_FN_TUPLE_KEYS[SLOT_KEY],
+];
+const _pinMissingHead = [
+    MISSING_TUPLE_KEYS[SLOT_KIND],
+    MISSING_TUPLE_KEYS[SLOT_DEPS],
+    MISSING_TUPLE_KEYS[2],
+    MISSING_TUPLE_KEYS[SLOT_KEY],
+];
+void _pinBundleHead;
+void _pinFacadeHead;
+void _pinFnTypeHead;
+void _pinPureFnHead;
+void _pinMissingHead;
+function tupleToRecord(keys, tuple) {
+    const record = {};
+    for (let index = 0; index < keys.length; index++) {
+        record[keys[index]] = tuple[index];
+    }
+    return record;
+}
+function isEntryTuple(value) {
+    if (isMissingTuple(value))
+        return true;
+    if (!Array.isArray(value) || value.length <= SLOT_KEY)
+        return false;
+    const deps = value[SLOT_DEPS];
+    return (typeof deps === 'function' || deps === undefined) && typeof value[SLOT_KEY] === 'string';
+}
+function entryTupleKey(tuple) {
+    return tuple[SLOT_KEY];
+}
+function isMissingTuple(value) {
+    return Array.isArray(value) && value[SLOT_KIND] === KIND_MISSING;
+}
+const noopTrue = () => true;
+const noopIdentity = (v) => v;
+const noopErrors = (_v, _pth, er) => er || [];
+const noopStringify = (v) => JSON.stringify(v);
+const noopParse = (s) => JSON.parse(s);
+const valueArgs = () => ({ vλl: 'v' });
+const valueDefaults = () => ({ vλl: '' });
+const errorArgs = () => ({ vλl: 'v', pλth: 'pth', εrr: 'er' });
+const errorDefaults = () => ({ vλl: '', pλth: '[]', εrr: '[]' });
+const valueShaped = (fnID, noop) => ({ fnID, args: valueArgs, defaultParamValues: valueDefaults, noop });
+const errorShaped = (fnID) => ({ fnID, args: errorArgs, defaultParamValues: errorDefaults, noop: noopErrors });
+exports.familyMeta = {
+    val: valueShaped('val', noopTrue),
+    verr: errorShaped('verr'),
+    vst: valueShaped('vst', noopTrue),
+    vest: errorShaped('vest'),
+    vuk: valueShaped('vuk', noopTrue),
+    veuk: errorShaped('veuk'),
+    pj: valueShaped('pj', noopIdentity),
+    rj: valueShaped('rj', noopIdentity),
+    pjs: valueShaped('pjs', noopIdentity),
+    cj: valueShaped('cj', noopIdentity),
+    cjr: valueShaped('cjr', noopIdentity),
+    rjs: valueShaped('rjs', noopIdentity),
+    ruk: valueShaped('ruk', noopIdentity),
+    ruks: valueShaped('ruks', noopIdentity),
+    rukr: valueShaped('rukr', noopIdentity),
+    csr: valueShaped('csr', noopIdentity),
+    fmt: valueShaped('fmt', noopIdentity),
+    jsc: valueShaped('jsc', () => ({})),
+    jeCL: valueShaped('pj', noopStringify),
+    jeMU: valueShaped('pj', noopStringify),
+    jeCO: valueShaped('pj', noopStringify),
+    jdCL: valueShaped('rj', noopParse),
+    jdMU: valueShaped('rj', noopParse),
+    jdCO: valueShaped('rj', noopParse),
+};
+const processedKeys = new Set();
+function initFromTuple(root) {
+    if (isMissingTuple(root))
+        return;
+    if (!isEntryTuple(root))
+        return;
+    const utils = (0, rtUtils_ts_1.getRTUtils)();
+    const fresh = [];
+    collectClosure(root, utils, fresh, new Set());
+    for (const tuple of fresh) {
+        if (tuple[SLOT_KIND] === KIND_RUN_TYPE_BUNDLE)
+            wireBundleRelations(utils, tuple);
+        const ini = tuple[2];
+        if (typeof ini === 'function')
+            ini(utils);
+    }
+}
+function wireBundleRelations(utils, tuple) {
+    const rows = (tuple[SLOT_ROWS] ?? []);
+    const rels = (tuple[SLOT_RELS] ?? []);
+    const added = addedRows.get(tuple);
+    if (rels.length === 0 || !added)
+        return;
+    const byIndex = rows.map((row) => utils.getRunType(row[0]));
+    const resolve = (rel) => typeof rel === 'number' ? byIndex[rel] : typeof rel === 'string' ? utils.getRunType(rel) : rel;
+    for (const i of added) {
+        const relRow = rels[i];
+        if (!relRow)
+            continue;
+        const runType = byIndex[i];
+        if (!runType)
+            continue;
+        const target = runType;
+        for (let slot = 0; slot < RUN_TYPE_REL_KEYS.length; slot++) {
+            const value = relRow[slot];
+            if (value === undefined)
+                continue;
+            target[RUN_TYPE_REL_KEYS[slot]] = RUN_TYPE_REL_IS_ARRAY[slot] ? value.map(resolve) : resolve(value);
+        }
+    }
+}
+function collectClosure(tuple, utils, fresh, visiting) {
+    if (!isEntryTuple(tuple) || isMissingTuple(tuple))
+        return;
+    const key = entryTupleKey(tuple);
+    if (visiting.has(key))
+        return;
+    visiting.add(key);
+    if (processedKeys.has(key) && isStillRegistered(utils, tuple))
+        return;
+    processedKeys.add(key);
+    const deps = tuple[SLOT_DEPS];
+    if (deps)
+        for (const dep of deps())
+            collectClosure(dep, utils, fresh, visiting);
+    if (registerTuple(utils, tuple))
+        fresh.push(tuple);
+}
+function isStillRegistered(utils, tuple) {
+    const slot0 = tuple[SLOT_KIND];
+    const key = entryTupleKey(tuple);
+    if (typeof slot0 === 'string')
+        return utils.hasRTFn(key);
+    if (slot0 === KIND_RUN_TYPE)
+        return utils.hasRunType(key);
+    if (slot0 === KIND_PURE_FN)
+        return utils.hasPureFnByKey(key);
+    if (slot0 === KIND_RUN_TYPE_BUNDLE) {
+        const rows = (tuple[SLOT_ROWS] ?? []);
+        return rows.length === 0 || utils.hasRunType(rows[0][0]);
+    }
+    return true;
+}
+function registerTuple(utils, tuple) {
+    const slot0 = tuple[SLOT_KIND];
+    if (typeof slot0 === 'string')
+        return registerTypeFnTuple(utils, tuple);
+    if (slot0 === KIND_RUN_TYPE_BUNDLE)
+        return registerRunTypeBundle(utils, tuple);
+    if (slot0 === KIND_RUN_TYPE)
+        return registerRunTypeTuple(utils, tuple);
+    if (slot0 === KIND_PURE_FN)
+        return registerPureFnTuple(utils, tuple);
+    if (slot0 === KIND_RUN_TYPE_FACADE)
+        return false;
+    return false;
+}
+function runTypeEntryFromRecord(record) {
+    return {
+        ...record,
+        child: undefined,
+        index: undefined,
+        return: undefined,
+        indexType: undefined,
+        parameters: undefined,
+        children: undefined,
+        safeUnionChildren: undefined,
+        unionDiscriminators: undefined,
+        typeMeta: undefined,
+        typeArguments: undefined,
+        arguments: undefined,
+        extendsArguments: undefined,
+        implements: undefined,
+        extends: undefined,
+        classType: undefined,
+    };
+}
+function registerRunTypeTuple(utils, tuple) {
+    const record = tupleToRecord(exports.RUN_TYPE_TUPLE_KEYS, tuple);
+    if (utils.hasRunType(record.id))
+        return false;
+    utils.addRunType(record.id, runTypeEntryFromRecord(record));
+    return true;
+}
+const addedRows = new WeakMap();
+function registerRunTypeBundle(utils, tuple) {
+    const rows = (tuple[SLOT_ROWS] ?? []);
+    const added = [];
+    rows.forEach((row, index) => {
+        const record = tupleToRecord(RUN_TYPE_FIELD_KEYS, row);
+        const existing = utils.getRunType(record.id);
+        if (!existing) {
+            utils.addRunType(record.id, runTypeEntryFromRecord(record));
+            added.push(index);
+        }
+        else if (existing.jsonMaxBytes === undefined && record.jsonMaxBytes !== undefined) {
+            existing.jsonMaxBytes = record.jsonMaxBytes;
+        }
+    });
+    if (added.length)
+        addedRows.set(tuple, added);
+    return added.length > 0;
+}
+function registerTypeFnTuple(utils, tuple) {
+    const record = tupleToRecord(exports.FN_TYPE_TUPLE_KEYS, tuple);
+    if (utils.hasRTFn(record.rtFnHash))
+        return false;
+    const meta = exports.familyMeta[record.familyTag];
+    if (!meta)
+        return false;
+    const isNoop = record.isNoop === true;
+    const entry = {
+        rtFnHash: record.rtFnHash,
+        fnID: meta.fnID,
+        familyTag: record.familyTag,
+        typeName: record.typeName,
+        args: meta.args(),
+        defaultParamValues: meta.defaultParamValues(),
+        code: record.code,
+        isNoop,
+        rtDependencies: record.rtDependencies,
+        pureFnDependencies: record.pureFnDependencies,
+        createRTFn: record.alwaysThrowMessage !== undefined
+            ? utils.alwaysThrowFactory(record.alwaysThrowMessage)
+            : record.createRTFn,
+        fn: isNoop ? meta.noop : undefined,
+        alwaysThrowMessage: record.alwaysThrowMessage,
+    };
+    utils.addToRTCache(entry);
+    return true;
+}
+function registerPureFnTuple(utils, tuple) {
+    const record = tupleToRecord(exports.PURE_FN_TUPLE_KEYS, tuple);
+    if (utils.hasPureFnByKey(record.key))
+        return false;
+    const entry = {
+        id: record.key,
+        paramNames: record.paramNames,
+        code: record.code,
+        pureFnDependencies: record.pureFnDependencies,
+        createPureFn: record.createPureFn,
+        fn: undefined,
+    };
+    utils.addPureFn(record.key, entry);
+    return true;
+}
+function entryTupleAt(injected, index) {
+    const tuples = injected;
+    return tuples ? tuples[index] : undefined;
+}
+function resolveEntryTupleFn(fnName, identityFn, runTypeId, injected) {
+    const utils = (0, rtUtils_ts_1.getRTUtils)();
+    if (isMissingTuple(injected))
+        return identityFn;
+    if (!isEntryTuple(injected)) {
+        if (runTypeId === undefined) {
+            throw new Error(`${fnName}(): no id injected. @mionjs/devtools must be active for ${fnName} to dispatch to a precompiled factory.`);
+        }
+        if (utils.knowsType(runTypeId))
+            return identityFn;
+        throw new Error(`${fnName}(): no RTCompiledFn entry for run-type id "${runTypeId}" in rtUtils.`);
+    }
+    initFromTuple(injected);
+    let key = entryTupleKey(injected);
+    if (runTypeId !== undefined)
+        key = key.slice(0, exports.FN_HASH_LEN) + '_' + runTypeId;
+    const typeId = key.slice(exports.FN_HASH_LEN + 1);
+    const entry = utils.getRT(key);
+    if (entry)
+        return entry.fn;
+    if (utils.knowsType(typeId))
+        return identityFn;
+    throw new Error(`${fnName}(): no RTCompiledFn entry for "${key}" in rtUtils. The build pipeline didn't emit a factory for that runtype.`);
+}

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

@@ -0,0 +1,4 @@
+export interface FormatAnnotation<Params extends object = Record<string, unknown>> {
+    name: string;
+    params?: Params;
+}

package/dist/cjs/runtypes/formatAnnotation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });