@typokit/transform-typia 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import type { TypeMetadata } from "@typokit/types";
+/**
+ * Error thrown when validator generation fails for a type.
+ */
+export declare class ValidatorGenerationError extends Error {
+    readonly typeName: string;
+    readonly reason: string;
+    constructor(typeName: string, reason: string);
+}
+/**
+ * Generate a runtime validator function as a code string from type metadata.
+ * The generated function validates input against the type's shape and returns
+ * `{ success: true, data }` or `{ success: false, errors }`.
+ */
+export declare function generateValidator(typeMetadata: TypeMetadata): string;
+/**
+ * Generate validators for multiple types in batch.
+ * Types can cross-reference each other for nested validation.
+ * Returns Map<typeName, generatedCode>.
+ */
+export declare function generateValidatorBatch(types: TypeMetadata[]): Map<string, string>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAM7C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CASpE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,YAAY,EAAE,GACpB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAoBrB"}

package/dist/index.js

@@ -0,0 +1,239 @@
+// @typokit/transform-typia — Typia Validation Bridge
+//
+// Generates runtime validation code from type metadata.
+// Typia is installed as a dependency for transformer integration;
+// this module bridges Rust-extracted TypeMetadata to generated validators.
+/**
+ * Error thrown when validator generation fails for a type.
+ */
+export class ValidatorGenerationError extends Error {
+    typeName;
+    reason;
+    constructor(typeName, reason) {
+        super(`Failed to generate validator for type "${typeName}": ${reason}`);
+        this.typeName = typeName;
+        this.reason = reason;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Generate a runtime validator function as a code string from type metadata.
+ * The generated function validates input against the type's shape and returns
+ * `{ success: true, data }` or `{ success: false, errors }`.
+ */
+export function generateValidator(typeMetadata) {
+    try {
+        assertValidMetadata(typeMetadata);
+        return buildValidatorCode(typeMetadata);
+    }
+    catch (err) {
+        if (err instanceof ValidatorGenerationError)
+            throw err;
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new ValidatorGenerationError(typeMetadata.name, reason);
+    }
+}
+/**
+ * Generate validators for multiple types in batch.
+ * Types can cross-reference each other for nested validation.
+ * Returns Map<typeName, generatedCode>.
+ */
+export function generateValidatorBatch(types) {
+    const result = new Map();
+    const registry = new Map();
+    for (const t of types) {
+        registry.set(t.name, t);
+    }
+    for (const metadata of types) {
+        try {
+            assertValidMetadata(metadata);
+            const code = buildValidatorCode(metadata, registry);
+            result.set(metadata.name, code);
+        }
+        catch (err) {
+            if (err instanceof ValidatorGenerationError)
+                throw err;
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new ValidatorGenerationError(metadata.name, reason);
+        }
+    }
+    return result;
+}
+// ── Internal helpers ─────────────────────────────────────────────
+function assertValidMetadata(metadata) {
+    if (!metadata.name || typeof metadata.name !== "string") {
+        throw new ValidatorGenerationError(metadata.name ?? "<unnamed>", "TypeMetadata must have a non-empty string name");
+    }
+    if (!metadata.properties || typeof metadata.properties !== "object") {
+        throw new ValidatorGenerationError(metadata.name, "TypeMetadata must have a properties object");
+    }
+}
+function buildValidatorCode(metadata, registry) {
+    const fnName = `validate${metadata.name}`;
+    const propEntries = Object.entries(metadata.properties);
+    const lines = [];
+    lines.push(`function ${fnName}(input) {`);
+    lines.push(`  if (typeof input !== "object" || input === null) {`);
+    lines.push(`    return { success: false, errors: [{ path: "$input", expected: "object", actual: input === null ? "null" : typeof input }] };`);
+    lines.push(`  }`);
+    if (propEntries.length === 0) {
+        lines.push(`  return { success: true, data: input };`);
+        lines.push(`}`);
+        return lines.join("\n");
+    }
+    lines.push(`  var errors = [];`);
+    for (const [propName, propDef] of propEntries) {
+        const accessor = `input[${JSON.stringify(propName)}]`;
+        const typeCheck = generateTypeCheck(accessor, propDef.type, registry);
+        if (propDef.optional) {
+            lines.push(`  if (${accessor} !== undefined) {`);
+            lines.push(`    if (!(${typeCheck})) {`);
+            lines.push(`      errors.push({ path: ${JSON.stringify(propName)}, expected: ${JSON.stringify(propDef.type)}, actual: typeof ${accessor} });`);
+            lines.push(`    }`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${accessor} === undefined) {`);
+            lines.push(`    errors.push({ path: ${JSON.stringify(propName)}, expected: ${JSON.stringify(propDef.type)}, actual: "undefined" });`);
+            lines.push(`  } else if (!(${typeCheck})) {`);
+            lines.push(`    errors.push({ path: ${JSON.stringify(propName)}, expected: ${JSON.stringify(propDef.type)}, actual: typeof ${accessor} });`);
+            lines.push(`  }`);
+        }
+    }
+    lines.push(`  return errors.length === 0 ? { success: true, data: input } : { success: false, errors: errors };`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+function generateTypeCheck(expr, typeStr, registry) {
+    typeStr = typeStr.trim();
+    // Union types: "string | number"
+    const unionParts = splitUnionType(typeStr);
+    if (unionParts.length > 1) {
+        const checks = unionParts.map((p) => generateTypeCheck(expr, p.trim(), registry));
+        return `(${checks.join(" || ")})`;
+    }
+    // Array shorthand: "string[]"
+    if (typeStr.endsWith("[]")) {
+        const elementType = typeStr.slice(0, -2).trim();
+        return `(Array.isArray(${expr}) && ${expr}.every(function(item) { return ${generateTypeCheck("item", elementType, registry)}; }))`;
+    }
+    // Array generic: "Array<string>"
+    const arrayGenericMatch = typeStr.match(/^Array<(.+)>$/);
+    if (arrayGenericMatch) {
+        const elementType = arrayGenericMatch[1].trim();
+        return `(Array.isArray(${expr}) && ${expr}.every(function(item) { return ${generateTypeCheck("item", elementType, registry)}; }))`;
+    }
+    // Record<K, V>
+    const recordMatch = typeStr.match(/^Record<(.+),\s*(.+)>$/);
+    if (recordMatch) {
+        const valueType = recordMatch[2].trim();
+        return `(typeof ${expr} === "object" && ${expr} !== null && !Array.isArray(${expr}) && Object.values(${expr}).every(function(v) { return ${generateTypeCheck("v", valueType, registry)}; }))`;
+    }
+    // Template literal types: `prefix_${string}`
+    if (typeStr.startsWith("`") && typeStr.endsWith("`")) {
+        const pattern = buildTemplateLiteralRegex(typeStr.slice(1, -1));
+        return `(typeof ${expr} === "string" && /^${pattern}$/.test(${expr}))`;
+    }
+    // Primitive types
+    switch (typeStr) {
+        case "string":
+            return `typeof ${expr} === "string"`;
+        case "number":
+            return `(typeof ${expr} === "number" && !isNaN(${expr}))`;
+        case "boolean":
+            return `typeof ${expr} === "boolean"`;
+        case "null":
+            return `${expr} === null`;
+        case "undefined":
+        case "void":
+            return `${expr} === undefined`;
+        case "any":
+        case "unknown":
+            return `true`;
+        case "never":
+            return `false`;
+        case "bigint":
+            return `typeof ${expr} === "bigint"`;
+        case "symbol":
+            return `typeof ${expr} === "symbol"`;
+        case "object":
+            return `(typeof ${expr} === "object" && ${expr} !== null)`;
+        case "Date":
+            return `(${expr} instanceof Date)`;
+        default:
+            // Reference type or unknown — validate as non-null object
+            return `(typeof ${expr} === "object" && ${expr} !== null)`;
+    }
+}
+/**
+ * Split a type string on top-level `|` characters,
+ * respecting generics `<>`, parens `()`, braces `{}`, and backtick literals.
+ */
+function splitUnionType(typeStr) {
+    const parts = [];
+    let current = "";
+    let depth = 0;
+    let inBacktick = false;
+    for (let i = 0; i < typeStr.length; i++) {
+        const ch = typeStr[i];
+        if (ch === "`") {
+            inBacktick = !inBacktick;
+        }
+        if (!inBacktick) {
+            if (ch === "<" || ch === "(" || ch === "{")
+                depth++;
+            if (ch === ">" || ch === ")" || ch === "}")
+                depth--;
+            if (ch === "|" && depth === 0) {
+                parts.push(current.trim());
+                current = "";
+                continue;
+            }
+        }
+        current += ch;
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+/**
+ * Convert a template literal body (without surrounding backticks)
+ * into a JavaScript RegExp pattern string.
+ * Handles `${string}`, `${number}`, and literal characters.
+ */
+function buildTemplateLiteralRegex(inner) {
+    let pattern = "";
+    let i = 0;
+    while (i < inner.length) {
+        if (inner[i] === "$" && inner[i + 1] === "{") {
+            const end = inner.indexOf("}", i + 2);
+            if (end !== -1) {
+                const placeholder = inner.slice(i + 2, end);
+                switch (placeholder) {
+                    case "string":
+                        pattern += ".*";
+                        break;
+                    case "number":
+                        pattern += "[0-9]+(?:\\.[0-9]+)?";
+                        break;
+                    default:
+                        pattern += ".*";
+                        break;
+                }
+                i = end + 1;
+                continue;
+            }
+        }
+        // Escape regex-special characters
+        if (/[.*+?^${}()|[\]\\]/.test(inner[i])) {
+            pattern += "\\" + inner[i];
+        }
+        else {
+            pattern += inner[i];
+        }
+        i++;
+    }
+    return pattern;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@typokit/transform-typia",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "version": "0.1.4",
+  "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "typia": "11.0.3",
+    "@typokit/types": "0.1.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KyleBastien/typokit",
+    "directory": "packages/transform-typia"
+  },
+  "scripts": {
+    "test": "rstest run --passWithNoTests"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, expect } from "@rstest/core";
+import {
+  generateValidator,
+  generateValidatorBatch,
+  ValidatorGenerationError,
+} from "./index.js";
+
+import type { TypeMetadata } from "@typokit/types";
+
+// Helper: evaluate generated validator code and run it against input
+function run(code: string, fnName: string, input: unknown): unknown {
+  const fn = new Function("input", code + `\nreturn ${fnName}(input);`);
+  return fn(input);
+}
+
+describe("generateValidator", () => {
+  it("generates validator for simple types", () => {
+    const metadata: TypeMetadata = {
+      name: "User",
+      properties: {
+        name: { type: "string", optional: false },
+        age: { type: "number", optional: false },
+        active: { type: "boolean", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    expect(code).toContain("function validateUser(input)");
+
+    const valid = run(code, "validateUser", {
+      name: "John",
+      age: 30,
+      active: true,
+    }) as { success: boolean };
+    expect(valid.success).toBe(true);
+
+    const invalid = run(code, "validateUser", {
+      name: 123,
+      age: "thirty",
+      active: "yes",
+    }) as { success: boolean; errors: unknown[] };
+    expect(invalid.success).toBe(false);
+    expect(invalid.errors.length).toBe(3);
+  });
+
+  it("generates validator for union types", () => {
+    const metadata: TypeMetadata = {
+      name: "FlexId",
+      properties: {
+        id: { type: "string | number", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateFlexId", v) as { success: boolean };
+
+    expect(check({ id: "abc" }).success).toBe(true);
+    expect(check({ id: 42 }).success).toBe(true);
+    expect(check({ id: true }).success).toBe(false);
+  });
+
+  it("generates validator for nested object types", () => {
+    const metadata: TypeMetadata = {
+      name: "Profile",
+      properties: {
+        address: { type: "Address", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateProfile", v) as { success: boolean };
+
+    expect(check({ address: { street: "123 Main" } }).success).toBe(true);
+    expect(check({ address: null }).success).toBe(false);
+    expect(check({ address: "not object" }).success).toBe(false);
+  });
+
+  it("generates validator for array types", () => {
+    const metadata: TypeMetadata = {
+      name: "TagList",
+      properties: {
+        tags: { type: "string[]", optional: false },
+        scores: { type: "number[]", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateTagList", v) as { success: boolean };
+
+    expect(check({ tags: ["a", "b"], scores: [1, 2] }).success).toBe(true);
+    expect(check({ tags: [1, 2], scores: [1, 2] }).success).toBe(false);
+    expect(check({ tags: "not array", scores: [1] }).success).toBe(false);
+  });
+
+  it("generates validator for optional fields", () => {
+    const metadata: TypeMetadata = {
+      name: "UpdateUser",
+      properties: {
+        name: { type: "string", optional: true },
+        age: { type: "number", optional: true },
+        email: { type: "string", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateUpdateUser", v) as { success: boolean };
+
+    expect(check({ name: "John", age: 30, email: "j@e.com" }).success).toBe(
+      true,
+    );
+    expect(check({ email: "j@e.com" }).success).toBe(true);
+    expect(check({ name: "John" }).success).toBe(false);
+    expect(check({ email: "j@e.com", name: 123 }).success).toBe(false);
+  });
+
+  it("generates validator for empty properties", () => {
+    const metadata: TypeMetadata = {
+      name: "Empty",
+      properties: {},
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateEmpty", v) as { success: boolean };
+
+    expect(check({}).success).toBe(true);
+    expect(check(null).success).toBe(false);
+  });
+
+  it("rejects non-object input in generated validators", () => {
+    const metadata: TypeMetadata = {
+      name: "Test",
+      properties: { x: { type: "string", optional: false } },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateTest", v) as { success: boolean };
+
+    expect(check(null).success).toBe(false);
+    expect(check(undefined).success).toBe(false);
+    expect(check("string").success).toBe(false);
+    expect(check(42).success).toBe(false);
+  });
+
+  it("generates validator for nullable union types", () => {
+    const metadata: TypeMetadata = {
+      name: "Nullable",
+      properties: {
+        value: { type: "string | null", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateNullable", v) as { success: boolean };
+
+    expect(check({ value: "hello" }).success).toBe(true);
+    expect(check({ value: null }).success).toBe(true);
+    expect(check({ value: 42 }).success).toBe(false);
+  });
+
+  it("generates validator for template literal types", () => {
+    const metadata: TypeMetadata = {
+      name: "EventName",
+      properties: {
+        event: { type: "`on_${string}`", optional: false },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    const check = (v: unknown) =>
+      run(code, "validateEventName", v) as { success: boolean };
+
+    expect(check({ event: "on_click" }).success).toBe(true);
+    expect(check({ event: "on_" }).success).toBe(true);
+    expect(check({ event: "off_click" }).success).toBe(false);
+    expect(check({ event: 42 }).success).toBe(false);
+  });
+
+  it("generates validator for recursive types", () => {
+    const metadata: TypeMetadata = {
+      name: "TreeNode",
+      properties: {
+        value: { type: "number", optional: false },
+        children: { type: "TreeNode[]", optional: true },
+      },
+    };
+
+    const code = generateValidator(metadata);
+    expect(code).toContain("function validateTreeNode");
+    expect(code).toContain("Array.isArray");
+
+    const check = (v: unknown) =>
+      run(code, "validateTreeNode", v) as { success: boolean };
+    expect(check({ value: 1 }).success).toBe(true);
+    expect(check({ value: 1, children: [{ value: 2 }] }).success).toBe(true);
+    expect(check({ value: "not a number" }).success).toBe(false);
+  });
+
+  it("throws ValidatorGenerationError on empty name", () => {
+    const metadata = { name: "", properties: {} } as TypeMetadata;
+    expect(() => generateValidator(metadata)).toThrow(ValidatorGenerationError);
+  });
+
+  it("error includes type name and reason", () => {
+    try {
+      generateValidator({ name: "", properties: {} });
+      expect(true).toBe(false); // should not reach here
+    } catch (err) {
+      expect(err).toBeInstanceOf(ValidatorGenerationError);
+      const vge = err as ValidatorGenerationError;
+      expect(vge.reason).toContain("non-empty");
+    }
+  });
+});
+
+describe("generateValidatorBatch", () => {
+  it("generates validators for multiple types", () => {
+    const types: TypeMetadata[] = [
+      {
+        name: "User",
+        properties: {
+          name: { type: "string", optional: false },
+          age: { type: "number", optional: false },
+        },
+      },
+      {
+        name: "Post",
+        properties: {
+          title: { type: "string", optional: false },
+          author: { type: "User", optional: false },
+        },
+      },
+    ];
+
+    const result = generateValidatorBatch(types);
+    expect(result.size).toBe(2);
+    expect(result.has("User")).toBe(true);
+    expect(result.has("Post")).toBe(true);
+    expect(result.get("User")).toContain("function validateUser");
+    expect(result.get("Post")).toContain("function validatePost");
+  });
+
+  it("cross-references types in the batch", () => {
+    const types: TypeMetadata[] = [
+      {
+        name: "Address",
+        properties: {
+          street: { type: "string", optional: false },
+        },
+      },
+      {
+        name: "Person",
+        properties: {
+          name: { type: "string", optional: false },
+          address: { type: "Address", optional: false },
+        },
+      },
+    ];
+
+    const result = generateValidatorBatch(types);
+    const personCode = result.get("Person")!;
+    const check = (v: unknown) =>
+      run(personCode, "validatePerson", v) as { success: boolean };
+
+    expect(check({ name: "Jane", address: { street: "Elm" } }).success).toBe(
+      true,
+    );
+    expect(check({ name: "Jane", address: null }).success).toBe(false);
+  });
+
+  it("throws ValidatorGenerationError for invalid type in batch", () => {
+    const types: TypeMetadata[] = [
+      { name: "Good", properties: { x: { type: "string", optional: false } } },
+      { name: "", properties: {} },
+    ];
+
+    expect(() => generateValidatorBatch(types)).toThrow(
+      ValidatorGenerationError,
+    );
+  });
+});

package/src/index.ts

@@ -0,0 +1,284 @@
+// @typokit/transform-typia — Typia Validation Bridge
+//
+// Generates runtime validation code from type metadata.
+// Typia is installed as a dependency for transformer integration;
+// this module bridges Rust-extracted TypeMetadata to generated validators.
+
+import type { TypeMetadata } from "@typokit/types";
+
+/**
+ * Error thrown when validator generation fails for a type.
+ */
+export class ValidatorGenerationError extends Error {
+  public readonly typeName: string;
+  public readonly reason: string;
+
+  constructor(typeName: string, reason: string) {
+    super(`Failed to generate validator for type "${typeName}": ${reason}`);
+    this.typeName = typeName;
+    this.reason = reason;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+/**
+ * Generate a runtime validator function as a code string from type metadata.
+ * The generated function validates input against the type's shape and returns
+ * `{ success: true, data }` or `{ success: false, errors }`.
+ */
+export function generateValidator(typeMetadata: TypeMetadata): string {
+  try {
+    assertValidMetadata(typeMetadata);
+    return buildValidatorCode(typeMetadata);
+  } catch (err) {
+    if (err instanceof ValidatorGenerationError) throw err;
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new ValidatorGenerationError(typeMetadata.name, reason);
+  }
+}
+
+/**
+ * Generate validators for multiple types in batch.
+ * Types can cross-reference each other for nested validation.
+ * Returns Map<typeName, generatedCode>.
+ */
+export function generateValidatorBatch(
+  types: TypeMetadata[],
+): Map<string, string> {
+  const result = new Map<string, string>();
+  const registry = new Map<string, TypeMetadata>();
+  for (const t of types) {
+    registry.set(t.name, t);
+  }
+
+  for (const metadata of types) {
+    try {
+      assertValidMetadata(metadata);
+      const code = buildValidatorCode(metadata, registry);
+      result.set(metadata.name, code);
+    } catch (err) {
+      if (err instanceof ValidatorGenerationError) throw err;
+      const reason = err instanceof Error ? err.message : String(err);
+      throw new ValidatorGenerationError(metadata.name, reason);
+    }
+  }
+
+  return result;
+}
+
+// ── Internal helpers ─────────────────────────────────────────────
+
+function assertValidMetadata(metadata: TypeMetadata): void {
+  if (!metadata.name || typeof metadata.name !== "string") {
+    throw new ValidatorGenerationError(
+      metadata.name ?? "<unnamed>",
+      "TypeMetadata must have a non-empty string name",
+    );
+  }
+  if (!metadata.properties || typeof metadata.properties !== "object") {
+    throw new ValidatorGenerationError(
+      metadata.name,
+      "TypeMetadata must have a properties object",
+    );
+  }
+}
+
+function buildValidatorCode(
+  metadata: TypeMetadata,
+  registry?: Map<string, TypeMetadata>,
+): string {
+  const fnName = `validate${metadata.name}`;
+  const propEntries = Object.entries(metadata.properties);
+  const lines: string[] = [];
+
+  lines.push(`function ${fnName}(input) {`);
+  lines.push(`  if (typeof input !== "object" || input === null) {`);
+  lines.push(
+    `    return { success: false, errors: [{ path: "$input", expected: "object", actual: input === null ? "null" : typeof input }] };`,
+  );
+  lines.push(`  }`);
+
+  if (propEntries.length === 0) {
+    lines.push(`  return { success: true, data: input };`);
+    lines.push(`}`);
+    return lines.join("\n");
+  }
+
+  lines.push(`  var errors = [];`);
+
+  for (const [propName, propDef] of propEntries) {
+    const accessor = `input[${JSON.stringify(propName)}]`;
+    const typeCheck = generateTypeCheck(accessor, propDef.type, registry);
+
+    if (propDef.optional) {
+      lines.push(`  if (${accessor} !== undefined) {`);
+      lines.push(`    if (!(${typeCheck})) {`);
+      lines.push(
+        `      errors.push({ path: ${JSON.stringify(propName)}, expected: ${JSON.stringify(propDef.type)}, actual: typeof ${accessor} });`,
+      );
+      lines.push(`    }`);
+      lines.push(`  }`);
+    } else {
+      lines.push(`  if (${accessor} === undefined) {`);
+      lines.push(
+        `    errors.push({ path: ${JSON.stringify(propName)}, expected: ${JSON.stringify(propDef.type)}, actual: "undefined" });`,
+      );
+      lines.push(`  } else if (!(${typeCheck})) {`);
+      lines.push(
+        `    errors.push({ path: ${JSON.stringify(propName)}, expected: ${JSON.stringify(propDef.type)}, actual: typeof ${accessor} });`,
+      );
+      lines.push(`  }`);
+    }
+  }
+
+  lines.push(
+    `  return errors.length === 0 ? { success: true, data: input } : { success: false, errors: errors };`,
+  );
+  lines.push(`}`);
+  return lines.join("\n");
+}
+
+function generateTypeCheck(
+  expr: string,
+  typeStr: string,
+  registry?: Map<string, TypeMetadata>,
+): string {
+  typeStr = typeStr.trim();
+
+  // Union types: "string | number"
+  const unionParts = splitUnionType(typeStr);
+  if (unionParts.length > 1) {
+    const checks = unionParts.map((p) =>
+      generateTypeCheck(expr, p.trim(), registry),
+    );
+    return `(${checks.join(" || ")})`;
+  }
+
+  // Array shorthand: "string[]"
+  if (typeStr.endsWith("[]")) {
+    const elementType = typeStr.slice(0, -2).trim();
+    return `(Array.isArray(${expr}) && ${expr}.every(function(item) { return ${generateTypeCheck("item", elementType, registry)}; }))`;
+  }
+
+  // Array generic: "Array<string>"
+  const arrayGenericMatch = typeStr.match(/^Array<(.+)>$/);
+  if (arrayGenericMatch) {
+    const elementType = arrayGenericMatch[1].trim();
+    return `(Array.isArray(${expr}) && ${expr}.every(function(item) { return ${generateTypeCheck("item", elementType, registry)}; }))`;
+  }
+
+  // Record<K, V>
+  const recordMatch = typeStr.match(/^Record<(.+),\s*(.+)>$/);
+  if (recordMatch) {
+    const valueType = recordMatch[2].trim();
+    return `(typeof ${expr} === "object" && ${expr} !== null && !Array.isArray(${expr}) && Object.values(${expr}).every(function(v) { return ${generateTypeCheck("v", valueType, registry)}; }))`;
+  }
+
+  // Template literal types: `prefix_${string}`
+  if (typeStr.startsWith("`") && typeStr.endsWith("`")) {
+    const pattern = buildTemplateLiteralRegex(typeStr.slice(1, -1));
+    return `(typeof ${expr} === "string" && /^${pattern}$/.test(${expr}))`;
+  }
+
+  // Primitive types
+  switch (typeStr) {
+    case "string":
+      return `typeof ${expr} === "string"`;
+    case "number":
+      return `(typeof ${expr} === "number" && !isNaN(${expr}))`;
+    case "boolean":
+      return `typeof ${expr} === "boolean"`;
+    case "null":
+      return `${expr} === null`;
+    case "undefined":
+    case "void":
+      return `${expr} === undefined`;
+    case "any":
+    case "unknown":
+      return `true`;
+    case "never":
+      return `false`;
+    case "bigint":
+      return `typeof ${expr} === "bigint"`;
+    case "symbol":
+      return `typeof ${expr} === "symbol"`;
+    case "object":
+      return `(typeof ${expr} === "object" && ${expr} !== null)`;
+    case "Date":
+      return `(${expr} instanceof Date)`;
+    default:
+      // Reference type or unknown — validate as non-null object
+      return `(typeof ${expr} === "object" && ${expr} !== null)`;
+  }
+}
+
+/**
+ * Split a type string on top-level `|` characters,
+ * respecting generics `<>`, parens `()`, braces `{}`, and backtick literals.
+ */
+function splitUnionType(typeStr: string): string[] {
+  const parts: string[] = [];
+  let current = "";
+  let depth = 0;
+  let inBacktick = false;
+
+  for (let i = 0; i < typeStr.length; i++) {
+    const ch = typeStr[i];
+    if (ch === "`") {
+      inBacktick = !inBacktick;
+    }
+    if (!inBacktick) {
+      if (ch === "<" || ch === "(" || ch === "{") depth++;
+      if (ch === ">" || ch === ")" || ch === "}") depth--;
+      if (ch === "|" && depth === 0) {
+        parts.push(current.trim());
+        current = "";
+        continue;
+      }
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+}
+
+/**
+ * Convert a template literal body (without surrounding backticks)
+ * into a JavaScript RegExp pattern string.
+ * Handles `${string}`, `${number}`, and literal characters.
+ */
+function buildTemplateLiteralRegex(inner: string): string {
+  let pattern = "";
+  let i = 0;
+  while (i < inner.length) {
+    if (inner[i] === "$" && inner[i + 1] === "{") {
+      const end = inner.indexOf("}", i + 2);
+      if (end !== -1) {
+        const placeholder = inner.slice(i + 2, end);
+        switch (placeholder) {
+          case "string":
+            pattern += ".*";
+            break;
+          case "number":
+            pattern += "[0-9]+(?:\\.[0-9]+)?";
+            break;
+          default:
+            pattern += ".*";
+            break;
+        }
+        i = end + 1;
+        continue;
+      }
+    }
+    // Escape regex-special characters
+    if (/[.*+?^${}()|[\]\\]/.test(inner[i])) {
+      pattern += "\\" + inner[i];
+    } else {
+      pattern += inner[i];
+    }
+    i++;
+  }
+  return pattern;
+}