@mionjs/run-types 0.8.10 → 0.13.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Mion
+Copyright (c) 2026 Ma Jerez
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,32 +1,30 @@
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
-    <img alt='mion, a mikro kit for Typescript Serverless APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
-  </picture>
-</p>
-<p align="center">
-  <strong>Common RunTypes.
-  </strong>
-</p>
-<p align=center>
-  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
-  <img src="https://img.shields.io/badge/license-MIT-97ca00.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
-</p>
+# @mionjs/run-types
 
-# `@mionjs/run-types`
+**Compile-time runtime types for TypeScript 7 / typescript-go (tsgo).**
 
-Runtime Types support for mion apps!
+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
+round trip functions, mock data, and reflection.
 
-## Description
+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
+[`@mionjs/devtools`](https://www.npmjs.com/package/@mionjs/devtools).
 
-This library provides support for runtime types based on [@deepkit/type].  
-Having runtime types enables a full new set of features when using typescript/javascript.
+## Documentation
 
-## Check Out The [Website And Documentation](http://mion.io) 📚
+Install, guides, the factory reference, and benchmarks live at
+**[mion.pages.dev/runtypes](https://mion.pages.dev/runtypes)**.
 
-[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+- [Quick start](https://mion.pages.dev/runtypes/introduction/quick-start)
+- [Configuration](https://mion.pages.dev/runtypes/introduction/configuration)
+- [Source and issues](https://github.com/MionKit/mion)
 
----
+## Status
 
-[MIT LICENSE](../../LICENSE)
+Experimental.
+
+## License
+
+MIT. See
+[LICENSE](https://github.com/MionKit/mion/blob/main/LICENSE).

package/bin/skills.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Copies the mion 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 = `mion-skills — install the RunTypes agent skills into your project
+
+Usage:
+  npx mion-skills --claude        copy skills into ./.claude/skills
+  npx mion-skills --agent         copy skills into ./.agent/skills
+  npx mion-skills --dir <path>    copy skills into <path> (resolved from cwd)
+  npx mion-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/builders/atomic.d.ts

@@ -0,0 +1,13 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectRunTypeId } from '../markers.ts';
+export declare function boolean(id?: InjectRunTypeId<boolean>): RunType<boolean>;
+export declare function literal<const V extends string | number | bigint | boolean | null | undefined>(value: V, id?: InjectRunTypeId<V>): RunType<V>;
+export declare function regexp(id?: InjectRunTypeId<RegExp>): RunType<RegExp>;
+export declare function symbol(id?: InjectRunTypeId<symbol>): RunType<symbol>;
+export declare function any(id?: InjectRunTypeId<any>): RunType<any>;
+export declare function unknown(id?: InjectRunTypeId<unknown>): RunType<unknown>;
+export declare function never(id?: InjectRunTypeId<never>): RunType<never>;
+export declare function voidType(id?: InjectRunTypeId<void>): RunType<void>;
+export declare function classType<Instance>(ctor: abstract new (...args: any[]) => Instance, id?: InjectRunTypeId<Instance>): RunType<Instance>;
+export declare function enumType<const E extends Record<string, string | number>>(enumObject: E, id?: InjectRunTypeId<E[keyof E]>): RunType<E[keyof E]>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/builders/atomic.js

@@ -0,0 +1,32 @@
+import { builderResult } from '../runtypes/builderCore.js';
+export function boolean(id) {
+    return builderResult(id, { type: 'boolean', formatParams: {} });
+}
+export function literal(value, id) {
+    return builderResult(id, { type: 'literal', literal: value });
+}
+export function regexp(id) {
+    return builderResult(id, { type: 'regexp', formatParams: {} });
+}
+export function symbol(id) {
+    return builderResult(id, { type: 'symbol', formatParams: {} });
+}
+export function any(id) {
+    return builderResult(id, { type: 'any', formatParams: {} });
+}
+export function unknown(id) {
+    return builderResult(id, { type: 'unknown', formatParams: {} });
+}
+export function never(id) {
+    return builderResult(id, { type: 'never', formatParams: {} });
+}
+export function voidType(id) {
+    return builderResult(id, { type: 'void', formatParams: {} });
+}
+export function classType(ctor, id) {
+    return builderResult(id, { type: 'class', ctor });
+}
+export function enumType(enumObject, id) {
+    return builderResult(id, { type: 'enum', members: enumObject });
+}
+//# sourceMappingURL=atomic.js.map

package/dist/builders/atomic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../../src/builders/atomic.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAIzD,MAAM,UAAU,OAAO,CAAC,EAA6B;IACnD,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAChE,CAAC;AAGD,MAAM,UAAU,OAAO,CACrB,KAAQ,EACR,EAAuB;IAEvB,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;AAC9D,CAAC;AAID,MAAM,UAAU,MAAM,CAAC,EAA4B;IACjD,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAC/D,CAAC;AAGD,MAAM,UAAU,MAAM,CAAC,EAA4B;IACjD,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAC/D,CAAC;AAGD,MAAM,UAAU,GAAG,CAAC,EAAyB;IAC3C,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAC5D,CAAC;AAGD,MAAM,UAAU,OAAO,CAAC,EAA6B;IACnD,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAChE,CAAC;AAGD,MAAM,UAAU,KAAK,CAAC,EAA2B;IAC/C,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAC9D,CAAC;AAGD,MAAM,UAAU,QAAQ,CAAC,EAA0B;IACjD,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAC,CAAC,CAAC;AAC7D,CAAC;AAID,MAAM,UAAU,SAAS,CACvB,IAA+C,EAC/C,EAA8B;IAE9B,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAC,CAAC,CAAC;AAClD,CAAC;AAKD,MAAM,UAAU,QAAQ,CACtB,UAAa,EACb,EAAgC;IAEhC,OAAO,aAAa,CAAC,EAAE,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAC,CAAC,CAAC;AAChE,CAAC"}

package/dist/builders/compose.d.ts

@@ -0,0 +1,61 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { ExactParams } from '../runtypes/builderTypes.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+import type { FormattedCollectionParamsValueFirst, FormattedMapParamsValueFirst, FormattedObjectParamsValueFirst, FormattedArrayFrom, FormattedObjectFrom, FormattedSetFrom, FormattedMapFrom } from '../formats/structural.ts';
+import type { InferType, UnionOf, IntersectionOf, TemplatePart, AssembleTemplate, ObjectType, PropModifiers, PropModCarrier, Self, Recursive, LabeledTuple, SlotCarrier, TupleFromGroups, LabeledTupleFromGroups, FuncFromParams } from './static.ts';
+export declare function array<T>(item: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<T[]>): RunType<T[]>;
+export declare function array<T, const P extends FormattedCollectionParamsValueFirst>(item: CompTimeArgs<RunType<T>>, params: CompTimeArgs<ExactParams<P, FormattedCollectionParamsValueFirst>>, id?: InjectRunTypeId<FormattedArrayFrom<T[], P>>): RunType<FormattedArrayFrom<T[], P>>;
+export declare function slot<const Label extends string, Value>(label: CompTimeArgs<Label>, value: CompTimeArgs<RunType<Value>>): SlotCarrier<Label, Value>;
+export declare function tuple<const T extends readonly RunType[] = [], const O extends readonly RunType[] = [], RestValue = never>(parts: CompTimeArgs<{
+    readonly required?: T;
+    readonly optional?: O;
+    readonly rest?: RunType<RestValue>;
+}>, id?: InjectRunTypeId<TupleFromGroups<T, O, RestValue>>): RunType<TupleFromGroups<T, O, RestValue>>;
+export declare function tuple<const T extends readonly SlotCarrier<string, unknown>[] = [], const O extends readonly SlotCarrier<string, unknown>[] = [], const RestLabel extends string = never, RestValue = never>(parts: CompTimeArgs<{
+    readonly required?: T;
+    readonly optional?: O;
+    readonly rest?: SlotCarrier<RestLabel, RestValue>;
+}>, id?: InjectRunTypeId<LabeledTupleFromGroups<T, O, RestLabel, RestValue>>): RunType<LabeledTupleFromGroups<T, O, RestLabel, RestValue>>;
+export declare function union<A, B>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>]>, id?: InjectRunTypeId<A | B>): RunType<A | B>;
+export declare function union<A, B, C>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>]>, id?: InjectRunTypeId<A | B | C>): RunType<A | B | C>;
+export declare function union<A, B, C, D>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>]>, id?: InjectRunTypeId<A | B | C | D>): RunType<A | B | C | D>;
+export declare function union<A, B, C, D, E>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>]>, id?: InjectRunTypeId<A | B | C | D | E>): RunType<A | B | C | D | E>;
+export declare function union<A, B, C, D, E, F>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>, RunType<F>]>, id?: InjectRunTypeId<A | B | C | D | E | F>): RunType<A | B | C | D | E | F>;
+export declare function union<A, B, C, D, E, F, G>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>, RunType<F>, RunType<G>]>, id?: InjectRunTypeId<A | B | C | D | E | F | G>): RunType<A | B | C | D | E | F | G>;
+export declare function union<A, B, C, D, E, F, G, H>(members: CompTimeArgs<readonly [RunType<A>, RunType<B>, RunType<C>, RunType<D>, RunType<E>, RunType<F>, RunType<G>, RunType<H>]>, id?: InjectRunTypeId<A | B | C | D | E | F | G | H>): RunType<A | B | C | D | E | F | G | H>;
+export declare function union<const T extends readonly RunType[]>(members: CompTimeArgs<T>, id?: InjectRunTypeId<UnionOf<T>>): RunType<UnionOf<T>>;
+export declare const anyOf: typeof union;
+export declare function intersection<A, B = unknown, C = unknown, D = unknown>(a: CompTimeArgs<RunType<A>>, b?: CompTimeArgs<RunType<B>>, c?: CompTimeArgs<RunType<C>>, d?: CompTimeArgs<RunType<D>>, id?: InjectRunTypeId<A & B & C & D>): RunType<A & B & C & D>;
+export declare function intersection<const T extends readonly RunType[]>(members: CompTimeArgs<T>, id?: InjectRunTypeId<IntersectionOf<T>>): RunType<IntersectionOf<T>>;
+export declare function record<V>(valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Record<string, V>>): RunType<Record<string, V>>;
+export declare function record<V, const P extends FormattedObjectParamsValueFirst>(valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedObjectParamsValueFirst>>, id?: InjectRunTypeId<FormattedObjectFrom<Record<string, V>, P>>): RunType<FormattedObjectFrom<Record<string, V>, P>>;
+export declare function record<K extends string | number, V>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Record<K, V>>): RunType<Record<K, V>>;
+export declare function record<K extends string | number, V, const P extends FormattedObjectParamsValueFirst>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedObjectParamsValueFirst>>, id?: InjectRunTypeId<FormattedObjectFrom<Record<K, V>, P>>): RunType<FormattedObjectFrom<Record<K, V>, P>>;
+export declare function map<K, V>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Map<K, V>>): RunType<Map<K, V>>;
+export declare function map<K, V, const P extends FormattedMapParamsValueFirst>(keySchema: CompTimeArgs<RunType<K>>, valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedMapParamsValueFirst>>, id?: InjectRunTypeId<FormattedMapFrom<Map<K, V>, P>>): RunType<FormattedMapFrom<Map<K, V>, P>>;
+export declare function set<V>(valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Set<V>>): RunType<Set<V>>;
+export declare function set<V, const P extends FormattedCollectionParamsValueFirst>(valueSchema: CompTimeArgs<RunType<V>>, params: CompTimeArgs<ExactParams<P, FormattedCollectionParamsValueFirst>>, id?: InjectRunTypeId<FormattedSetFrom<Set<V>, P>>): RunType<FormattedSetFrom<Set<V>, P>>;
+export declare function self(id?: InjectRunTypeId<Self>): RunType<Self>;
+export declare function circular<Body>(body: CompTimeArgs<RunType<Body>>, id?: InjectRunTypeId<Recursive<Body>>): RunType<Recursive<Body>>;
+export declare function promise<V>(valueSchema: CompTimeArgs<RunType<V>>, id?: InjectRunTypeId<Promise<V>>): RunType<Promise<V>>;
+export declare function func<const P extends readonly RunType[] = [], R extends RunType = RunType<void>>(parts?: CompTimeArgs<{
+    readonly params?: P;
+    readonly ret?: R;
+}>, id?: InjectRunTypeId<FuncFromParams<P, InferType<R>>>): RunType<FuncFromParams<P, InferType<R>>>;
+export declare function func<const P extends readonly SlotCarrier<string, unknown>[], R extends RunType = RunType<void>>(parts: CompTimeArgs<{
+    readonly params: P;
+    readonly ret?: R;
+}>, id?: InjectRunTypeId<(...args: LabeledTuple<P>) => InferType<R>>): RunType<(...args: LabeledTuple<P>) => InferType<R>>;
+export declare function func<T extends readonly unknown[], R extends RunType = RunType<void>>(parts: CompTimeArgs<{
+    readonly params: RunType<T>;
+    readonly ret?: R;
+}>, id?: InjectRunTypeId<(...args: T) => InferType<R>>): RunType<(...args: T) => InferType<R>>;
+export declare function callable<Fn, Props>(fn: CompTimeArgs<RunType<Fn>>, iface: CompTimeArgs<RunType<Props>>, id?: InjectRunTypeId<Fn & Props>): RunType<Fn & Props>;
+export declare function templateLiteral<const P extends readonly TemplatePart[]>(parts: CompTimeArgs<P>, id?: InjectRunTypeId<AssembleTemplate<P>>): RunType<AssembleTemplate<P>>;
+export declare function propMod<const M extends PropModifiers, const F>(modifiers: CompTimeArgs<ExactParams<M, PropModifiers>>, field: CompTimeArgs<F>): PropModCarrier<M, F>;
+export declare function optional<const F>(field: CompTimeArgs<F>): PropModCarrier<{
+    optional: true;
+}, F>;
+export declare function object<const C extends Record<string, unknown>>(config: CompTimeArgs<C>, id?: InjectRunTypeId<ObjectType<C>>): RunType<ObjectType<C>>;
+export declare function object<const C extends Record<string, unknown>, const P extends FormattedObjectParamsValueFirst>(config: CompTimeArgs<C>, params: CompTimeArgs<ExactParams<P, FormattedObjectParamsValueFirst>>, id?: InjectRunTypeId<FormattedObjectFrom<ObjectType<C>, P>>): RunType<FormattedObjectFrom<ObjectType<C>, P>>;
+//# sourceMappingURL=compose.d.ts.map

package/dist/builders/compose.js

@@ -0,0 +1,103 @@
+import { builderResult } from '../runtypes/builderCore.js';
+function isRunTypeLike(arg) {
+    return typeof arg === 'object' && arg !== null && !Array.isArray(arg) && ('kind' in arg || 'type' in arg || '__rtType' in arg);
+}
+function isFormatParams(arg) {
+    return typeof arg === 'object' && arg !== null && !Array.isArray(arg) && !isRunTypeLike(arg);
+}
+function isSlotCarrier(arg) {
+    return typeof arg === 'object' && arg !== null && typeof arg.__slotLabel === 'string';
+}
+function slotChild(arg) {
+    return isSlotCarrier(arg) ? arg.__slotValue : arg;
+}
+export function array(item, arg2, arg3) {
+    const base = { type: 'array', child: item };
+    if (isFormatParams(arg2)) {
+        return builderResult(arg3, base);
+    }
+    return builderResult(arg2, base);
+}
+export function slot(label, value) {
+    return { __slotLabel: label, __slotValue: value };
+}
+export function tuple(parts, id) {
+    return builderResult(id, {
+        type: 'tuple',
+        children: (parts.required ?? []).map(slotChild),
+        optionalChildren: parts.optional?.map(slotChild),
+        rest: parts.rest === undefined ? undefined : slotChild(parts.rest),
+    });
+}
+export function union(members, id) {
+    return builderResult(id, { type: 'union', children: members });
+}
+export const anyOf = union;
+export function intersection(arg1, arg2, arg3, arg4, arg5) {
+    if (Array.isArray(arg1)) {
+        return builderResult(arg2, { type: 'intersection', children: arg1 });
+    }
+    return builderResult(arg5, {
+        type: 'intersection',
+        children: [arg1, arg2, arg3, arg4],
+    });
+}
+export function record(arg1, arg2, arg3, arg4) {
+    if (isRunTypeLike(arg2)) {
+        const base = { type: 'record', index: arg1, child: arg2 };
+        if (isFormatParams(arg3)) {
+            return builderResult(arg4, base);
+        }
+        return builderResult(arg3, base);
+    }
+    const base = { type: 'record', child: arg1 };
+    if (isFormatParams(arg2)) {
+        return builderResult(arg3, base);
+    }
+    return builderResult(arg2, base);
+}
+export function map(keySchema, valueSchema, arg3, arg4) {
+    const base = { type: 'map', index: keySchema, child: valueSchema };
+    if (isFormatParams(arg3))
+        return builderResult(arg4, base);
+    return builderResult(arg3, base);
+}
+export function set(valueSchema, arg2, arg3) {
+    const base = { type: 'set', child: valueSchema };
+    if (isFormatParams(arg2))
+        return builderResult(arg3, base);
+    return builderResult(arg2, base);
+}
+export function self(id) {
+    return builderResult(id, { type: 'self' });
+}
+export function circular(body, id) {
+    return builderResult(id, { type: 'circular', child: body });
+}
+export function promise(valueSchema, id) {
+    return builderResult(id, { type: 'promise', child: valueSchema });
+}
+export function func(parts, id) {
+    const params = parts?.params;
+    const parameters = Array.isArray(params) ? params.map(slotChild) : (params ?? []);
+    return builderResult(id, { type: 'function', parameters, return: parts?.ret });
+}
+export function callable(fn, iface, id) {
+    return builderResult(id, { type: 'intersection', children: [fn, iface] });
+}
+export function templateLiteral(parts, id) {
+    return builderResult(id, { type: 'templateLiteral', children: parts });
+}
+export function propMod(modifiers, field) {
+    return { __propMod: modifiers, __field: field };
+}
+export function optional(field) {
+    return propMod({ optional: true }, field);
+}
+export function object(config, arg2, arg3) {
+    if (isFormatParams(arg2)) {
+        return builderResult(arg3, config);
+    }
+    return builderResult(arg2, config);
+}
+//# sourceMappingURL=compose.js.map

package/dist/builders/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../src/builders/compose.ts"],"names":[],"mappings":"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"}

package/dist/builders/index.d.ts

@@ -0,0 +1,6 @@
+export { boolean, literal, regexp, symbol, any, unknown, never, voidType, voidType as void, classType, enumType, enumType as enum, } from './atomic.ts';
+export { object, array, tuple, slot, union, anyOf, intersection, record, map, set, promise, circular, self, func, callable, templateLiteral, propMod, optional, } from './compose.ts';
+export { partial, required, pick, omit, exclude, extract, nonNullable, readonlyType, readonlyType as readonly, returnType, parameters, } from './utility.ts';
+export type { PropModifiers, MapTuple, TemplatePart, AssembleTemplate, AnyOf } from './static.ts';
+import '../runtypes/pure-fns-utils.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/builders/index.js

@@ -0,0 +1,5 @@
+export { boolean, literal, regexp, symbol, any, unknown, never, voidType, voidType as void, classType, enumType, enumType as enum, } from './atomic.js';
+export { object, array, tuple, slot, union, anyOf, intersection, record, map, set, promise, circular, self, func, callable, templateLiteral, propMod, optional, } from './compose.js';
+export { partial, required, pick, omit, exclude, extract, nonNullable, readonlyType, readonlyType as readonly, returnType, parameters, } from './utility.js';
+import '../runtypes/pure-fns-utils.js';
+//# sourceMappingURL=index.js.map

package/dist/builders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/builders/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,MAAM,EACN,GAAG,EACH,OAAO,EACP,KAAK,EACL,QAAQ,EACR,QAAQ,IAAI,IAAI,EAChB,SAAS,EACT,QAAQ,EACR,QAAQ,IAAI,IAAI,GACjB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,KAAK,EACL,KAAK,EACL,YAAY,EACZ,MAAM,EACN,GAAG,EACH,GAAG,EACH,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,eAAe,EACf,OAAO,EACP,QAAQ,GACT,MAAM,cAAc,CAAC;AAItB,OAAO,EACL,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,OAAO,EACP,WAAW,EACX,YAAY,EACZ,YAAY,IAAI,QAAQ,EACxB,UAAU,EACV,UAAU,GACX,MAAM,cAAc,CAAC;AAOtB,OAAO,+BAA+B,CAAC"}

package/dist/builders/static.d.ts

@@ -0,0 +1,138 @@
+import type { __rtFormatName, __rtFormatParams, __rtFormatBrand, __rtContains, __rtPatternProps, __rtPropNames, __rtLabels } from '../runtypes/sentinelKeys.ts';
+import type { RunType } from '../runtypes/types.ts';
+import type { InferType } from '../runtypes/builderTypes.ts';
+export type { InferType, LeafType, LeafTypeByFormatName, LeafFormatName, BrandArg, TemporalFormatByTag, TemporalBaseByTag, TemporalBuilderFn, } from '../runtypes/builderTypes.ts';
+export interface PropModifiers {
+    optional?: true;
+    readonly?: true;
+}
+export interface PropModCarrier<M extends PropModifiers, F> {
+    readonly __propMod: M;
+    readonly __field: F;
+}
+export type FieldOf<V> = V extends {
+    __propMod: PropModifiers;
+    __field: unknown;
+} ? InferType<V['__field']> : InferType<V>;
+export type IsOptional<V> = V extends {
+    __propMod: {
+        optional: true;
+    };
+} ? true : false;
+export type IsReadonly<V> = V extends {
+    __propMod: {
+        readonly: true;
+    };
+} ? true : false;
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+};
+type AnyOptional<C> = true extends {
+    [K in keyof C]: IsOptional<C[K]>;
+}[keyof C] ? true : false;
+type AnyReadonly<C> = true extends {
+    [K in keyof C]: IsReadonly<C[K]>;
+}[keyof C] ? true : false;
+type ObjectOptionalOnly<C> = Flatten<{
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? never : K]: FieldOf<C[K]>;
+} & {
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? K : never]?: FieldOf<C[K]>;
+}>;
+type ObjectReadonlyOnly<C> = Flatten<{
+    -readonly [K in keyof C as IsReadonly<C[K]> extends true ? never : K]: FieldOf<C[K]>;
+} & {
+    readonly [K in keyof C as IsReadonly<C[K]> extends true ? K : never]: FieldOf<C[K]>;
+}>;
+type ObjectMixed<C> = Flatten<{
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? never : IsReadonly<C[K]> extends true ? never : K]: FieldOf<C[K]>;
+} & {
+    readonly [K in keyof C as IsOptional<C[K]> extends true ? never : IsReadonly<C[K]> extends true ? K : never]: FieldOf<C[K]>;
+} & {
+    -readonly [K in keyof C as IsOptional<C[K]> extends true ? (IsReadonly<C[K]> extends true ? never : K) : never]?: FieldOf<C[K]>;
+} & {
+    readonly [K in keyof C as IsOptional<C[K]> extends true ? (IsReadonly<C[K]> extends true ? K : never) : never]?: FieldOf<C[K]>;
+}>;
+export type ObjectType<C> = AnyOptional<C> extends false ? AnyReadonly<C> extends false ? {
+    -readonly [K in keyof C]: FieldOf<C[K]>;
+} : ObjectReadonlyOnly<C> : AnyReadonly<C> extends false ? ObjectOptionalOnly<C> : ObjectMixed<C>;
+export type MapTuple<T extends readonly RunType[]> = {
+    -readonly [K in keyof T]: InferType<T[K]>;
+};
+export interface SlotCarrier<Label extends string, Value> {
+    readonly __slotLabel: Label;
+    readonly __slotValue: RunType<Value>;
+}
+export type SlotValues<Slots extends readonly SlotCarrier<string, unknown>[]> = {
+    -readonly [K in keyof Slots]: InferType<Slots[K]['__slotValue']>;
+};
+export type SlotLabels<Slots extends readonly SlotCarrier<string, unknown>[]> = {
+    -readonly [K in keyof Slots]: Slots[K]['__slotLabel'];
+};
+export type LabeledTuple<Slots extends readonly SlotCarrier<string, unknown>[], OptionalSlots extends readonly SlotCarrier<string, unknown>[] = []> = [...SlotValues<Slots>, ...Partial<SlotValues<OptionalSlots>>] & {
+    readonly [__rtLabels]?: readonly [...SlotLabels<Slots>, ...SlotLabels<OptionalSlots>];
+};
+export type LabeledRestTuple<Slots extends readonly SlotCarrier<string, unknown>[], OptionalSlots extends readonly SlotCarrier<string, unknown>[], RestLabel extends string, Rest> = [...SlotValues<Slots>, ...Partial<SlotValues<OptionalSlots>>, ...Rest[]] & {
+    readonly [__rtLabels]?: readonly [...SlotLabels<Slots>, ...SlotLabels<OptionalSlots>, RestLabel];
+};
+export type TupleFromGroups<Items extends readonly RunType[], OptionalItems extends readonly RunType[], Rest> = [Rest] extends [
+    never
+] ? [...MapTuple<Items>, ...Partial<MapTuple<OptionalItems>>] : [...MapTuple<Items>, ...Partial<MapTuple<OptionalItems>>, ...Rest[]];
+export type LabeledTupleFromGroups<Slots extends readonly SlotCarrier<string, unknown>[], OptionalSlots extends readonly SlotCarrier<string, unknown>[], RestLabel extends string, Rest> = [RestLabel] extends [never] ? LabeledTuple<Slots, OptionalSlots> : LabeledRestTuple<Slots, OptionalSlots, RestLabel, Rest>;
+export type FuncFromParams<Params extends readonly RunType[], Return> = Params extends readonly [] ? () => Return : (...args: MapTuple<Params>) => Return;
+export type UnionOf<T extends readonly RunType[]> = InferType<T[number]>;
+export type AnyOf<Branches extends readonly [unknown, ...unknown[]]> = Branches[number];
+export type IntersectionOf<T extends readonly RunType[]> = T extends readonly [
+    infer Head extends RunType,
+    ...infer Tail extends readonly RunType[]
+] ? InferType<Head> & IntersectionOf<Tail> : unknown;
+export type TemplatePart = string | RunType;
+type Interpolatable = string | number | bigint | boolean | null | undefined;
+type Unbrand<X> = typeof __rtFormatName extends keyof X ? X extends string ? string : X extends number ? number : X extends bigint ? bigint : X & Interpolatable : X & Interpolatable;
+type PartText<Part extends TemplatePart> = Part extends RunType ? Unbrand<InferType<Part>> : Part & Interpolatable;
+export type AssembleTemplate<P extends readonly TemplatePart[]> = P extends readonly [
+    infer Head extends TemplatePart,
+    ...infer Tail extends readonly TemplatePart[]
+] ? `${PartText<Head>}${AssembleTemplate<Tail>}` : '';
+declare const SelfBrand: unique symbol;
+export type Self = {
+    readonly [SelfBrand]: true;
+};
+export type CarriedKey = typeof __rtFormatName | typeof __rtFormatParams | typeof __rtFormatBrand | typeof __rtContains | typeof __rtPatternProps | typeof __rtPropNames | typeof __rtLabels;
+type HasCarried<T> = [Extract<keyof T, CarriedKey>] extends [never] ? false : true;
+type CarrySlots<T, P extends [unknown]> = {
+    readonly [K in Extract<keyof T, CarriedKey>]?: SubstituteSelf<NonNullable<T[K]>, P>;
+};
+type ContainsSelf<T, Depth extends unknown[] = []> = AnyTrue<ContainsSelfIn<T, Depth>>;
+type AnyTrue<B> = [B] extends [never] ? false : [B] extends [false] ? false : true;
+type ContainsSelfIn<T, Depth extends unknown[]> = Depth['length'] extends 24 ? false : 0 extends 1 & T ? false : T extends Self ? true : T extends string | number | boolean | bigint | symbol | null | undefined ? false : T extends Date | RegExp ? false : T extends Map<any, any> ? T extends Map<infer K, infer V> ? AnyTrue<ContainsSelfIn<K, Next<Depth>> | ContainsSelfIn<V, Next<Depth>>> : false : T extends Set<any> ? T extends Set<infer E> ? ContainsSelf<E, Next<Depth>> : false : T extends Promise<infer E> ? ContainsSelf<E, Next<Depth>> : T extends (...args: infer A extends readonly unknown[]) => infer R ? AnyTrue<ContainsSelfIn<A[number], Next<Depth>> | ContainsSelfIn<R, Next<Depth>>> : T extends readonly unknown[] ? number extends T['length'] ? ContainsSelf<T[number], Next<Depth>> : AnyTrue<MembersContainSelf<MemberBoxes<T>[number], Depth>> : T extends object ? AnyTrue<MembersContainSelf<MemberBoxes<T>[keyof T], Depth>> : false;
+type Next<Depth extends unknown[]> = [...Depth, unknown];
+type MemberBoxes<T> = {
+    [K in keyof T]: [T[K]];
+};
+type MembersContainSelf<Boxed, Depth extends unknown[]> = Boxed extends [infer Member] ? ContainsSelf<Member, Next<Depth>> : false;
+type SubstituteSelf<T, P extends [unknown]> = T extends Self ? P[0] : T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends Date | RegExp ? T : ContainsSelf<T> extends false ? T : SubstituteInto<T, P>;
+type SubstituteInto<T, P extends [unknown]> = T extends Map<any, any> ? T extends Map<infer K, infer V> ? CarryOnto<Map<SubstituteSelf<K, P>, SubstituteSelf<V, P>>, T, P> : never : T extends Set<any> ? T extends Set<infer E> ? CarryOnto<Set<SubstituteSelf<E, P>>, T, P> : never : T extends Promise<infer E> ? Promise<SubstituteSelf<E, P>> : T extends (...args: infer A extends readonly unknown[]) => infer R ? (...args: SubstituteTuple<A, P>) => SubstituteSelf<R, P> : T extends readonly unknown[] ? number extends T['length'] ? T extends readonly (infer E)[] ? CarryOnto<T extends unknown[] ? SubstituteSelf<E, P>[] : readonly SubstituteSelf<E, P>[], T, P> : never : T extends unknown[] ? SubstituteTuple<T, P> : Readonly<SubstituteTuple<T, P>> : T extends object ? HasCarried<T> extends true ? {
+    [K in keyof T as K extends CarriedKey ? never : K]: SubstituteSelf<T[K], P>;
+} & CarrySlots<T, P> : {
+    [K in keyof T]: SubstituteSelf<T[K], P>;
+} : T;
+type CarryOnto<Base, Source, P extends [unknown]> = HasCarried<Source> extends true ? Base & CarrySlots<Source, P> : Base;
+type SubstituteTuple<T extends readonly unknown[], P extends [unknown]> = HasCarried<T> extends true ? IsFixedArity<T> extends true ? TupleFromIndexes<T, P, RequiredArity<T>> & CarrySlots<T, P> : [
+    ...TupleFromIndexes<T, P, RequiredArity<T>>,
+    ...Partial<OptionalSlots<T, P> extends infer Slots extends unknown[] ? Slots : []>
+] & CarrySlots<T, P> : {
+    -readonly [K in keyof T]: SubstituteSelf<T[K], P>;
+};
+type IsFixedArity<T extends readonly unknown[]> = IsUnion<T['length']> extends true ? false : true;
+type IsUnion<X, All = X> = X extends unknown ? ([All] extends [X] ? false : true) : never;
+type RequiredArity<T extends readonly unknown[], Acc extends unknown[] = []> = Acc['length'] extends T['length'] ? Acc : RequiredArity<T, [...Acc, unknown]>;
+type TotalArity<T extends readonly unknown[], Acc extends unknown[] = RequiredArity<T>> = [
+    ...Acc,
+    unknown
+]['length'] extends T['length'] ? TotalArity<T, [...Acc, unknown]> : Acc;
+type TupleFromIndexes<T, P extends [unknown], Stop extends unknown[], Acc extends unknown[] = []> = Acc['length'] extends Stop['length'] ? Acc : TupleFromIndexes<T, P, Stop, [...Acc, SubstituteSelf<T[Acc['length'] & keyof T], P>]>;
+type OptionalSlots<T extends readonly unknown[], P extends [unknown]> = DropRequired<OptionalCandidates<T, P, TotalArity<T>>, RequiredArity<T>>;
+type OptionalCandidates<T, P extends [unknown], Stop extends unknown[], Acc extends unknown[] = []> = Acc['length'] extends Stop['length'] ? Acc : OptionalCandidates<T, P, Stop, [...Acc, SubstituteSelf<NonNullable<T[Acc['length'] & keyof T]>, P>]>;
+type DropRequired<All extends unknown[], Skip extends unknown[]> = Skip['length'] extends 0 ? All : All extends [unknown, ...infer Rest] ? Skip extends [unknown, ...infer SkipRest] ? DropRequired<Rest, SkipRest extends unknown[] ? SkipRest : []> : All : [];
+export type Recursive<Body> = SubstituteSelf<Body, [Recursive<Body>]>;
+//# sourceMappingURL=static.d.ts.map

package/dist/builders/static.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=static.js.map

package/dist/builders/static.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.js","sourceRoot":"","sources":["../../src/builders/static.ts"],"names":[],"mappings":""}

package/dist/builders/utility.d.ts

@@ -0,0 +1,13 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+export declare function partial<T>(model: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<Partial<T>>): RunType<Partial<T>>;
+export declare function required<T>(model: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<Required<T>>): RunType<Required<T>>;
+export declare function readonlyType<T>(model: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<Readonly<T>>): RunType<Readonly<T>>;
+export declare function nonNullable<T>(rt: CompTimeArgs<RunType<T>>, id?: InjectRunTypeId<NonNullable<T>>): RunType<NonNullable<T>>;
+export declare function returnType<F extends (...args: any[]) => any>(fnRt: CompTimeArgs<RunType<F>>, id?: InjectRunTypeId<ReturnType<F>>): RunType<ReturnType<F>>;
+export declare function pick<T, const K extends readonly (keyof T)[]>(model: CompTimeArgs<RunType<T>>, keys: CompTimeArgs<K>, id?: InjectRunTypeId<Pick<T, K[number]>>): RunType<Pick<T, K[number]>>;
+export declare function omit<T, const K extends readonly (keyof T)[]>(model: CompTimeArgs<RunType<T>>, keys: CompTimeArgs<K>, id?: InjectRunTypeId<Omit<T, K[number]>>): RunType<Omit<T, K[number]>>;
+export declare function exclude<U, X>(union: CompTimeArgs<RunType<U>>, removed: CompTimeArgs<RunType<X>>, id?: InjectRunTypeId<Exclude<U, X>>): RunType<Exclude<U, X>>;
+export declare function extract<U, X>(union: CompTimeArgs<RunType<U>>, extracted: CompTimeArgs<RunType<X>>, id?: InjectRunTypeId<Extract<U, X>>): RunType<Extract<U, X>>;
+export declare function parameters<F extends (...args: any[]) => any>(fnRt: CompTimeArgs<RunType<F>>, id?: InjectRunTypeId<Parameters<F>>): RunType<Parameters<F>>;
+//# sourceMappingURL=utility.d.ts.map

package/dist/builders/utility.js

@@ -0,0 +1,32 @@
+import { builderResult } from '../runtypes/builderCore.js';
+export function partial(model, id) {
+    return builderResult(id, { type: 'partial', child: model });
+}
+export function required(model, id) {
+    return builderResult(id, { type: 'required', child: model });
+}
+export function readonlyType(model, id) {
+    return builderResult(id, { type: 'readonly', child: model });
+}
+export function nonNullable(rt, id) {
+    return builderResult(id, { type: 'nonNullable', child: rt });
+}
+export function returnType(fnRt, id) {
+    return builderResult(id, { type: 'returnType', child: fnRt });
+}
+export function pick(model, keys, id) {
+    return builderResult(id, { type: 'pick', child: model, keys });
+}
+export function omit(model, keys, id) {
+    return builderResult(id, { type: 'omit', child: model, keys });
+}
+export function exclude(union, removed, id) {
+    return builderResult(id, { type: 'exclude', child: union, excluded: removed });
+}
+export function extract(union, extracted, id) {
+    return builderResult(id, { type: 'extract', child: union, extracted });
+}
+export function parameters(fnRt, id) {
+    return builderResult(id, { type: 'parameters', child: fnRt });
+}
+//# sourceMappingURL=utility.js.map