runtypex 0.1.12 → 0.2.0

package/dist/esm/runtime/mapper.d.ts

@@ -0,0 +1,71 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+export type PathOf<T> = T extends Primitive ? never : T extends readonly (infer U)[] ? `${number}` | `${number}.${PathOf<U>}` : {
+    [K in Extract<keyof T, string>]: T[K] extends Primitive ? K : T[K] extends readonly (infer U)[] ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U>}` : K | `${K}.${PathOf<T[K]>}`;
+}[Extract<keyof T, string>];
+export type Mapper<TDto, TDomain> = (dto: TDto) => TDomain;
+export type MapperMetadata<TValue = never> = {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue;
+};
+export type MapRule<TDto, TValue> = MapperMetadata<TValue> & {
+    from: PathOf<TDto>;
+    transform?: (value: unknown, dto: TDto) => TValue;
+};
+export type MapSpec<TDto, TDomain> = {
+    [K in keyof TDomain]-?: MapRule<TDto, TDomain[K]>;
+};
+export type MappingPolicy<TDto> = Record<string, MapRule<TDto, unknown>>;
+export type MappingPolicyMode = "warn" | "error";
+export type MapperOptions<TDto> = {
+    policy?: MappingPolicy<TDto>;
+    policyMode?: MappingPolicyMode;
+};
+declare const DTO_TYPE: unique symbol;
+declare const DOMAIN_TYPE: unique symbol;
+export type DefinedMap<TDto, TDomain> = MapSpec<TDto, TDomain> & {
+    readonly [DTO_TYPE]?: TDto;
+    readonly [DOMAIN_TYPE]?: TDomain;
+};
+export declare function defineMap<TDto, TDomain>(): <const TSpec extends MapSpec<TDto, TDomain>>(spec: TSpec) => TSpec & DefinedMap<TDto, TDomain>;
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+export declare function defineMappingPolicy<TDto>(): <const TSpec extends MappingPolicy<TDto>>(spec: TSpec) => TSpec;
+/** Shorthand rule for direct DTO path reads. */
+export declare function source<const TPath extends string, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+};
+/** Shorthand rule for DTO path reads that require a value conversion. */
+export declare function transform<const TPath extends string, TValue>(from: TPath, transform: (value: unknown, dto: unknown) => TValue, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+    transform: (value: unknown, dto: unknown) => TValue;
+};
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+export declare function mapperHelpers<TDto>(): {
+    source: <const TPath extends PathOf<TDto>, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+    };
+    transform: <const TPath extends PathOf<TDto>, TValue>(from: TPath, transform: (value: unknown, dto: TDto) => TValue, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+        transform: (value: unknown, dto: TDto) => TValue;
+    };
+};
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+export declare function makeMapper<TDto, TDomain>(spec: DefinedMap<TDto, TDomain> | MapSpec<TDto, TDomain>, options?: MapperOptions<TDto>): Mapper<TDto, TDomain>;
+export {};

package/dist/esm/runtime/mapper.js

@@ -0,0 +1,71 @@
+import { getByPath } from "../core/path.js";
+export function defineMap() {
+    return (spec) => spec;
+}
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+export function defineMappingPolicy() {
+    return (spec) => spec;
+}
+/** Shorthand rule for direct DTO path reads. */
+export function source(from, metadata) {
+    return { from, ...metadata };
+}
+/** Shorthand rule for DTO path reads that require a value conversion. */
+export function transform(from, transform, metadata) {
+    return { from, transform, ...metadata };
+}
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+export function mapperHelpers() {
+    return {
+        source: (from, metadata) => source(from, metadata),
+        transform: (from, transform, metadata) => ({ from, transform, ...metadata }),
+    };
+}
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+export function makeMapper(spec, options) {
+    _handlePolicyViolations(_findPolicyViolations(spec, options?.policy), options?.policyMode ?? "warn");
+    return ((dto) => {
+        const output = {};
+        for (const key of Object.keys(spec)) {
+            const rule = spec[key];
+            const raw = getByPath(dto, String(rule.from));
+            const value = raw === undefined && _hasOwn(rule, "default") ? rule.default : raw;
+            output[key] = rule.transform ? rule.transform(value, dto) : value;
+        }
+        return output;
+    });
+}
+function _hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function _findPolicyViolations(spec, policy) {
+    if (!policy)
+        return [];
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const key of Object.keys(policy)) {
+        const from = String(policy[key].from);
+        const existing = canonicalByPath.get(from);
+        if (existing && existing !== key) {
+            violations.push(`DTO path "${from}" is canonically mapped as "${existing}", but this map uses "${key}".`);
+            continue;
+        }
+        canonicalByPath.set(from, key);
+    }
+    violations.push(...Object.keys(spec).flatMap((key) => {
+        const from = String(spec[key].from);
+        const expected = canonicalByPath.get(from);
+        return expected && expected !== key
+            ? [`DTO path "${from}" is canonically mapped as "${expected}", but this map uses "${key}".`]
+            : [];
+    }));
+    return violations;
+}
+function _handlePolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const message = `[runtypex/mapper] Mapping policy violation:\n${violations.join("\n")}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}

package/dist/esm/transformer/helper.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function resolveTypeByName(program: ts.Program, sf: ts.SourceFile, checker: ts.TypeChecker, name: string): ts.Type | null;

package/dist/esm/transformer/helper.js

@@ -0,0 +1,57 @@
+import ts from "typescript";
+export function resolveTypeByName(program, sf, checker, name) {
+    // -1️⃣ Primitive type fallback
+    const primitiveNames = ["string", "number", "boolean", "bigint", "symbol", "null", "undefined"];
+    if (primitiveNames.includes(name)) {
+        const map = {
+            string: checker.getStringType(),
+            number: checker.getNumberType(),
+            boolean: checker.getBooleanType(),
+            bigint: checker.getBigIntType(),
+            symbol: checker.getESSymbolType(),
+            null: checker.getNullType(),
+            undefined: checker.getUndefinedType(),
+        };
+        return map[name];
+    }
+    // 2️⃣ Scan source files
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        // ✅ type, interface, enum, class
+        if (ts.isInterfaceDeclaration(decl) ||
+            ts.isClassDeclaration(decl) ||
+            ts.isEnumDeclaration(decl)) {
+            if (decl.name) {
+                const symbol = checker.getSymbolAtLocation(decl.name);
+                if (symbol)
+                    return checker.getDeclaredTypeOfSymbol(symbol);
+            }
+        }
+        if (ts.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    // 3️⃣ Scope-based fallback
+    const symbol = checker
+        .getSymbolsInScope(sf, ts.SymbolFlags.Type | ts.SymbolFlags.Alias | ts.SymbolFlags.Interface)
+        .find((s) => s.name === name);
+    return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+}
+function _findLocalDeclaration(sf, name) {
+    let found;
+    (function walk(node) {
+        if ((ts.isInterfaceDeclaration(node) ||
+            ts.isTypeAliasDeclaration(node) ||
+            ts.isEnumDeclaration(node) ||
+            ts.isClassDeclaration(node)) &&
+            node.name?.text === name) {
+            found = node;
+            return;
+        }
+        if (!found)
+            node.forEachChild(walk);
+    })(sf);
+    return found;
+}

package/dist/esm/transformer/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./ts-transformer.js";
+export { default as tsTransformer } from "./ts-transformer.js";
+export { default as vitePlugin } from "./vite-plugin.js";

package/dist/esm/transformer/index.js

@@ -0,0 +1,3 @@
+export { default } from "./ts-transformer.js";
+export { default as tsTransformer } from "./ts-transformer.js";
+export { default as vitePlugin } from "./vite-plugin.js";

package/dist/esm/transformer/ts-transformer.d.ts

@@ -1,4 +1,10 @@
 import ts from "typescript";
+type TransformerOptions = {
+    program: ts.Program;
+    removeInProd?: boolean;
+    validateDto?: boolean;
+    validateDomain?: boolean;
+};
 /**
  * 🧩 tsTransformer
  * TypeScript custom transformer (BEFORE) factory.
@@ -19,7 +25,5 @@ import ts from "typescript";
  *   ✅ Validation logic embedded at build-time
  *   ✅ Optionally removed in production builds
  */
-export default function tsTransformer(options: {
-    program: ts.Program;
-    removeInProd?: boolean;
-}): (context: ts.TransformationContext) => (sf: ts.SourceFile) => ts.Node | undefined;
+export default function tsTransformer(options: TransformerOptions): ts.TransformerFactory<ts.SourceFile>;
+export {};

package/dist/esm/transformer/ts-transformer.js

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import { emitGuardFromType } from "../core/index.js";
+import { emitMapperFromSpec } from "../core/emitMapperFromSpec.js";
 /**
  * 🧩 tsTransformer
  * TypeScript custom transformer (BEFORE) factory.
@@ -21,7 +22,6 @@ import { emitGuardFromType } from "../core/index.js";
  *   ✅ Optionally removed in production builds
  */
 export default function tsTransformer(options) {
-    const { program } = options;
     const checker = options.program.getTypeChecker();
     const removeInProd = !!options.removeInProd;
     const prod = process.env.NODE_ENV === "production";
@@ -29,13 +29,8 @@ export default function tsTransformer(options) {
         const visit = (node) => {
             if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
                 const name = node.expression.text;
-                const targetFunctions = ["makeValidate", "makeAssert"];
-                if (targetFunctions.includes(name) && node.typeArguments?.length) {
-                    const typeNode = node.typeArguments[0];
-                    const typeName = typeNode.getText();
-                    const type = _resolveTypeByName(program, node.getSourceFile(), checker, typeName);
-                    if (!type)
-                        return node;
+                if ((name === "makeValidate" || name === "makeAssert") && node.typeArguments?.length) {
+                    const type = checker.getTypeFromTypeNode(node.typeArguments[0]);
                     const isRemovedInProd = removeInProd && prod;
                     switch (name) {
                         case "makeValidate":
@@ -44,69 +39,65 @@ export default function tsTransformer(options) {
                             return _emitMakeAssert(checker, type, isRemovedInProd);
                     }
                 }
+                // makeMapper<TDto, TDomain>(spec) becomes an inline validating mapper.
+                if (name === "makeMapper" && node.typeArguments?.length === 2 && node.arguments[0]) {
+                    const mapperCallOptions = _readMapperCallOptions(node.arguments[1]);
+                    const mapper = emitMapperFromSpec({
+                        checker,
+                        dtoType: checker.getTypeFromTypeNode(node.typeArguments[0]),
+                        domainType: checker.getTypeFromTypeNode(node.typeArguments[1]),
+                        specNode: node.arguments[0],
+                        sourceFile: node.getSourceFile(),
+                        options: {
+                            validateDto: !(removeInProd && prod) && options.validateDto !== false,
+                            validateDomain: !(removeInProd && prod) && options.validateDomain !== false,
+                            mappingPolicy: mapperCallOptions.policy,
+                            policyMode: mapperCallOptions.policyMode,
+                        },
+                    });
+                    if (mapper)
+                        return ts.factory.createIdentifier(mapper);
+                }
             }
             return ts.visitEachChild(node, visit, context);
         };
         return (sf) => ts.visitNode(sf, visit);
     };
 }
-function _resolveTypeByName(program, sf, checker, name) {
-    // 1️⃣ <string|number|boolean|null|undefined>
-    const primitiveNames = ["string", "number", "boolean", "bigint", "symbol", "null", "undefined"];
-    if (primitiveNames.includes(name)) {
-        const map = {
-            string: checker.getStringType(),
-            number: checker.getNumberType(),
-            boolean: checker.getBooleanType(),
-            bigint: checker.getBigIntType(),
-            symbol: checker.getESSymbolType(),
-            null: checker.getNullType(),
-            undefined: checker.getUndefinedType(),
-        };
-        return map[name];
-    }
-    // 2️⃣ <Type|Interface|Enum> declared in the same file or other files
-    for (const file of program.getSourceFiles()) {
-        const decl = _findLocalDeclaration(file, name);
-        if (!decl)
-            continue;
-        if (ts.isInterfaceDeclaration(decl) || ts.isClassDeclaration(decl) || ts.isEnumDeclaration(decl)) {
-            const symbol = decl.name ? checker.getSymbolAtLocation(decl.name) : null;
-            if (symbol)
-                return checker.getDeclaredTypeOfSymbol(symbol);
+function _readMapperCallOptions(node) {
+    if (!node)
+        return {};
+    const expr = ts.isAsExpression(node) || ts.isParenthesizedExpression(node) ? node.expression : node;
+    if (!ts.isObjectLiteralExpression(expr))
+        return {};
+    return {
+        policy: _readExpressionProperty(expr, "policy"),
+        policyMode: _readPolicyMode(expr),
+    };
+}
+function _readExpressionProperty(object, name) {
+    for (const item of object.properties) {
+        if (ts.isPropertyAssignment(item) && ts.isIdentifier(item.name) && item.name.text === name) {
+            return item.initializer;
         }
-        if (ts.isTypeAliasDeclaration(decl)) {
-            return checker.getTypeFromTypeNode(decl.type);
+        if (ts.isShorthandPropertyAssignment(item) && item.name.text === name) {
+            return item.name;
         }
     }
-    // 3️⃣ <Type|Interface|Enum> imported from other modules
-    const symbol = checker
-        .getSymbolsInScope(sf, ts.SymbolFlags.Type | ts.SymbolFlags.Alias | ts.SymbolFlags.Interface)
-        .find((s) => s.name === name);
-    return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+    return undefined;
 }
-function _findLocalDeclaration(sf, name) {
-    let found;
-    (function walk(node) {
-        if ((ts.isInterfaceDeclaration(node) ||
-            ts.isTypeAliasDeclaration(node) ||
-            ts.isEnumDeclaration(node) ||
-            ts.isClassDeclaration(node)) &&
-            node.name?.text === name) {
-            found = node;
-            return;
-        }
-        if (!found)
-            node.forEachChild(walk);
-    })(sf);
-    return found;
+function _readPolicyMode(object) {
+    const mode = _readExpressionProperty(object, "policyMode");
+    return mode && ts.isStringLiteral(mode) && (mode.text === "warn" || mode.text === "error") ? mode.text : undefined;
 }
 function _emitMakeValidate(checker, type, isRemovedInProd) {
     const guard = isRemovedInProd ? "((_)=>true)" : emitGuardFromType(checker, type);
     return ts.factory.createIdentifier(guard);
 }
 function _emitMakeAssert(checker, type, isRemovedInProd) {
-    const guard = isRemovedInProd ? "((_)=>{})" : emitGuardFromType(checker, type);
+    if (isRemovedInProd)
+        return ts.factory.createIdentifier("((_)=>{})");
+    const guard = emitGuardFromType(checker, type);
     const txt = `(function(){const G=${guard};return(i)=>{if(!G(i))throw new TypeError("[runtypex] Validation failed.");};})()`;
     return ts.factory.createIdentifier(txt);
 }

package/dist/esm/transformer/vite-plugin.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import path from "node:path";
-import { emitGuardFromType } from "../core/index.js";
+import tsTransformer from "./ts-transformer.js";
 /**
  * 🧩 vitePluginRuntypex
  * A Vite plugin that performs build-time type → runtime validation transformation.
@@ -17,24 +17,21 @@ import { emitGuardFromType } from "../core/index.js";
  */
 export default function vitePluginRuntypex(options) {
     const removeInProd = !!options?.removeInProd;
-    const prod = process.env.NODE_ENV === "production";
     return {
         name: "vite-plugin-runtypex",
         enforce: "pre",
         transform(code, id) {
             const isTS = id.endsWith(".ts") || id.endsWith(".tsx");
-            const isTargetFunction = /make(?:Validate|Assert)</.test(code);
+            const isTargetFunction = /make(?:Validate|Assert|Mapper)</.test(code);
             if (!isTS || !isTargetFunction)
                 return;
-            const { program, checker } = _createProgramFor(id);
+            const { program } = _createProgramFor(id);
             const sf = program.getSourceFile(id);
             if (!sf)
                 return;
-            let mutated = code;
-            // ① makeAssert<T>()
-            mutated = mutated.replace(/makeAssert<\s*([^>]+)\s*>\s*\(\s*\)/g, (_m, typeName) => _emitMakeAssert({ program, checker, sf, typeName, prod, removeInProd }) ?? _m);
-            // ② makeValidate<T>()
-            mutated = mutated.replace(/makeValidate<\s*([^>]+)\s*>\s*\(\s*\)/g, (_m, typeName) => _emitMakeValidate({ program, checker, sf, typeName, prod, removeInProd }) ?? _m);
+            const result = ts.transform(sf, [tsTransformer({ program, removeInProd })]);
+            const mutated = ts.createPrinter().printFile(result.transformed[0]);
+            result.dispose();
             return mutated === code ? null : { code: mutated, map: null };
         },
     };
@@ -49,8 +46,7 @@ function _createProgramFor(file) {
         throw new Error(ts.flattenDiagnosticMessageText(cfg.error.messageText, "\n"));
     const parsed = ts.parseJsonConfigFileContent(cfg.config, ts.sys, path.dirname(tsconfig));
     const program = ts.createProgram({ rootNames: parsed.fileNames, options: parsed.options });
-    const checker = program.getTypeChecker();
-    return { program, checker };
+    return { program };
 }
 function _findNearestTsconfig(start) {
     let dir = start;
@@ -68,85 +64,3 @@ function _findNearestTsconfig(start) {
         return fallback;
     throw new Error("tsconfig.json not found");
 }
-// ──────────────────────────────────────────────
-// ② Emit Helpers
-// ──────────────────────────────────────────────
-function _emitMakeValidate({ program, checker, sf, typeName, prod, removeInProd, }) {
-    if (removeInProd && prod)
-        return `((_)=>true)`;
-    const type = _resolveTypeByName(program, sf, checker, typeName.trim());
-    if (!type)
-        return null;
-    return emitGuardFromType(checker, type);
-}
-function _emitMakeAssert({ program, checker, sf, typeName, prod, removeInProd, }) {
-    if (removeInProd && prod)
-        return `((_)=>{})`;
-    const type = _resolveTypeByName(program, sf, checker, typeName.trim());
-    if (!type)
-        return null;
-    const guard = emitGuardFromType(checker, type);
-    return `(function(){const G=${guard};return(i)=>{if(!G(i))throw new TypeError("[runtypex] Validation failed.");};})()`;
-}
-// ──────────────────────────────────────────────
-// ③ Type Resolution (support primitive/interface/type/enum)
-// ──────────────────────────────────────────────
-function _resolveTypeByName(program, sf, checker, name) {
-    // -1️⃣ Primitive type fallback
-    const primitiveNames = ["string", "number", "boolean", "bigint", "symbol", "null", "undefined"];
-    if (primitiveNames.includes(name)) {
-        const map = {
-            string: checker.getStringType(),
-            number: checker.getNumberType(),
-            boolean: checker.getBooleanType(),
-            bigint: checker.getBigIntType(),
-            symbol: checker.getESSymbolType(),
-            null: checker.getNullType(),
-            undefined: checker.getUndefinedType(),
-        };
-        return map[name];
-    }
-    // 2️⃣ Scan source files
-    for (const file of program.getSourceFiles()) {
-        const decl = _findLocalDeclaration(file, name);
-        if (!decl)
-            continue;
-        // ✅ type, interface, enum, class
-        if (ts.isInterfaceDeclaration(decl) ||
-            ts.isClassDeclaration(decl) ||
-            ts.isEnumDeclaration(decl)) {
-            if (decl.name) {
-                const symbol = checker.getSymbolAtLocation(decl.name);
-                if (symbol)
-                    return checker.getDeclaredTypeOfSymbol(symbol);
-            }
-        }
-        if (ts.isTypeAliasDeclaration(decl)) {
-            return checker.getTypeFromTypeNode(decl.type);
-        }
-    }
-    // 3️⃣ Scope-based fallback
-    const symbol = checker
-        .getSymbolsInScope(sf, ts.SymbolFlags.Type | ts.SymbolFlags.Alias | ts.SymbolFlags.Interface)
-        .find((s) => s.name === name);
-    return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
-}
-// ──────────────────────────────────────────────
-// ④ AST Utility
-// ──────────────────────────────────────────────
-function _findLocalDeclaration(sf, name) {
-    let found;
-    (function walk(node) {
-        if ((ts.isInterfaceDeclaration(node) ||
-            ts.isTypeAliasDeclaration(node) ||
-            ts.isEnumDeclaration(node) ||
-            ts.isClassDeclaration(node)) &&
-            node.name?.text === name) {
-            found = node;
-            return;
-        }
-        if (!found)
-            node.forEachChild(walk);
-    })(sf);
-    return found;
-}

package/docs/build-integrations.md

@@ -0,0 +1,89 @@
+# Build Integrations
+
+`runtypex` relies on the TypeScript compiler API, so its full value comes from
+running the transformer during build.
+
+## Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { vitePlugin as runtypex } from "runtypex";
+
+export default defineConfig({
+  plugins: [runtypex()],
+});
+```
+
+The Vite plugin scans TypeScript files for:
+
+- `makeValidate<T>()`
+- `makeAssert<T>()`
+- `makeMapper<TDto, TDomain>()`
+
+When a target call is found, the plugin creates a TypeScript program for the
+nearest `tsconfig.json`, runs the transformer, and returns the transformed code
+to Vite.
+
+## ts-loader
+
+```js
+// webpack.config.js
+const { tsTransformer } = require("runtypex");
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        loader: "ts-loader",
+        options: {
+          getCustomTransformers: (program) => ({
+            before: [tsTransformer({ program })],
+          }),
+        },
+      },
+    ],
+  },
+};
+```
+
+## Transformer Options
+
+```ts
+tsTransformer({
+  program,
+  removeInProd: true,
+  validateDto: true,
+  validateDomain: true,
+});
+```
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `program` | required | TypeScript program used to resolve types. |
+| `removeInProd` | `false` | Replaces generated validation with no-op functions in production. |
+| `validateDto` | `true` | Enables DTO input validation for generated mappers. |
+| `validateDomain` | `true` | Enables domain output validation for generated mappers. |
+
+## Package Entry Points
+
+```ts
+import { makeValidate } from "runtypex";
+import { makeMapper } from "runtypex/mapper";
+import { generateJSDocFromSpec } from "runtypex/generator";
+import { tsTransformer } from "runtypex/transformer";
+import { vitePlugin } from "runtypex/transformer/vite-plugin";
+```
+
+The package exports ESM and CommonJS builds from `dist/esm` and `dist/cjs`.
+
+## Local Verification
+
+Useful verification commands:
+
+```bash
+npm run build
+npx jest --runInBand --watchman=false
+npm run test:esm
+```