@ts-runtypes/core 0.9.0

package/LICENSE

@@ -0,0 +1,104 @@
+RunTypes Small Organization License 1.0.0
+
+Copyright (c) 2026 Ma Jerez. All rights reserved except as expressly granted below.
+
+## Purpose
+
+This license lets individuals and smaller organizations use the software for
+free, subject to the rules below. Larger organizations must obtain a paid
+commercial license. This is a proprietary, source-available style license; it is
+NOT an open source license.
+
+## Acceptance
+
+To exercise any rights under this license you must agree to its rules. Those
+rules are both obligations under your agreement with the licensor and conditions
+of your license. Do not do anything with the software that this license does not
+expressly permit.
+
+## Free License
+
+The licensor grants you a non-exclusive, non-transferable, royalty-free,
+worldwide license to install, run, and use the software, and to include it as a
+dependency in your own applications and deploy those applications, provided that:
+
+- you qualify as a Small Organization (see below), and
+- you comply with the Limitations below.
+
+## Small Organization
+
+You qualify for the Free License only if you are:
+
+- an individual using the software; or
+- an organization whose total gross revenue, aggregated across the organization
+  and all of its affiliates, was less than 10,000,000 US dollars (USD) during its
+  most recently completed fiscal year.
+
+"Affiliates" means all entities that control, are controlled by, or are under
+common control with an organization.
+
+If you do not qualify, you must obtain a Commercial License before using the
+software.
+
+## Limitations
+
+The Free License does NOT permit you to:
+
+- copy or reproduce the software, except as strictly necessary to install and run
+  it for your permitted use;
+- modify the software or create derivative works from it;
+- distribute, publish, sublicense, sell, rent, lease, or otherwise make the
+  software available to any third party, except as embedded in your own
+  applications for their normal operation;
+- reverse engineer, decompile, or disassemble any part of the software provided
+  in compiled or binary form, except to the extent this restriction is prohibited
+  by applicable law;
+- remove or alter any copyright, license, or other proprietary notices.
+
+All rights not expressly granted here are reserved by the licensor.
+
+## Commercial License
+
+If you do not qualify as a Small Organization, or if you need rights beyond those
+granted by the Free License, you must obtain a separate commercial license from
+the licensor. To request one, contact: jerez.m82@gmail.com.
+
+## Notices
+
+You must keep this license file, and all copyright and other notices, with every
+copy of the software.
+
+## No Other Rights
+
+This license does not grant you any rights in the licensor's trademarks, patents,
+or other intellectual property, except the copyright rights expressly stated
+above.
+
+## Termination
+
+If you violate this license, it terminates automatically. On termination you must
+stop using the software and delete all copies in your possession or control. If
+your violation is capable of cure, your license is reinstated if you cure the
+violation within 30 days of first becoming aware of it, unless the licensor has
+already notified you that your license has terminated.
+
+## No Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. YOU BEAR THE ENTIRE RISK OF USING
+THE SOFTWARE.
+
+## Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT WILL THE LICENSOR BE LIABLE
+FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR
+THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## Definitions
+
+- "Licensor" means Ma Jerez, the copyright holder.
+- "Software" means the RunTypes packages published under the @ts-runtypes npm
+  scope, together with any files distributed with them under this license.
+- "You" means the individual or entity exercising rights under this license.

package/bin/skills.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Copies the ts-runtypes agent skills bundled in this package into your skills folder.
+// Dependency-free; Node 18+ (relies on fs.cp). Ships as-is — never built.
+
+import { cp, mkdir, readdir, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const USAGE = `ts-runtypes-skills — install the RunTypes agent skills into your project
+
+Usage:
+  npx ts-runtypes-skills --claude        copy skills into ./.claude/skills
+  npx ts-runtypes-skills --agent         copy skills into ./.agent/skills
+  npx ts-runtypes-skills --dir <path>    copy skills into <path> (resolved from cwd)
+  npx ts-runtypes-skills -h | --help     show this help
+
+Once installed, your AI agent picks the right skill up automatically for enrichment tasks.`;
+
+function printUsage(stream = process.stdout) {
+  stream.write(USAGE + '\n');
+}
+
+function parseArgs(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '-h' || arg === '--help') return { help: true };
+    if (arg === '--claude') return { target: resolve(process.cwd(), '.claude', 'skills') };
+    if (arg === '--agent') return { target: resolve(process.cwd(), '.agent', 'skills') };
+    if (arg === '--dir') {
+      const dir = argv[i + 1];
+      if (!dir) return { error: '--dir requires a path argument' };
+      return { target: resolve(process.cwd(), dir) };
+    }
+    return { error: `unknown argument: ${arg}` };
+  }
+  return {};
+}
+
+async function listSkillDirs(skillsDir) {
+  let entries;
+  try {
+    entries = await readdir(skillsDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+
+  if (parsed.help) {
+    printUsage();
+    return 0;
+  }
+
+  if (parsed.error) {
+    process.stderr.write(`Error: ${parsed.error}\n\n`);
+    printUsage(process.stderr);
+    return 1;
+  }
+
+  if (!parsed.target) {
+    printUsage();
+    return 1;
+  }
+
+  const bundledSkills = fileURLToPath(new URL('../skills', import.meta.url));
+
+  // Confirm the bundled skills directory exists and holds at least one skill.
+  let bundledStat;
+  try {
+    bundledStat = await stat(bundledSkills);
+  } catch {
+    process.stderr.write(`Error: no bundled skills found at ${bundledSkills}\n`);
+    return 1;
+  }
+  if (!bundledStat.isDirectory()) {
+    process.stderr.write(`Error: bundled skills path is not a directory: ${bundledSkills}\n`);
+    return 1;
+  }
+
+  const skillNames = await listSkillDirs(bundledSkills);
+  if (!skillNames || skillNames.length === 0) {
+    process.stderr.write(`Error: no skills found inside ${bundledSkills}\n`);
+    return 1;
+  }
+
+  await mkdir(parsed.target, { recursive: true });
+
+  for (const skillName of skillNames) {
+    const from = resolve(bundledSkills, skillName);
+    const to = resolve(parsed.target, skillName);
+    await cp(from, to, { recursive: true });
+    process.stdout.write(`installed ${skillName} -> ${to}\n`);
+  }
+
+  process.stdout.write(
+    `Done. Copied ${skillNames.length} skill${skillNames.length === 1 ? '' : 's'} into ${parsed.target}\n`,
+  );
+  return 0;
+}
+
+main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    process.stderr.write(`Error: ${err && err.message ? err.message : err}\n`);
+    process.exitCode = 1;
+  });

package/dist/cjs/createRTFBinary.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBinaryEncoder = createBinaryEncoder;
+exports.createBinarySizer = createBinarySizer;
+exports.createBinaryDecoder = createBinaryDecoder;
+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'.`);
+}
+function encodeFixed(encodeFn, value, ser, capacity) {
+    try {
+        encodeFn(value, ser);
+    }
+    catch (err) {
+        if (err instanceof RangeError)
+            throw fixedBufferTooSmall(capacity);
+        throw err;
+    }
+    if (ser.getLength() > capacity)
+        throw fixedBufferTooSmall(capacity);
+    return ser.getBufferView();
+}
+function binarySizingKey(schemaId, injected) {
+    if (schemaId !== undefined)
+        return schemaId;
+    if ((0, entryTuple_ts_1.isEntryTuple)(injected))
+        return (0, entryTuple_ts_1.entryTupleKey)(injected).slice(entryTuple_ts_1.FN_HASH_LEN + 1);
+    return 'unknown';
+}
+function createBinaryEncoder(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 sizeStrategy = options?.sizeStrategy ?? 'dynamic';
+    if (sizeStrategy === 'precalculate') {
+        const fn = (value) => {
+            const sizer = (0, dataView_ts_1.createSizingSerializer)(cacheKey);
+            encodeFn(value, sizer);
+            const ser = (0, dataView_ts_1.createDataViewSerializer)(cacheKey, { size: sizer.getLength(), grow: false });
+            encodeFn(value, ser);
+            ser.markAsEnded();
+            return ser.getBufferView();
+        };
+        return fn;
+    }
+    if (sizeStrategy === 'initialSize') {
+        const fn = (value, size) => {
+            if (typeof size !== 'number')
+                throw new Error("createBinaryEncoder: sizeStrategy 'initialSize' requires a numeric `size` argument.");
+            return encodeFixed(encodeFn, value, (0, dataView_ts_1.createDataViewSerializer)(cacheKey, { size, grow: false }), size);
+        };
+        return fn;
+    }
+    if (sizeStrategy === 'intoBuffer') {
+        const fn = (value, into) => {
+            if (!(into instanceof ArrayBuffer))
+                throw new Error("createBinaryEncoder: sizeStrategy 'intoBuffer' requires an ArrayBuffer `into` argument.");
+            return encodeFixed(encodeFn, value, (0, dataView_ts_1.createDataViewSerializer)(cacheKey, { buffer: into }), into.byteLength);
+        };
+        return fn;
+    }
+    const coldStartSize = (0, entryTuple_ts_1.binarySizeEstimateFromTuple)(id);
+    const fn = (value) => {
+        const ser = (0, dataView_ts_1.createDataViewSerializer)(cacheKey, { grow: true, coldStartSize });
+        encodeFn(value, ser);
+        ser.markAsEnded();
+        return ser.getBufferView();
+    };
+    return fn;
+}
+function createBinarySizer(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);
+    return (value) => {
+        const sizer = (0, dataView_ts_1.createSizingSerializer)(cacheKey);
+        encodeFn(value, sizer);
+        return sizer.getLength();
+    };
+}
+function createBinaryDecoder(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);
+    return ((input) => {
+        let des;
+        if (input && typeof input.desString === 'function') {
+            des = input;
+        }
+        else {
+            des = (0, dataView_ts_1.createDataViewDeserializer)(cacheKey, input);
+        }
+        return decodeFn(undefined, des);
+    });
+}

package/dist/cjs/createRTFunctions.js

@@ -0,0 +1,38 @@
+"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;
+const rtUtils_ts_1 = require("./runtypes/rtUtils.js");
+const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
+function resolveTupleEntry(fnName, identityFn, val, args, rejectCircularRefs) {
+    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;
+}
+function createTypeFnArgsFunction(fnName, identityFn) {
+    return (val, options, args) => resolveTupleEntry(fnName, identityFn, val, args, readRejectCircularRefs(options));
+}
+function createRTFunction(fnName, identityFn) {
+    return (val, args) => resolveTupleEntry(fnName, identityFn, val, args);
+}
+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);
+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 createJsonDecoder(valOrSchema, options, id) {
+    return resolveTupleEntry('createJsonDecoder', jsonParseFallback, valOrSchema, id);
+}

package/dist/cjs/enrich/createFriendlyText.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFriendlyText = createFriendlyText;
+exports.resolveLocale = resolveLocale;
+exports.createFriendlyTextI18n = createFriendlyTextI18n;
+const PLACEHOLDER = /\$\[(\w+)\]/g;
+const DEFAULT_LOCALE = 'en';
+const pluralRulesCache = new Map();
+const boundNumberFormatCache = new Map();
+const boundDateFormatCache = new Map();
+function cachedPluralRules(locale) {
+    let rules = pluralRulesCache.get(locale);
+    if (!rules) {
+        rules = new Intl.PluralRules(locale, { type: 'cardinal' });
+        pluralRulesCache.set(locale, rules);
+    }
+    return rules;
+}
+function cachedBoundNumberFormat(locale, currency) {
+    const key = locale + '\0' + (currency ?? '');
+    let format = boundNumberFormatCache.get(key);
+    if (!format) {
+        try {
+            format = currency ? new Intl.NumberFormat(locale, { style: 'currency', currency }) : new Intl.NumberFormat(locale);
+        }
+        catch {
+            format = new Intl.NumberFormat(locale);
+        }
+        boundNumberFormatCache.set(key, format);
+    }
+    return format;
+}
+const DATE_BOUND_OPTIONS = {
+    date: { dateStyle: 'medium' },
+    temporalPlainDate: { dateStyle: 'medium' },
+    temporalPlainYearMonth: { year: 'numeric', month: 'long' },
+    dateTime: { dateStyle: 'medium', timeStyle: 'short' },
+    nativeDate: { dateStyle: 'medium', timeStyle: 'short' },
+    temporalInstant: { dateStyle: 'medium', timeStyle: 'short' },
+    temporalZonedDateTime: { dateStyle: 'medium', timeStyle: 'short' },
+    temporalPlainDateTime: { dateStyle: 'medium', timeStyle: 'short' },
+    time: { timeStyle: 'short' },
+    temporalPlainTime: { timeStyle: 'short' },
+};
+function cachedBoundDateFormat(locale, formatName) {
+    const key = locale + '\0' + formatName;
+    let format = boundDateFormatCache.get(key);
+    if (!format) {
+        format = new Intl.DateTimeFormat(locale, DATE_BOUND_OPTIONS[formatName]);
+        boundDateFormatCache.set(key, format);
+    }
+    return format;
+}
+function selectPlural(leaf, bound, locale) {
+    const count = Number(bound);
+    if (!Number.isFinite(count))
+        return leaf.other;
+    const category = cachedPluralRules(locale).select(count);
+    return leaf[category] || leaf.other;
+}
+function segmentKey(seg) {
+    if (typeof seg === 'string' || typeof seg === 'number')
+        return seg;
+    return seg.key;
+}
+function descend(node, seg) {
+    if (!node)
+        return undefined;
+    if (typeof seg === 'string')
+        return node[seg];
+    if (typeof seg === 'number')
+        return node.rt$slots ? node.rt$slots[seg] : node.rt$items;
+    return seg.failed === 'mapKey' ? node.rt$keys : node.rt$values;
+}
+function nodeAt(root, path) {
+    let node = root;
+    for (const seg of path)
+        node = descend(node, seg);
+    return node;
+}
+function rawLabel(path) {
+    for (let i = path.length - 1; i >= 0; i--) {
+        if (typeof path[i] === 'string')
+            return path[i];
+    }
+    const tail = path.length ? segmentKey(path[path.length - 1]) : undefined;
+    return tail === undefined ? '' : String(tail);
+}
+function pathToString(path) {
+    return path.map((seg) => String(segmentKey(seg))).join('.');
+}
+function constraintKey(format) {
+    if (!format)
+        return 'type';
+    const tail = format.formatPath[format.formatPath.length - 1];
+    return tail !== undefined ? String(tail) : format.name;
+}
+function primitiveVal(val) {
+    const kind = typeof val;
+    if (kind === 'string' || kind === 'number' || kind === 'boolean' || kind === 'bigint') {
+        return val;
+    }
+    return undefined;
+}
+function numericIndex(path) {
+    for (let i = path.length - 1; i >= 0; i--) {
+        const key = segmentKey(path[i]);
+        if (typeof key === 'number')
+            return key;
+    }
+    return undefined;
+}
+function interpolate(template, ctx) {
+    return template.replace(PLACEHOLDER, (whole, name) => {
+        if (name === 'label')
+            return ctx.label;
+        if (name === 'val')
+            return ctx.valText ?? '';
+        if (name === 'path')
+            return ctx.path;
+        if (name === 'index')
+            return ctx.index === undefined ? '' : String(ctx.index);
+        return whole;
+    });
+}
+function groupSignature(path) {
+    return path.map((seg) => (typeof seg === 'object' ? `${seg.key} ${seg.failed ?? ''}` : String(seg))).join('.');
+}
+function groupByPath(errs) {
+    const groups = [];
+    const bySignature = new Map();
+    for (const err of errs) {
+        const signature = groupSignature(err.path);
+        let group = bySignature.get(signature);
+        if (!group) {
+            group = { path: err.path, pathStr: pathToString(err.path), errors: [] };
+            bySignature.set(signature, group);
+            groups.push(group);
+        }
+        group.errors.push(err);
+    }
+    return groups;
+}
+function renderBoundText(state, format, val) {
+    if (val === undefined)
+        return undefined;
+    if (!state.i18n || !format)
+        return String(val);
+    if (format.isCurrency) {
+        const numeric = Number(val);
+        if (!Number.isFinite(numeric))
+            return String(val);
+        return cachedBoundNumberFormat(state.rootLocale, state.currency).format(numeric);
+    }
+    if (DATE_BOUND_OPTIONS[format.name] && (typeof val === 'string' || typeof val === 'number')) {
+        const date = new Date(val);
+        if (Number.isNaN(date.getTime()))
+            return String(val);
+        return cachedBoundDateFormat(state.rootLocale, format.name).format(date);
+    }
+    return String(val);
+}
+const labelFor = (node, path) => node?.rt$label || rawLabel(path);
+function resolveTemplate(node, key, val, mapLocale) {
+    const errorTemplates = node?.rt$errors;
+    if (!errorTemplates)
+        return undefined;
+    return leafTemplate(errorTemplates[key], val, mapLocale) ?? leafTemplate(errorTemplates.rt$default, val, mapLocale);
+}
+function leafTemplate(leaf, val, mapLocale) {
+    if (leaf === undefined)
+        return undefined;
+    const template = typeof leaf === 'string' ? leaf : selectPlural(leaf, val, mapLocale);
+    return template || undefined;
+}
+function renderLabel(state, path) {
+    const segs = typeof path === 'string' ? (path === '' ? [] : path.split('.')) : path;
+    const node = nodeAt(state.root, segs);
+    if (node?.rt$label)
+        return node.rt$label;
+    const sourceNode = state.source ? nodeAt(state.source, segs) : undefined;
+    return labelFor(sourceNode, segs);
+}
+function renderErrors(state, errs) {
+    const out = [];
+    for (const group of groupByPath(errs)) {
+        const node = nodeAt(state.root, group.path);
+        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);
+        for (const err of group.errors) {
+            const key = constraintKey(err.format);
+            const val = primitiveVal(err.format?.val);
+            const template = resolveTemplate(node, key, val, state.rootLocale) ?? resolveTemplate(sourceNode, key, val, state.sourceLocale);
+            const message = template
+                ? interpolate(template, {
+                    label,
+                    valText: renderBoundText(state, err.format, val),
+                    path: group.pathStr,
+                    index,
+                })
+                : `${label || 'value'} is invalid`;
+            out.push({ path: group.pathStr, label, message });
+        }
+    }
+    return out;
+}
+function createFriendlyText(map) {
+    const state = {
+        root: map,
+        rootLocale: DEFAULT_LOCALE,
+        sourceLocale: DEFAULT_LOCALE,
+    };
+    return {
+        label: (path) => renderLabel(state, path),
+        errors: (errs) => renderErrors(state, errs),
+    };
+}
+function resolveLocale(locale, translations) {
+    if (!locale)
+        return undefined;
+    const have = (tag) => translations[tag] !== undefined;
+    const parts = locale.split('-');
+    for (let keep = parts.length; keep >= 1; keep--) {
+        const candidate = parts.slice(0, keep).join('-');
+        if (have(candidate))
+            return candidate;
+    }
+    const baseLanguage = parts[0].toLowerCase();
+    for (const tag of Object.keys(translations)) {
+        if (translations[tag] !== undefined && tag.split('-')[0].toLowerCase() === baseLanguage)
+            return tag;
+    }
+    return undefined;
+}
+function createFriendlyTextI18n(source, options) {
+    const sourceRoot = source;
+    const sourceLocale = options.sourceLocale ?? DEFAULT_LOCALE;
+    const state = () => {
+        const active = typeof options.locale === 'object' ? options.locale.value : options.locale;
+        const matched = resolveLocale(active, options.translations);
+        const translation = matched !== undefined ? options.translations[matched] : undefined;
+        return {
+            root: translation ?? sourceRoot,
+            rootLocale: translation ? matched : sourceLocale,
+            source: translation ? sourceRoot : undefined,
+            sourceLocale,
+            i18n: true,
+            currency: typeof options.currency === 'object' ? options.currency.value : options.currency,
+        };
+    };
+    return {
+        label: (path) => renderLabel(state(), path),
+        errors: (errs) => renderErrors(state(), errs),
+    };
+}

package/dist/cjs/enrich/friendlyText.js

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

package/dist/cjs/enrich/mockData.js

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

package/dist/cjs/formats/bigintFormats.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigUInt64 = exports.bigInt64 = exports.bigNegativeInt = exports.bigPositiveInt = exports.bigNegative = exports.bigPositive = void 0;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+exports.bigPositive = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigNegative = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigPositiveInt = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigNegativeInt = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigInt64 = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigUInt64 = (0, builderCore_ts_1.presetBuilder)('bigint');

package/dist/cjs/formats/datetime/dateFormats.js

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