runtypex 0.1.12 → 0.2.0

package/README.md

@@ -1,69 +1,112 @@
-# 🛡️ runtypex
-
-Runtime type guards compiled from your TypeScript types.  
-No schemas. No decorators. Just types → blazing-fast runtime checks.
-
-
-## Use
-```ts
-import { makeValidate, makeAssert } from "runtypex";
-
-interface User { id: number; name: string; active: boolean; }
-
-const isUser = makeValidate<User>();
-const assertUser: ReturnType<typeof makeAssert<User>> = makeAssert<User>();
-
-isUser({ id: 1, name: "Lux", active: true });  // true
-assertUser({ id: "bad" });                      // throws
-toUser({ nope: true });                         // → fallback
-```
-
-## Vite
-```ts
-// vite.config.ts
-import { defineConfig } from "vite";
-import { vitePlugin as runtypex } from "runtypex";
-
-export default defineConfig({
-  plugins: [runtypex()],
-});
-```
-
-To disable runtime checks in production builds, pass the option `{ removeInProd: true }` when initializing the Vite plugin.
-```ts
-// vite.config.ts
-import { defineConfig } from "vite";
-import { vitePlugin as runtypex } from "runtypex";
-
-export default defineConfig({
-  plugins: [runtypex({ removeInProd: true })],
-});
-```
-
-## Webpack (ts-loader)
-```js
-// webpack.config.js
-const { tsTransformer } = require("runtypex/dist/ts-transformer.js");
-
-module.exports = {
-  module: {
-    rules: [
-      {
-        test: /\.tsx?$/,
-        loader: "ts-loader",
-        options: {
-          getCustomTransformers: (program) => ({
-            before: [ tsTransformer({ program }) ]
-          })
-        }
-      }
-    ]
-  }
-}
-```
-
-## Why runtypex?
-- ⚡ **Fast**: compiled checks, no runtime schema walk
-- 🧩 **Simple**: types only, no schema duplication
-- 🧱 **Flexible**: Vite or Webpack
-- 🛠️ **APIs**: `makeValidate`, `makeAssert`
+# runtypex
+
+`runtypex` generates runtime validation and mapping code from TypeScript types.
+It keeps TypeScript types as the source of truth, so you do not need to maintain
+a separate schema just to validate data at runtime.
+
+## What It Solves
+
+TypeScript types disappear after compilation. That means data from APIs,
+databases, files, or external modules can still be invalid at runtime even when
+the consuming code is type-safe at build time.
+
+`runtypex` closes that gap by using the TypeScript compiler API to generate
+runtime guards and mappers during build.
+
+## Install
+
+```bash
+npm i runtypex
+```
+
+## Quick Start
+
+```ts
+import { makeAssert, makeValidate } from "runtypex";
+
+interface User {
+  id: number;
+  name: string;
+  active: boolean;
+}
+
+const isUser = makeValidate<User>();
+const assertUser = makeAssert<User>();
+
+isUser({ id: 1, name: "Lux", active: true }); // true
+assertUser({ id: "bad" }); // throws
+```
+
+## Vite Setup
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { vitePlugin as runtypex } from "runtypex";
+
+export default defineConfig({
+  plugins: [runtypex()],
+});
+```
+
+To replace validators with no-op functions in production builds:
+
+```ts
+export default defineConfig({
+  plugins: [runtypex({ removeInProd: true })],
+});
+```
+
+## Feature Docs
+
+| Feature | Description |
+| --- | --- |
+| [Runtime validation](docs/runtime-validation.md) | Generate `makeValidate<T>()` and `makeAssert<T>()` implementations from TypeScript types. |
+| [Mapper](docs/mapper.md) | Convert DTO shapes into domain shapes with typed mapping specs. |
+| [Mapping policy](docs/mapping-policy.md) | Keep DTO path to domain field names consistent across multiple mappers. |
+| [JSDoc generation](docs/jsdoc-generation.md) | Generate field documentation from mapper metadata. |
+| [Build integrations](docs/build-integrations.md) | Configure Vite, ts-loader, ESM exports, and build behavior. |
+
+## Mapper Example
+
+```ts
+import { defineMap, makeMapper, source, transform } from "runtypex/mapper";
+
+interface UserDto {
+  user_id: string;
+  profile: { name: string };
+  status: "ACTIVE" | "INACTIVE";
+}
+
+interface User {
+  id: string;
+  displayName: string;
+  isActive: boolean;
+}
+
+const userMap = defineMap<UserDto, User>()({
+  id: source("user_id", {
+    db: "users.user_id",
+    description: "User id",
+    dtoDescription: "User identifier from the user DTO.",
+  }),
+  displayName: source("profile.name"),
+  isActive: transform("status", (value) => value === "ACTIVE"),
+});
+
+const toUser = makeMapper<UserDto, User>(userMap);
+```
+
+## Why runtypex?
+
+| Goal | How runtypex handles it |
+| --- | --- |
+| Avoid schema duplication | Runtime code is generated from TypeScript types. |
+| Validate external data | Generated guards check values after compilation. |
+| Keep DTO and domain mapping explicit | Mapper specs make field movement visible and typed. |
+| Reduce runtime overhead | Build-time generation avoids dynamic schema parsing. |
+
+## Demo
+
+[runtypex-demo](https://github.com/KumJungMin/runtypex-demo) shows TypeScript
+types being transformed into runtime guards during build.

package/dist/cjs/core/emitArrayOrTuple.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles array (T[]) and tuple ([A, B]) types.
+ */
+export declare function emitArrayOrTuple(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitArrayOrTuple.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitArrayOrTuple = emitArrayOrTuple;
+/**
+ * Handles array (T[]) and tuple ([A, B]) types.
+ */
+function emitArrayOrTuple(ctx, expr, t) {
+    if (ctx.checker.isTupleType(t)) {
+        return _emitTuple(t, expr, ctx);
+    }
+    if (ctx.checker.isArrayType(t)) {
+        return _emitArray(ctx, expr, t);
+    }
+    return null;
+}
+/**
+ * Generate validation for Array<T>
+ */
+function _emitArray(ctx, expr, t) {
+    const arrayCheck = `Array.isArray(${expr})`;
+    // Try extracting element type
+    const element = ctx.checker.getElementTypeOfArrayType?.(t) ||
+        t.typeArguments?.[0] ||
+        t.getNumberIndexType?.();
+    if (!element)
+        return arrayCheck;
+    const eachCheck = `${expr}.every(e=>${ctx.emit("e", element)})`;
+    return `(${arrayCheck}&&${eachCheck})`;
+}
+/**
+ * Generate validation for Tuple [A, B, ...]
+ */
+function _emitTuple(ref, expr, ctx) {
+    const elements = ref.typeArguments ?? ctx.checker.getTypeArguments?.(ref) ?? [];
+    const arrayCheck = `Array.isArray(${expr})`;
+    const lenCheck = `${expr}.length===${elements.length}`;
+    const elementChecks = elements.map((el, i) => ctx.emit(`${expr}[${i}]`, el));
+    const parts = [arrayCheck, lenCheck, ...elementChecks];
+    return `(${parts.join("&&")})`;
+}

package/dist/cjs/core/emitLiteralOrEnum.d.ts

@@ -0,0 +1,4 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/** Handles literal types and enum-like types. */
+export declare function emitLiteralOrEnum(_: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitLiteralOrEnum.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitLiteralOrEnum = emitLiteralOrEnum;
+const typescript_1 = __importDefault(require("typescript"));
+/** Handles literal types and enum-like types. */
+function emitLiteralOrEnum(_, expr, t) {
+    if (t.isLiteral()) {
+        const value = t.value;
+        const isString = typeof value === "string";
+        const newValue = isString ? JSON.stringify(value) : String(value);
+        return `${expr}===${newValue}`;
+    }
+    const isEnum = t.flags & typescript_1.default.TypeFlags.EnumLike;
+    if (isEnum) {
+        const enumValues = _extractEnumValues(t);
+        if (enumValues.length) {
+            return `(${enumValues.map(v => `${expr}===${v}`).join("||")})`;
+        }
+    }
+    return null;
+}
+// Extracts numeric or string values from an Enum declaration.
+function _extractEnumValues(t) {
+    const symbol = t.getSymbol();
+    if (!symbol)
+        return [];
+    const values = [];
+    const declarations = symbol.getDeclarations() ?? [];
+    for (const declaration of declarations) {
+        const isEnum = typescript_1.default.isEnumDeclaration(declaration);
+        if (!isEnum)
+            continue;
+        for (const member of declaration.members) {
+            const init = member.initializer;
+            if (!init)
+                continue;
+            if (typescript_1.default.isStringLiteral(init) || typescript_1.default.isNumericLiteral(init)) {
+                const value = typescript_1.default.isStringLiteral(init) ? JSON.stringify(init.text) : init.text;
+                values.push(value);
+            }
+        }
+    }
+    return values;
+}

package/dist/cjs/core/emitMapperFromSpec.d.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+export type MapperEmitOptions = {
+    validateDto?: boolean;
+    validateDomain?: boolean;
+    mappingPolicy?: ts.Expression;
+    policyMode?: "warn" | "error";
+};
+export type MapRuleInfo = {
+    key: string;
+    from: string;
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+};
+export declare function emitMapperFromSpec(params: {
+    checker: ts.TypeChecker;
+    dtoType: ts.Type;
+    domainType: ts.Type;
+    specNode: ts.Expression;
+    sourceFile: ts.SourceFile;
+    options?: MapperEmitOptions;
+}): string | null;
+export declare function readMapRules(checker: ts.TypeChecker, specNode: ts.Expression): Map<string, MapRuleInfo>;
+export type MapPolicyViolation = {
+    from: string;
+    expectedKey: string;
+    actualKey: string;
+};
+export declare function findMapPolicyViolations(checker: ts.TypeChecker, specNode: ts.Expression, policyNode: ts.Expression | undefined): MapPolicyViolation[];
+export declare function handleMapPolicyViolations(violations: MapPolicyViolation[], mode: "warn" | "error"): void;
+/** Finds the mapping object behind inline, defineMap-wrapped, or identifier specs. */
+export declare function resolveMapSpecObject(checker: ts.TypeChecker, node: ts.Expression): ts.ObjectLiteralExpression | null;

package/dist/cjs/core/emitMapperFromSpec.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitMapperFromSpec = emitMapperFromSpec;
+exports.readMapRules = readMapRules;
+exports.findMapPolicyViolations = findMapPolicyViolations;
+exports.handleMapPolicyViolations = handleMapPolicyViolations;
+exports.resolveMapSpecObject = resolveMapSpecObject;
+const typescript_1 = __importDefault(require("typescript"));
+const index_js_1 = require("./index.js");
+const path_js_1 = require("./path.js");
+function emitMapperFromSpec(params) {
+    // Resolve the concrete object literal so generated code does not retain DSL calls.
+    const specObject = resolveMapSpecObject(params.checker, params.specNode);
+    if (!specObject)
+        return null;
+    handleMapPolicyViolations(findMapPolicyViolations(params.checker, specObject, params.options?.mappingPolicy), params.options?.policyMode ?? "warn");
+    const rules = readMapRules(params.checker, specObject);
+    const props = params.checker.getPropertiesOfType(params.domainType);
+    const fields = [];
+    for (const prop of props) {
+        const rule = rules.get(prop.name);
+        if (!rule)
+            return null;
+        fields.push(`${JSON.stringify(prop.name)}:R(${JSON.stringify(prop.name)},${(0, path_js_1.emitPathAccess)("input", rule.from)})`);
+    }
+    const specText = _emitRuntimeSpecText(specObject, params.sourceFile);
+    const dtoGuard = params.options?.validateDto === false ? null : (0, index_js_1.emitGuardFromType)(params.checker, params.dtoType);
+    const domainGuard = params.options?.validateDomain === false ? null : (0, index_js_1.emitGuardFromType)(params.checker, params.domainType);
+    return [
+        `(function(){const S=${specText};`,
+        dtoGuard ? `const VD=${dtoGuard};` : "",
+        domainGuard ? `const VO=${domainGuard};` : "",
+        `return(input)=>{`,
+        dtoGuard ? `if(!VD(input))throw new TypeError("[runtypex] DTO validation failed.");` : "",
+        `const R=(key,raw)=>{const rule=S[key];const value=raw===undefined&&Object.prototype.hasOwnProperty.call(rule,"default")?rule.default:raw;return typeof rule.transform==="function"?rule.transform(value,input):value;};`,
+        `const output={${fields.join(",")}};`,
+        domainGuard ? `if(!VO(output))throw new TypeError("[runtypex] Domain validation failed.");` : "",
+        `return output;};})()`,
+    ].join("");
+}
+function readMapRules(checker, specNode) {
+    const object = resolveMapSpecObject(checker, specNode);
+    const rules = new Map();
+    if (!object)
+        return rules;
+    for (const prop of object.properties) {
+        if (!typescript_1.default.isPropertyAssignment(prop))
+            continue;
+        const key = _propertyName(prop.name);
+        const rule = _readRule(prop.initializer);
+        if (key && rule)
+            rules.set(key, { key, ...rule });
+    }
+    return rules;
+}
+function findMapPolicyViolations(checker, specNode, policyNode) {
+    if (!policyNode)
+        return [];
+    const rules = readMapRules(checker, specNode);
+    const policyRules = readMapRules(checker, policyNode);
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const rule of policyRules.values()) {
+        const existing = canonicalByPath.get(rule.from);
+        if (existing && existing !== rule.key) {
+            violations.push({ from: rule.from, expectedKey: existing, actualKey: rule.key });
+            continue;
+        }
+        canonicalByPath.set(rule.from, rule.key);
+    }
+    violations.push(...Array.from(rules.values()).flatMap((rule) => {
+        const expected = canonicalByPath.get(rule.from);
+        return expected && expected !== rule.key
+            ? [{ from: rule.from, expectedKey: expected, actualKey: rule.key }]
+            : [];
+    }));
+    return violations;
+}
+function handleMapPolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const details = violations
+        .map((item) => `DTO path "${item.from}" is canonically mapped as "${item.expectedKey}", but this map uses "${item.actualKey}".`)
+        .join("\n");
+    const message = `[runtypex/mapper] Mapping policy violation:\n${details}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}
+/** Finds the mapping object behind inline, defineMap-wrapped, or identifier specs. */
+function resolveMapSpecObject(checker, node) {
+    const expr = _skip(node);
+    if (typescript_1.default.isObjectLiteralExpression(expr))
+        return expr;
+    if (typescript_1.default.isCallExpression(expr) && expr.arguments[0]) {
+        const arg = _skip(expr.arguments[0]);
+        if (typescript_1.default.isObjectLiteralExpression(arg))
+            return arg;
+    }
+    if (typescript_1.default.isCallExpression(expr) && typescript_1.default.isCallExpression(expr.expression)) {
+        return resolveMapSpecObject(checker, expr.expression);
+    }
+    if (typescript_1.default.isIdentifier(expr)) {
+        const symbol = checker.getShorthandAssignmentValueSymbol?.(expr) ?? checker.getSymbolAtLocation(expr);
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        if (declaration && typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer) {
+            return resolveMapSpecObject(checker, declaration.initializer);
+        }
+        const variable = _findVariableDeclaration(expr.getSourceFile(), expr.text, expr.getStart(expr.getSourceFile()));
+        if (variable?.initializer)
+            return resolveMapSpecObject(checker, variable.initializer);
+    }
+    return null;
+}
+function _readRule(node) {
+    const expr = _skip(node);
+    if (typescript_1.default.isObjectLiteralExpression(expr)) {
+        return _readRuleObject(expr);
+    }
+    if (typescript_1.default.isCallExpression(expr) && expr.arguments[0]) {
+        const from = _stringValue(expr.arguments[0]);
+        const metadata = expr.arguments.length > 2 ? expr.arguments[2] : expr.arguments[1];
+        if (!from)
+            return null;
+        return { from, ..._readMetadata(metadata) };
+    }
+    return null;
+}
+function _readRuleObject(object) {
+    const from = _readStringProperty(object, "from");
+    if (!from)
+        return null;
+    return {
+        from,
+        db: _readStringProperty(object, "db") ?? undefined,
+        description: _readStringProperty(object, "description") ?? undefined,
+        dtoDescription: _readStringProperty(object, "dtoDescription") ?? undefined,
+    };
+}
+function _readMetadata(node) {
+    const expr = node ? _skip(node) : null;
+    if (!expr || !typescript_1.default.isObjectLiteralExpression(expr))
+        return {};
+    return {
+        db: _readStringProperty(expr, "db") ?? undefined,
+        description: _readStringProperty(expr, "description") ?? undefined,
+        dtoDescription: _readStringProperty(expr, "dtoDescription") ?? undefined,
+    };
+}
+function _readStringProperty(object, name) {
+    const prop = object.properties.find((item) => typescript_1.default.isPropertyAssignment(item) && _propertyName(item.name) === name);
+    return prop ? _stringValue(prop.initializer) : null;
+}
+function _skip(node) {
+    let expr = node;
+    while (typescript_1.default.isParenthesizedExpression(expr) || typescript_1.default.isAsExpression(expr) || typescript_1.default.isTypeAssertionExpression(expr)) {
+        expr = expr.expression;
+    }
+    return expr;
+}
+function _propertyName(name) {
+    if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name))
+        return name.text;
+    return null;
+}
+function _stringValue(node) {
+    if (typescript_1.default.isStringLiteral(node) || typescript_1.default.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    return null;
+}
+function _findVariableDeclaration(sourceFile, name, before) {
+    let found = null;
+    const visit = (node) => {
+        if (typescript_1.default.isVariableDeclaration(node) &&
+            typescript_1.default.isIdentifier(node.name) &&
+            node.name.text === name &&
+            node.getStart(sourceFile) < before) {
+            found = node;
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function _emitRuntimeSpecText(specObject, sourceFile) {
+    // Remove TypeScript-only syntax from inline transform callbacks before embedding.
+    const marker = "__runtypexSpec";
+    const output = typescript_1.default.transpileModule(`const ${marker} = ${specObject.getText(sourceFile)};`, {
+        compilerOptions: {
+            module: typescript_1.default.ModuleKind.ESNext,
+            target: typescript_1.default.ScriptTarget.ESNext,
+        },
+    }).outputText.trim();
+    const prefix = `const ${marker} = `;
+    return output.startsWith(prefix) ? output.slice(prefix.length).replace(/;$/, "") : specObject.getText(sourceFile);
+}

package/dist/cjs/core/emitObject.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles interfaces, classes, and object-like structures.
+ */
+export declare function emitObject(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitObject.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitObject = emitObject;
+const typescript_1 = __importDefault(require("typescript"));
+const path_js_1 = require("./path.js");
+/**
+ * Handles interfaces, classes, and object-like structures.
+ */
+function emitObject(ctx, expr, t) {
+    const isObject = (t.getFlags() & typescript_1.default.TypeFlags.Object) !== 0;
+    if (!isObject)
+        return null;
+    const props = ctx.checker.getPropertiesOfType(t);
+    const parts = [`typeof ${expr}==="object"`, `${expr}!==null`];
+    for (const prop of props) {
+        const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+        if (!declaration)
+            continue;
+        const propType = ctx.checker.getTypeOfSymbolAtLocation(prop, declaration);
+        const isOptional = (prop.getFlags() & typescript_1.default.SymbolFlags.Optional) !== 0;
+        const propExpr = (0, path_js_1.emitPropertyAccess)(expr, prop.name);
+        const condition = ctx.emit(propExpr, propType);
+        const checkExpr = isOptional ? `(${propExpr}===undefined||${condition})` : condition;
+        parts.push(checkExpr);
+    }
+    return `(${parts.join("&&")})`;
+}

package/dist/cjs/core/emitPrimitive.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles primitive types like number, string, boolean...
+ */
+export declare function emitPrimitive(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitPrimitive.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPrimitive = emitPrimitive;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Handles primitive types like number, string, boolean...
+ */
+function emitPrimitive(ctx, expr, t) {
+    if ((t.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown)) !== 0)
+        return "true";
+    if (t.flags & typescript_1.default.TypeFlags.Null)
+        return `${expr}===null`;
+    if (t.flags & typescript_1.default.TypeFlags.Undefined)
+        return `${expr}===undefined`;
+    if (t.flags & typescript_1.default.TypeFlags.BooleanLike)
+        return `typeof ${expr}==="boolean"`;
+    if (t.flags & typescript_1.default.TypeFlags.NumberLike)
+        return `typeof ${expr}==="number"`;
+    if (t.flags & typescript_1.default.TypeFlags.StringLike)
+        return `typeof ${expr}==="string"`;
+    if (t.flags & typescript_1.default.TypeFlags.BigIntLike)
+        return `typeof ${expr}==="bigint"`;
+    if (t.flags & typescript_1.default.TypeFlags.ESSymbolLike)
+        return `typeof ${expr}==="symbol"`;
+    return null;
+}

package/dist/cjs/core/emitUnionOrIntersection.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles union (A | B) and intersection (A & B) types.
+ */
+export declare function emitUnionOrIntersection(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitUnionOrIntersection.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitUnionOrIntersection = emitUnionOrIntersection;
+/**
+ * Handles union (A | B) and intersection (A & B) types.
+ */
+function emitUnionOrIntersection(ctx, expr, t) {
+    if (t.isUnion()) {
+        return `(${t.types.map(tt => ctx.emit(expr, tt)).join("||")})`;
+    }
+    if (t.isIntersection()) {
+        return `(${t.types.map(tt => ctx.emit(expr, tt)).join("&&")})`;
+    }
+    return null;
+}

package/dist/cjs/core/index.d.ts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+/**
+ * ✅ emitGuardFromType
+ * Converts a TypeScript type to a JavaScript runtime validation function string.
+ */
+export declare function emitGuardFromType(checker: ts.TypeChecker, type: ts.Type): string;
+/**
+ * ✅ GenContext
+ * Internal helper for converting TypeScript types to JS validation expressions.
+ */
+export declare class GenContext {
+    checker: ts.TypeChecker;
+    private seen;
+    constructor(checker: ts.TypeChecker);
+    /** Top-level router — delegates each type to the correct handler. */
+    emit(expr: string, t: ts.Type): string;
+}