runtypex 0.1.0

package/README.md

@@ -0,0 +1,69 @@
+# 🛡️ 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`

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

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index";
+/**
+ * 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";
+/** 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/emitObject.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index";
+/**
+ * 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,28 @@
+"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"));
+/**
+ * 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 condition = ctx.emit(`${expr}.${prop.name}`, propType);
+        const checkExpr = isOptional ? `(${expr}.${prop.name}===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";
+/**
+ * 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";
+/**
+ * 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;
+}

package/dist/cjs/core/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenContext = void 0;
+exports.emitGuardFromType = emitGuardFromType;
+const emitPrimitive_1 = require("./emitPrimitive");
+const emitLiteralOrEnum_1 = require("./emitLiteralOrEnum");
+const emitUnionOrIntersection_1 = require("./emitUnionOrIntersection");
+const emitArrayOrTuple_1 = require("./emitArrayOrTuple");
+const emitObject_1 = require("./emitObject");
+/**
+ * ✅ emitGuardFromType
+ * Converts a TypeScript type to a JavaScript runtime validation function string.
+ */
+function emitGuardFromType(checker, type) {
+    const ctx = new GenContext(checker);
+    const condition = ctx.emit("input", type);
+    return `(input)=>${condition}`;
+}
+/**
+ * ✅ GenContext
+ * Internal helper for converting TypeScript types to JS validation expressions.
+ */
+class GenContext {
+    checker;
+    seen = new Map();
+    constructor(checker) {
+        this.checker = checker;
+    }
+    /** Top-level router — delegates each type to the correct handler. */
+    emit(expr, t) {
+        if (this.seen.has(t))
+            return this.seen.get(t);
+        return ((0, emitPrimitive_1.emitPrimitive)(this, expr, t) ??
+            (0, emitLiteralOrEnum_1.emitLiteralOrEnum)(this, expr, t) ??
+            (0, emitUnionOrIntersection_1.emitUnionOrIntersection)(this, expr, t) ??
+            (0, emitArrayOrTuple_1.emitArrayOrTuple)(this, expr, t) ??
+            (0, emitObject_1.emitObject)(this, expr, t) ??
+            "true");
+    }
+}
+exports.GenContext = GenContext;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsTransformer = exports.vitePlugin = exports.makeAssert = exports.makeValidate = void 0;
+var validate_js_1 = require("./runtime/validate.js");
+Object.defineProperty(exports, "makeValidate", { enumerable: true, get: function () { return validate_js_1.makeValidate; } });
+Object.defineProperty(exports, "makeAssert", { enumerable: true, get: function () { return validate_js_1.makeAssert; } });
+var vite_plugin_js_1 = require("./transformer/vite-plugin.js");
+Object.defineProperty(exports, "vitePlugin", { enumerable: true, get: function () { return __importDefault(vite_plugin_js_1).default; } });
+var ts_transformer_js_1 = require("./transformer/ts-transformer.js");
+Object.defineProperty(exports, "tsTransformer", { enumerable: true, get: function () { return __importDefault(ts_transformer_js_1).default; } });

package/dist/cjs/runtime/validate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * runtypex — runtime APIs
+ * 1) makeValidate<T>()  : (v) => v is T
+ * 2) makeAssert<T>()    : throws on invalid
+ *
+ * NOTE: These factories are replaced at build-time by the transformer.
+ */
+export type ValidateFn<T> = (value: unknown) => value is T;
+export declare function makeValidate<T>(): ValidateFn<T>;
+export declare function makeAssert<T>(): (value: unknown) => asserts value is T;

package/dist/cjs/runtime/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValidate = makeValidate;
+exports.makeAssert = makeAssert;
+// Replaced by transformer to generated guard
+function __validate(_value) {
+    throw new Error("[runtypex] makeValidate() was not transformed. Add the plugin/transformer.");
+}
+function makeValidate() {
+    return (value) => __validate(value);
+}
+function makeAssert() {
+    const validate = makeValidate();
+    return (value) => {
+        if (!validate(value))
+            throw new TypeError("[runtypex] Validation failed.");
+    };
+}

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

@@ -0,0 +1,25 @@
+import ts from "typescript";
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ 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;

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

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = tsTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const core_1 = require("../core");
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ Validation logic embedded at build-time
+ *   ✅ Optionally removed in production builds
+ */
+function tsTransformer(options) {
+    const { program } = options;
+    const checker = options.program.getTypeChecker();
+    const removeInProd = !!options.removeInProd;
+    const prod = process.env.NODE_ENV === "production";
+    return (context) => {
+        const visit = (node) => {
+            if (typescript_1.default.isCallExpression(node) && typescript_1.default.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;
+                    const isRemovedInProd = removeInProd && prod;
+                    switch (name) {
+                        case "makeValidate":
+                            return _emitMakeValidate(checker, type, isRemovedInProd);
+                        case "makeAssert":
+                            return _emitMakeAssert(checker, type, isRemovedInProd);
+                    }
+                }
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        };
+        return (sf) => typescript_1.default.visitNode(sf, visit);
+    };
+}
+function _resolveTypeByName(program, sf, checker, name) {
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        if (typescript_1.default.isInterfaceDeclaration(decl) || typescript_1.default.isClassDeclaration(decl) || typescript_1.default.isEnumDeclaration(decl)) {
+            // @ts-ignore
+            const sym = checker.getSymbolAtLocation(decl.name);
+            if (sym)
+                return checker.getDeclaredTypeOfSymbol(sym);
+        }
+        if (typescript_1.default.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    const sym = checker
+        .getSymbolsInScope(sf, typescript_1.default.SymbolFlags.Type | typescript_1.default.SymbolFlags.Alias | typescript_1.default.SymbolFlags.Interface)
+        .find((s) => s.name === name);
+    return sym ? checker.getDeclaredTypeOfSymbol(sym) : null;
+}
+function _findLocalDeclaration(sf, name) {
+    let found;
+    (function walk(node) {
+        if ((typescript_1.default.isInterfaceDeclaration(node) ||
+            typescript_1.default.isTypeAliasDeclaration(node) ||
+            typescript_1.default.isEnumDeclaration(node) ||
+            typescript_1.default.isClassDeclaration(node)) &&
+            node.name?.text === name) {
+            found = node;
+            return;
+        }
+        if (!found)
+            node.forEachChild(walk);
+    })(sf);
+    return found;
+}
+function _emitMakeValidate(checker, type, isRemovedInProd) {
+    const guard = isRemovedInProd ? "((_)=>true)" : (0, core_1.emitGuardFromType)(checker, type);
+    return typescript_1.default.factory.createIdentifier(guard);
+}
+function _emitMakeAssert(checker, type, isRemovedInProd) {
+    const guard = isRemovedInProd ? "((_)=>{})" : (0, core_1.emitGuardFromType)(checker, type);
+    const txt = `(function(){const G=${guard};return(i)=>{if(!G(i))throw new TypeError("[runtypex] Validation failed.");};})()`;
+    return typescript_1.default.factory.createIdentifier(txt);
+}

package/dist/cjs/transformer/vite-plugin.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "vite";
+/**
+ * 🧩 vitePluginRuntypex
+ * A Vite plugin that performs build-time type → runtime validation transformation.
+ *
+ * 📘 Purpose
+ *  - Replace calls like:
+ *      makeValidate<T>(), makeAssert<T>()
+ *    with *inline JavaScript guard functions* derived from TypeScript types.
+ *
+ * 💡 Features
+ *  - Works in both dev & build mode
+ *  - Optional: remove validation code in production (`removeInProd`)
+ *  - Compatible with Rollup / Webpack (via Vite plugin API)
+ */
+export default function vitePluginRuntypex(options?: {
+    removeInProd?: boolean;
+}): Plugin;

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

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = vitePluginRuntypex;
+const typescript_1 = __importDefault(require("typescript"));
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("../core");
+/**
+ * 🧩 vitePluginRuntypex
+ * A Vite plugin that performs build-time type → runtime validation transformation.
+ *
+ * 📘 Purpose
+ *  - Replace calls like:
+ *      makeValidate<T>(), makeAssert<T>()
+ *    with *inline JavaScript guard functions* derived from TypeScript types.
+ *
+ * 💡 Features
+ *  - Works in both dev & build mode
+ *  - Optional: remove validation code in production (`removeInProd`)
+ *  - Compatible with Rollup / Webpack (via Vite plugin API)
+ */
+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);
+            if (!isTS || !isTargetFunction)
+                return;
+            const { program, checker } = _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);
+            return mutated === code ? null : { code: mutated, map: null };
+        },
+    };
+}
+// ──────────────────────────────────────────────
+// ① createProgram & TypeChecker
+// ──────────────────────────────────────────────
+function _createProgramFor(file) {
+    const tsconfig = _findNearestTsconfig(node_path_1.default.dirname(file));
+    const cfg = typescript_1.default.readConfigFile(tsconfig, typescript_1.default.sys.readFile);
+    if (cfg.error) {
+        throw new Error(typescript_1.default.flattenDiagnosticMessageText(cfg.error.messageText, "\n"));
+    }
+    const parsed = typescript_1.default.parseJsonConfigFileContent(cfg.config, typescript_1.default.sys, node_path_1.default.dirname(tsconfig));
+    const program = typescript_1.default.createProgram({ rootNames: parsed.fileNames, options: parsed.options });
+    const checker = program.getTypeChecker();
+    return { program, checker };
+}
+function _findNearestTsconfig(start) {
+    let dir = start;
+    while (true) {
+        const candidate = node_path_1.default.join(dir, "tsconfig.json");
+        if (typescript_1.default.sys.fileExists(candidate))
+            return candidate;
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const fallback = node_path_1.default.join(process.cwd(), "tsconfig.json");
+    if (typescript_1.default.sys.fileExists(fallback))
+        return fallback;
+    throw new Error("tsconfig.json not found");
+}
+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 (0, core_1.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 = (0, core_1.emitGuardFromType)(checker, type);
+    return `(function(){const G=${guard};return(i)=>{if(!G(i))throw new TypeError("[runtypex] Validation failed.");};})()`;
+}
+// ──────────────────────────────────────────────
+// ③ Type Resolution (support interface/type/enum)
+// ──────────────────────────────────────────────
+function _resolveTypeByName(program, sf, checker, name) {
+    // scan all source files for local declaration
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        // interface / class / enum
+        if (typescript_1.default.isInterfaceDeclaration(decl) || typescript_1.default.isClassDeclaration(decl) || typescript_1.default.isEnumDeclaration(decl)) {
+            // @ts-ignore
+            const symbol = checker.getSymbolAtLocation(decl.name);
+            if (symbol)
+                return checker.getDeclaredTypeOfSymbol(symbol);
+        }
+        // type alias
+        if (typescript_1.default.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    // Scope-based fallback
+    const symbol = checker
+        .getSymbolsInScope(sf, typescript_1.default.SymbolFlags.Type | typescript_1.default.SymbolFlags.Alias | typescript_1.default.SymbolFlags.Interface)
+        .find((s) => s.name === name);
+    return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+}
+function _findLocalDeclaration(sf, name) {
+    let found;
+    (function walk(node) {
+        if ((typescript_1.default.isInterfaceDeclaration(node) ||
+            typescript_1.default.isTypeAliasDeclaration(node) ||
+            typescript_1.default.isEnumDeclaration(node) ||
+            typescript_1.default.isClassDeclaration(node)) &&
+            node.name?.text === name) {
+            found = node;
+            return;
+        }
+        if (!found)
+            node.forEachChild(walk);
+    })(sf);
+    return found;
+}

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

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

package/dist/esm/core/emitArrayOrTuple.js

@@ -0,0 +1,37 @@
+/**
+ * Handles array (T[]) and tuple ([A, B]) types.
+ */
+export 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/esm/core/emitLiteralOrEnum.d.ts

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

package/dist/esm/core/emitLiteralOrEnum.js

@@ -0,0 +1,41 @@
+import ts from "typescript";
+/** Handles literal types and enum-like types. */
+export 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 & ts.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 = ts.isEnumDeclaration(declaration);
+        if (!isEnum)
+            continue;
+        for (const member of declaration.members) {
+            const init = member.initializer;
+            if (!init)
+                continue;
+            if (ts.isStringLiteral(init) || ts.isNumericLiteral(init)) {
+                const value = ts.isStringLiteral(init) ? JSON.stringify(init.text) : init.text;
+                values.push(value);
+            }
+        }
+    }
+    return values;
+}

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

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

package/dist/esm/core/emitObject.js

@@ -0,0 +1,22 @@
+import ts from "typescript";
+/**
+ * Handles interfaces, classes, and object-like structures.
+ */
+export function emitObject(ctx, expr, t) {
+    const isObject = (t.getFlags() & ts.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() & ts.SymbolFlags.Optional) !== 0;
+        const condition = ctx.emit(`${expr}.${prop.name}`, propType);
+        const checkExpr = isOptional ? `(${expr}.${prop.name}===undefined||${condition})` : condition;
+        parts.push(checkExpr);
+    }
+    return `(${parts.join("&&")})`;
+}

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

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

package/dist/esm/core/emitPrimitive.js

@@ -0,0 +1,23 @@
+import ts from "typescript";
+/**
+ * Handles primitive types like number, string, boolean...
+ */
+export function emitPrimitive(ctx, expr, t) {
+    if ((t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)
+        return "true";
+    if (t.flags & ts.TypeFlags.Null)
+        return `${expr}===null`;
+    if (t.flags & ts.TypeFlags.Undefined)
+        return `${expr}===undefined`;
+    if (t.flags & ts.TypeFlags.BooleanLike)
+        return `typeof ${expr}==="boolean"`;
+    if (t.flags & ts.TypeFlags.NumberLike)
+        return `typeof ${expr}==="number"`;
+    if (t.flags & ts.TypeFlags.StringLike)
+        return `typeof ${expr}==="string"`;
+    if (t.flags & ts.TypeFlags.BigIntLike)
+        return `typeof ${expr}==="bigint"`;
+    if (t.flags & ts.TypeFlags.ESSymbolLike)
+        return `typeof ${expr}==="symbol"`;
+    return null;
+}

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

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

package/dist/esm/core/emitUnionOrIntersection.js

@@ -0,0 +1,12 @@
+/**
+ * Handles union (A | B) and intersection (A & B) types.
+ */
+export 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/esm/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;
+}

package/dist/esm/core/index.js

@@ -0,0 +1,36 @@
+import { emitPrimitive } from "./emitPrimitive";
+import { emitLiteralOrEnum } from "./emitLiteralOrEnum";
+import { emitUnionOrIntersection } from "./emitUnionOrIntersection";
+import { emitArrayOrTuple } from "./emitArrayOrTuple";
+import { emitObject } from "./emitObject";
+/**
+ * ✅ emitGuardFromType
+ * Converts a TypeScript type to a JavaScript runtime validation function string.
+ */
+export function emitGuardFromType(checker, type) {
+    const ctx = new GenContext(checker);
+    const condition = ctx.emit("input", type);
+    return `(input)=>${condition}`;
+}
+/**
+ * ✅ GenContext
+ * Internal helper for converting TypeScript types to JS validation expressions.
+ */
+export class GenContext {
+    checker;
+    seen = new Map();
+    constructor(checker) {
+        this.checker = checker;
+    }
+    /** Top-level router — delegates each type to the correct handler. */
+    emit(expr, t) {
+        if (this.seen.has(t))
+            return this.seen.get(t);
+        return (emitPrimitive(this, expr, t) ??
+            emitLiteralOrEnum(this, expr, t) ??
+            emitUnionOrIntersection(this, expr, t) ??
+            emitArrayOrTuple(this, expr, t) ??
+            emitObject(this, expr, t) ??
+            "true");
+    }
+}

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

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

@@ -0,0 +1,10 @@
+/**
+ * runtypex — runtime APIs
+ * 1) makeValidate<T>()  : (v) => v is T
+ * 2) makeAssert<T>()    : throws on invalid
+ *
+ * NOTE: These factories are replaced at build-time by the transformer.
+ */
+export type ValidateFn<T> = (value: unknown) => value is T;
+export declare function makeValidate<T>(): ValidateFn<T>;
+export declare function makeAssert<T>(): (value: unknown) => asserts value is T;

package/dist/esm/runtime/validate.js

@@ -0,0 +1,14 @@
+// Replaced by transformer to generated guard
+function __validate(_value) {
+    throw new Error("[runtypex] makeValidate() was not transformed. Add the plugin/transformer.");
+}
+export function makeValidate() {
+    return (value) => __validate(value);
+}
+export function makeAssert() {
+    const validate = makeValidate();
+    return (value) => {
+        if (!validate(value))
+            throw new TypeError("[runtypex] Validation failed.");
+    };
+}

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

@@ -0,0 +1,25 @@
+import ts from "typescript";
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ 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;

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

@@ -0,0 +1,97 @@
+import ts from "typescript";
+import { emitGuardFromType } from "../core";
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ Validation logic embedded at build-time
+ *   ✅ 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";
+    return (context) => {
+        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;
+                    const isRemovedInProd = removeInProd && prod;
+                    switch (name) {
+                        case "makeValidate":
+                            return _emitMakeValidate(checker, type, isRemovedInProd);
+                        case "makeAssert":
+                            return _emitMakeAssert(checker, type, isRemovedInProd);
+                    }
+                }
+            }
+            return ts.visitEachChild(node, visit, context);
+        };
+        return (sf) => ts.visitNode(sf, visit);
+    };
+}
+function _resolveTypeByName(program, sf, checker, name) {
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        if (ts.isInterfaceDeclaration(decl) || ts.isClassDeclaration(decl) || ts.isEnumDeclaration(decl)) {
+            // @ts-ignore
+            const sym = checker.getSymbolAtLocation(decl.name);
+            if (sym)
+                return checker.getDeclaredTypeOfSymbol(sym);
+        }
+        if (ts.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    const sym = checker
+        .getSymbolsInScope(sf, ts.SymbolFlags.Type | ts.SymbolFlags.Alias | ts.SymbolFlags.Interface)
+        .find((s) => s.name === name);
+    return sym ? checker.getDeclaredTypeOfSymbol(sym) : 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;
+}
+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);
+    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.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "vite";
+/**
+ * 🧩 vitePluginRuntypex
+ * A Vite plugin that performs build-time type → runtime validation transformation.
+ *
+ * 📘 Purpose
+ *  - Replace calls like:
+ *      makeValidate<T>(), makeAssert<T>()
+ *    with *inline JavaScript guard functions* derived from TypeScript types.
+ *
+ * 💡 Features
+ *  - Works in both dev & build mode
+ *  - Optional: remove validation code in production (`removeInProd`)
+ *  - Compatible with Rollup / Webpack (via Vite plugin API)
+ */
+export default function vitePluginRuntypex(options?: {
+    removeInProd?: boolean;
+}): Plugin;

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

@@ -0,0 +1,131 @@
+import ts from "typescript";
+import path from "node:path";
+import { emitGuardFromType } from "../core";
+/**
+ * 🧩 vitePluginRuntypex
+ * A Vite plugin that performs build-time type → runtime validation transformation.
+ *
+ * 📘 Purpose
+ *  - Replace calls like:
+ *      makeValidate<T>(), makeAssert<T>()
+ *    with *inline JavaScript guard functions* derived from TypeScript types.
+ *
+ * 💡 Features
+ *  - Works in both dev & build mode
+ *  - Optional: remove validation code in production (`removeInProd`)
+ *  - Compatible with Rollup / Webpack (via Vite plugin API)
+ */
+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);
+            if (!isTS || !isTargetFunction)
+                return;
+            const { program, checker } = _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);
+            return mutated === code ? null : { code: mutated, map: null };
+        },
+    };
+}
+// ──────────────────────────────────────────────
+// ① createProgram & TypeChecker
+// ──────────────────────────────────────────────
+function _createProgramFor(file) {
+    const tsconfig = _findNearestTsconfig(path.dirname(file));
+    const cfg = ts.readConfigFile(tsconfig, ts.sys.readFile);
+    if (cfg.error) {
+        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 };
+}
+function _findNearestTsconfig(start) {
+    let dir = start;
+    while (true) {
+        const candidate = path.join(dir, "tsconfig.json");
+        if (ts.sys.fileExists(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const fallback = path.join(process.cwd(), "tsconfig.json");
+    if (ts.sys.fileExists(fallback))
+        return fallback;
+    throw new Error("tsconfig.json not found");
+}
+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 interface/type/enum)
+// ──────────────────────────────────────────────
+function _resolveTypeByName(program, sf, checker, name) {
+    // scan all source files for local declaration
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        // interface / class / enum
+        if (ts.isInterfaceDeclaration(decl) || ts.isClassDeclaration(decl) || ts.isEnumDeclaration(decl)) {
+            // @ts-ignore
+            const symbol = checker.getSymbolAtLocation(decl.name);
+            if (symbol)
+                return checker.getDeclaredTypeOfSymbol(symbol);
+        }
+        // type alias
+        if (ts.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    // 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/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "runtypex",
+  "version": "0.1.0",
+  "description": "Runtime type guards compiled from TypeScript types. Fast, zero-schema, transformer-based.",
+  "license": "MIT",
+  "author": "Lux",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://example.com/runtypex.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./vite-plugin": {
+      "types": "./dist/esm/transformer/vite-plugin.d.ts",
+      "import": "./dist/esm/transformer/vite-plugin.js",
+      "require": "./dist/cjs/transformer/vite-plugin.js"
+    },
+    "./transformer": {
+      "types": "./dist/esm/transformer/ts-transformer.d.ts",
+      "import": "./dist/esm/transformer/ts-transformer.js",
+      "require": "./dist/cjs/transformer/ts-transformer.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "test": "jest --passWithNoTests"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.8.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.3"
+  }
+}