@elliots/typical 0.1.0 → 0.1.1

package/README.md

@@ -23,7 +23,7 @@ Why not.
 - ✅ Configurable include/exclude patterns
 - ✅ Optionally reuse validation logic for identical types to optimize performance (enabled by default)
 - ✅ TSC plugin
-- ✅ ESM loader for runtime transformation with `node --import typical/esm` (or `node --loader typical/esm-loader` for older Node versions)
+- ✅ ESM loader for runtime transformation with `node --import @elliots/typical/esm` (or `node --loader @elliots/typical/esm-loader` for older Node versions)
 - ✅ tsx wrapper (ttsx) for easy use like `npx ttsx script.ts`
 
 ## Installation

package/bin/ttsx

@@ -1,3 +1,3 @@
 #!/bin/sh
 
-NODE_OPTIONS="--import typical/esm" exec tsx $@
+NODE_OPTIONS="--import @elliots/typical/esm" exec tsx $@

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliots/typical",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Runtime safe TypeScript transformer using typia",
   "main": "dist/index.js",
   "type": "module",
@@ -17,8 +17,7 @@
   },
   "files": [
     "dist/src",
-    "bin",
-    "src"
+    "bin"
   ],
   "scripts": {
     "build": "tsc",

package/src/cli.ts

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { TypicalTransformer } from './transformer.js';
-import * as ts from 'typescript';
-import { loadConfig } from './config.js';
-import { shouldIncludeFile } from './file-filter.js';
-
-const program = new Command();
-
-program
-  .name('typical')
-  .description('Runtime safe TypeScript transformer using typia')
-  .version('0.1.0');
-
-program
-  .command('transform')
-  .description('Transform a TypeScript file with runtime validation')
-  .argument('<file>', 'TypeScript file to transform')
-  .option('-o, --output <file>', 'Output file')
-  .option('-c, --config <file>', 'Config file path', 'typical.json')
-  .option('-m, --mode <mode>', 'Transformation mode:  basic, typia, js', 'basic')
-  .action(async (file: string, options: { output?: string; config?: string; mode?: 'basic' | 'typia' | 'js' }) => {
-    try {
-      const config = loadConfig(options.config);
-      const transformer = new TypicalTransformer(config);
-      
-      if (!fs.existsSync(file)) {
-        console.error(`File not found: ${file}`);
-        process.exit(1);
-      }
-
-      console.log(`Transforming ${file}...`);
-      const transformedCode = transformer.transform(path.resolve(file), options.mode ?? 'basic');
-
-      const outputFilename = options.output ? path.resolve(options.output) : options.mode === 'js' ? file + '.js' : file + '.transformed.ts';
-      
-      const outputFile = options.output ? path.resolve(options.output) : file + '.transformed.ts';
-      fs.writeFileSync(outputFile, transformedCode);
-      
-      console.log(`Transformed code written to ${outputFile}`);
-    } catch (error) {
-      console.error('Transformation failed:', error);
-      process.exit(1);
-    }
-  });
-
-// program
-//   .command('build')
-//   .description('Transform all TypeScript files in the project')
-//   .option('-c, --config <file>', 'Config file path')
-//   .option('--dry-run', 'Show what would be transformed without making changes')
-//   .action(async (options: { config?: string, dryRun?: boolean }) => {
-//     try {
-//       const transformer = new TypicalTransformer();
-      
-//       const { glob } = await import('glob');
-
-//       const config = loadConfig(options.config);
-      
-//       if (!config.include || config.include.length === 0) {
-//         console.error('No include patterns specified in config');
-//         process.exit(1);
-//       }
-      
-//       const files: string[] = [];
-      
-//       for (const pattern of config.include) {
-//         const matched = await glob(pattern, { 
-//           ignore: config.exclude,
-//           absolute: true 
-//         });
-//         files.push(...matched);
-//       }
-      
-//       console.log(`Found ${files.length} files to transform`);
-      
-//       if (options.dryRun) {
-//         files.forEach(file => console.log(`Would transform: ${file}`));
-//         return;
-//       }
-      
-//       let transformed = 0;
-      
-//       for (const file of files) {
-//         // Double-check with our shared filtering logic
-//         if (!shouldIncludeFile(file, config)) {
-//           console.log(`Skipping ${file} (excluded by filters)`);
-//           continue;
-//         }
-        
-//         try {
-//           console.log(`Transforming ${file}...`);
-//           const transformedCode = transformer.transformFile(file, ts);
-//           fs.writeFileSync(file, transformedCode);
-//           transformed++;
-//         } catch (error) {
-//           console.error(`Failed to transform ${file}:`, error);
-//         }
-//       }
-      
-//       console.log(`Successfully transformed ${transformed}/${files.length} files`);
-//     } catch (error) {
-//       console.error('Build failed:', error);
-//       process.exit(1);
-//     }
-//   });
-
-program.parse();

package/src/config.ts

@@ -1,35 +0,0 @@
-export interface TypicalConfig {
-  include?: string[];
-  exclude?: string[];
-  reusableValidators?: boolean;
-}
-
-export const defaultConfig: TypicalConfig = {
-  include: ["**/*.ts", "**/*.tsx"],
-  exclude: ["node_modules/**", "**/*.d.ts", "dist/**", "build/**"],
-  reusableValidators: true,
-};
-
-import fs from 'fs';
-import path from 'path';
-
-export function loadConfig(configPath?: string): TypicalConfig {
-  const configFile = configPath || path.join(process.cwd(), 'typical.json');
-  
-  if (fs.existsSync(configFile)) {
-    try {
-      const configContent = fs.readFileSync(configFile, 'utf8');
-      const userConfig: Partial<TypicalConfig> = JSON.parse(configContent);
-      
-      return {
-        ...defaultConfig,
-        ...userConfig,
-      };
-    } catch (error) {
-      console.warn(`Failed to parse config file ${configFile}:`, error);
-      return defaultConfig;
-    }
-  }
-
-  return defaultConfig;
-}

package/src/esm-loader-register.ts

@@ -1,2 +0,0 @@
-import { register } from 'node:module';
-register('./esm-loader.js', { parentURL: import.meta.url });

package/src/esm-loader.ts

@@ -1,26 +0,0 @@
-import { fileURLToPath } from "url";
-import { TypicalTransformer } from "./transformer.js";
-
-const transformer = new TypicalTransformer();
-
-/**
- * Load hook - transforms TypeScript files on the fly
- */
-export async function load(url: string, context: any, nextLoad: any) {
-  if (!url.endsWith(".ts")) {
-    return nextLoad(url, context);
-  }
-  const filePath = fileURLToPath(url);
-
-  try {
-    const transformedCode = transformer.transform(filePath, 'js');
-    return {
-      format: "module",
-      source: transformedCode,
-      shortCircuit: true,
-    };
-  } catch (error) {
-    console.error(`Error transforming ${filePath}:`, error);
-    throw error;
-  }
-}

package/src/file-filter.ts

@@ -1,44 +0,0 @@
-import * as path from 'path';
-import { minimatch } from 'minimatch';
-import { TypicalConfig } from './config.js';
-
-/**
- * Determines if a file should be transformed based on include/exclude patterns
- */
-export function shouldTransformFile(fileName: string, config: TypicalConfig): boolean {
-  const relativePath = path.relative(process.cwd(), fileName);
-  
-  // Check include patterns
-  const isIncluded = config.include?.some(pattern => {
-    return minimatch(relativePath, pattern);
-  }) ?? true;
-
-  if (!isIncluded) return false;
-  
-  // Check exclude patterns
-  const isExcluded = config.exclude?.some(pattern => {
-    return minimatch(relativePath, pattern);
-  }) ?? false;
-  
-  return !isExcluded;
-}
-
-/**
- * Checks if a file is a TypeScript file that can be transformed
- */
-export function isTransformableTypeScriptFile(fileName: string): boolean {
-  // Only transform TypeScript files
-  if (!/\.(ts|tsx)$/.test(fileName)) return false;
-  
-  // Skip declaration files
-  if (fileName.endsWith('.d.ts')) return false;
-  
-  return true;
-}
-
-/**
- * Combined check for both file type and include/exclude patterns
- */
-export function shouldIncludeFile(fileName: string, config: TypicalConfig): boolean {
-  return isTransformableTypeScriptFile(fileName) && shouldTransformFile(fileName, config);
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export { TypicalTransformer } from './transformer.js';
-export { loadConfig, defaultConfig, TypicalConfig } from './config.js';

package/src/patch-fs.cjs

@@ -1,25 +0,0 @@
-// logs all readFile and readFileSync calls (for debugging)
-
-const fs = require("fs");
-const fsp = require("fs/promises");
-
-// monkeypatch promises/readFile
-const origFspReadFile = fsp.readFile;
-fsp.readFile = async function (path, ...args) {
-  console.log("fsp.readFile", path);
-  return origFspReadFile.call(this, path, ...args);
-};
-
-// monkeypatch readFile
-const origFsReadFile = fs.readFile;
-fs.readFile = async function (path, ...args) {
-  console.log("fs.readFile", path);
-  return origFsReadFile.call(this, path, ...args);
-};
-
-// monkeypatch readFileSync
-const origFsReadFileSync = fs.readFileSync;
-fs.readFileSync = function (path, ...args) {
-  console.log("fs.readFileSync", path);
-  return origFsReadFileSync.call(this, path, ...args);
-};

package/src/patch-tsconfig.cjs

@@ -1,52 +0,0 @@
-// monkeypatch fs.readFileSync to automatically add typical/tsc-plugin to tsconfig.json (if not present)
-
-const fs = require("fs");
-const stripJsonComments = require('strip-json-comments').default;
-
-const origFsReadFileSync = fs.readFileSync;
-
-fs.readFileSync = function (path, ...args) {
-  const result = origFsReadFileSync.call(this, path, ...args);
-
-  if (typeof path === "string" && path.endsWith("/tsconfig.json")) {
-    try {
-
-      const json = stripJsonComments(result.toString(), { trailingCommas: true });
-
-      const config = JSON.parse(json);
-      
-      if (!config.compilerOptions) {
-        config.compilerOptions = {};
-      }
-
-      if (!config.compilerOptions.plugins) {
-        config.compilerOptions.plugins = [];
-      }
-
-      const hasTypical = config.compilerOptions.plugins.some(
-        (plugin) => plugin.transform === "typical/tsc-plugin"
-      );
-
-      if (!hasTypical) {
-        if (fs.existsSync("./dist/src/tsc-plugin.js")) {
-          console.log("DEV MODE: Adding ./dist/src/tsc-plugin.js to tsconfig.json");
-          config.compilerOptions.plugins.push({
-            transform: "./dist/src/tsc-plugin.js",
-          });
-        } else {
-          config.compilerOptions.plugins.push({
-            transform: "typical/tsc-plugin",
-          });
-        }
-      }
-
-      // console.log("patched config", JSON.stringify(config, null, 2));
-
-      return JSON.stringify(config, null, 2);
-    } catch (e) {
-      console.error("ERROR patching tsconfig.json to add typical/tsc-plugin", e);
-      throw e;
-    }
-  }
-  return result;
-};

package/src/setup.ts

@@ -1,29 +0,0 @@
-import type ts from "typescript";
-
-export function setupTsProgram(tsInstance: typeof ts): ts.Program {
-  // Find tsconfig.json
-  const tsConfigPath = tsInstance.findConfigFile(
-    process.cwd(),
-    tsInstance.sys.fileExists,
-    "tsconfig.json"
-  );
-  if (!tsConfigPath) {
-    throw new Error("Could not find tsconfig.json");
-  }
-
-  // Load and parse tsconfig.json
-  const configFile = tsInstance.readConfigFile(tsConfigPath, tsInstance.sys.readFile);
-  const parsedConfig = tsInstance.parseJsonConfigFileContent(
-    configFile.config,
-    tsInstance.sys,
-    process.cwd()
-  );
-
-  // Create the TypeScript program with all project files
-  const tsProgram = tsInstance.createProgram(
-    parsedConfig.fileNames,
-    parsedConfig.options
-  );
-
-  return tsProgram;
-}

package/src/transformer.ts

@@ -1,831 +0,0 @@
-import ts from "typescript";
-import { loadConfig, TypicalConfig } from "./config.js";
-import { shouldTransformFile } from "./file-filter.js";
-
-import { transform as typiaTransform } from "typia/lib/transform.js";
-import { setupTsProgram } from "./setup.js";
-
-export interface TransformContext {
-  ts: typeof ts;
-  factory: ts.NodeFactory;
-  context: ts.TransformationContext;
-}
-
-export class TypicalTransformer {
-  public config: TypicalConfig;
-  private program: ts.Program;
-  private ts: typeof ts;
-  private typeValidators = new Map<
-    string,
-    { name: string; typeNode: ts.TypeNode }
-  >(); // type -> { validator variable name, type node }
-  private typeStringifiers = new Map<
-    string,
-    { name: string; typeNode: ts.TypeNode }
-  >(); // type -> { stringifier variable name, type node }
-  private typeParsers = new Map<
-    string,
-    { name: string; typeNode: ts.TypeNode }
-  >(); // type -> { parser variable name, type node }
-
-  constructor(
-    config?: TypicalConfig,
-    program?: ts.Program,
-    tsInstance?: typeof ts
-  ) {
-    this.config = config ?? loadConfig();
-    this.ts = tsInstance ?? ts;
-    this.program = program ?? setupTsProgram(this.ts);
-  }
-
-  public createSourceFile(fileName: string, content: string): ts.SourceFile {
-    return this.ts.createSourceFile(
-      fileName,
-      content,
-      this.ts.ScriptTarget.ES2020,
-      true
-    );
-  }
-
-  public transform(
-    sourceFile: ts.SourceFile | string,
-    mode: "basic" | "typia" | "js"
-  ): string {
-    if (typeof sourceFile === "string") {
-      const file = this.program.getSourceFile(sourceFile);
-      if (!file) {
-        throw new Error(`Source file not found in program: ${sourceFile}`);
-      }
-      sourceFile = file;
-    }
-
-    const transformer = this.getTransformer(mode !== "basic");
-    const result = this.ts.transform(sourceFile, [transformer]);
-    const printer = this.ts.createPrinter();
-    const transformedCode = printer.printFile(result.transformed[0]);
-    result.dispose();
-
-    if (mode === "typia" || mode === 'basic') {
-      return transformedCode;
-    }
-
-    const compileResult = ts.transpileModule(transformedCode, {
-      compilerOptions: this.program.getCompilerOptions(),
-    });
-
-    return compileResult.outputText;
-  }
-
-  public getTransformer(
-    withTypia: boolean
-  ): ts.TransformerFactory<ts.SourceFile> {
-    return (context: ts.TransformationContext) => {
-      const factory = context.factory;
-      const typeChecker = this.program.getTypeChecker();
-      const transformContext: TransformContext = {
-        ts: this.ts,
-        factory,
-        context,
-      };
-
-      return (sourceFile: ts.SourceFile) => {
-
-        if (process.env.DEBUG) {
-          console.log("TYPICAL: processing ", sourceFile.fileName);
-        }
-        // First apply our transformation
-        let transformedSourceFile = this.transformSourceFile(
-          sourceFile,
-          transformContext,
-          typeChecker
-        );
-
-        if (!withTypia) {
-          return transformedSourceFile;
-        }
-
-        // Then apply typia if we added typia calls
-        const printer = this.ts.createPrinter();
-        const transformedCode = printer.printFile(transformedSourceFile);
-
-        if (transformedCode.includes("typia.")) {
-          try {
-            // Apply typia transformation to files with typia calls
-
-            // Create a new source file with the transformed code, preserving original filename
-            const newSourceFile = this.ts.createSourceFile(
-              sourceFile.fileName, // Use original filename to maintain source map references
-              transformedCode,
-              sourceFile.languageVersion,
-              true
-            );
-
-            // Create a new program with the transformed source file so typia's type checker works
-            const compilerOptions = this.program.getCompilerOptions();
-            const originalSourceFiles = new Map<string, ts.SourceFile>();
-            for (const sf of this.program.getSourceFiles()) {
-              originalSourceFiles.set(sf.fileName, sf);
-            }
-            // Replace the original source file with the transformed one
-            originalSourceFiles.set(sourceFile.fileName, newSourceFile);
-
-            const customHost: ts.CompilerHost = {
-              getSourceFile: (fileName, languageVersion) => {
-                if (originalSourceFiles.has(fileName)) {
-                  return originalSourceFiles.get(fileName);
-                }
-                return this.ts.createSourceFile(
-                  fileName,
-                  this.ts.sys.readFile(fileName) || "",
-                  languageVersion,
-                  true
-                );
-              },
-              getDefaultLibFileName: () => this.ts.getDefaultLibFilePath(compilerOptions),
-              writeFile: () => {},
-              getCurrentDirectory: () => this.ts.sys.getCurrentDirectory(),
-              getCanonicalFileName: (fileName) =>
-                this.ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
-              useCaseSensitiveFileNames: () => this.ts.sys.useCaseSensitiveFileNames,
-              getNewLine: () => this.ts.sys.newLine,
-              fileExists: (fileName) => originalSourceFiles.has(fileName) || this.ts.sys.fileExists(fileName),
-              readFile: (fileName) => this.ts.sys.readFile(fileName),
-            };
-
-            const newProgram = this.ts.createProgram(
-              Array.from(originalSourceFiles.keys()),
-              compilerOptions,
-              customHost
-            );
-
-            // Create typia transformer with the NEW program that has the transformed source
-            const typiaTransformer = typiaTransform(
-              newProgram,
-              {},
-              {
-                addDiagnostic(diag: ts.Diagnostic) {
-                  console.warn("Typia diagnostic:", diag);
-                  return 0;
-                },
-              }
-            );
-
-            // Apply the transformer with source map preservation
-            const transformationResult = this.ts.transform(
-              newSourceFile,
-              [typiaTransformer],
-              { ...compilerOptions, sourceMap: true }
-            );
-
-            if (transformationResult.transformed.length > 0) {
-              const finalTransformed = transformationResult.transformed[0];
-              transformedSourceFile = finalTransformed;
-
-              // Typia transformation completed successfully
-            }
-
-            transformationResult.dispose();
-          } catch (error) {
-            console.warn("Failed to apply typia transformer:", sourceFile.fileName, error);
-          }
-        }
-
-        return transformedSourceFile;
-      };
-    };
-  }
-
-  /**
-   * Transform a single source file with TypeScript AST
-   */
-  private transformSourceFile(
-    sourceFile: ts.SourceFile,
-    ctx: TransformContext,
-    typeChecker: ts.TypeChecker
-  ): ts.SourceFile {
-    const { ts } = ctx;
-
-    // Check if this file should be transformed
-    if (!this.shouldTransformFile(sourceFile.fileName)) {
-      return sourceFile; // Return unchanged for excluded files
-    }
-
-    // Check if this file has already been transformed by us
-    const sourceText = sourceFile.getFullText();
-    if (sourceText.includes('__typical_assert_') || sourceText.includes('__typical_stringify_') || sourceText.includes('__typical_parse_')) {
-      throw new Error(`File ${sourceFile.fileName} has already been transformed by Typical! Double transformation detected.`);
-    }
-
-    // Reset caches for each file
-    this.typeValidators.clear();
-    this.typeStringifiers.clear();
-    this.typeParsers.clear();
-
-    let needsTypiaImport = false;
-
-    const visit = (node: ts.Node): ts.Node => {
-      // Transform JSON calls first (before they get wrapped in functions)
-      if (
-        ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression)
-      ) {
-        const propertyAccess = node.expression;
-        if (
-          ts.isIdentifier(propertyAccess.expression) &&
-          propertyAccess.expression.text === "JSON"
-        ) {
-          needsTypiaImport = true;
-
-          if (propertyAccess.name.text === "stringify") {
-            // For stringify, we need to infer the type from the argument
-            if (this.config.reusableValidators) {
-              // For JSON.stringify, try to infer the type from the argument
-              let typeText = "unknown";
-              let typeNodeForCache: ts.TypeNode | undefined;
-
-              if (node.arguments.length > 0) {
-                const arg = node.arguments[0];
-
-                // Check if it's a type assertion
-                if (ts.isAsExpression(arg)) {
-                  // For type assertions, use the asserted type directly
-                  const assertedType = arg.type;
-                  const objectType =
-                    typeChecker.getTypeFromTypeNode(assertedType);
-
-                  const typeNode = assertedType;
-
-                  if (typeNode) {
-                    const typeString = typeChecker.typeToString(objectType);
-                    typeText = `Asserted_${typeString.replace(
-                      /[^a-zA-Z0-9_]/g,
-                      "_"
-                    )}`;
-                    typeNodeForCache = typeNode;
-                  } else {
-                    typeText = "unknown";
-                    typeNodeForCache = ctx.factory.createKeywordTypeNode(
-                      ctx.ts.SyntaxKind.UnknownKeyword
-                    );
-                  }
-                } else if (ts.isObjectLiteralExpression(arg)) {
-                  // For object literals, use the type checker to get the actual type
-                  const objectType = typeChecker.getTypeAtLocation(arg);
-
-                  const typeNode = typeChecker.typeToTypeNode(
-                    objectType,
-                    arg,
-                    ts.NodeBuilderFlags.InTypeAlias
-                  );
-
-                  if (typeNode) {
-                    const propNames = arg.properties
-                      .map((prop) => {
-                        if (ts.isShorthandPropertyAssignment(prop)) {
-                          return prop.name.text;
-                        } else if (
-                          ts.isPropertyAssignment(prop) &&
-                          ts.isIdentifier(prop.name)
-                        ) {
-                          return prop.name.text;
-                        }
-                        return "unknown";
-                      })
-                      .sort()
-                      .join("_");
-
-                    typeText = `ObjectLiteral_${propNames}`;
-                    typeNodeForCache = typeNode;
-                  } else {
-                    // typeText = "unknown";
-                    // typeNodeForCache = ctx.factory.createKeywordTypeNode(
-                    //   ctx.ts.SyntaxKind.UnknownKeyword
-                    // );
-                    throw new Error('unknown type node for object literal: ' + arg.getText());
-                  }
-                } else {
-                  // For other expressions, try to get the type from the type checker
-                  const argType = typeChecker.getTypeAtLocation(arg);
-
-                  const typeNode = typeChecker.typeToTypeNode(
-                    argType,
-                    arg,
-                    ts.NodeBuilderFlags.InTypeAlias
-                  );
-                  if (typeNode) {
-                    const typeString = typeChecker.typeToString(argType);
-                    typeText = `Expression_${typeString.replace(
-                      /[^a-zA-Z0-9_]/g,
-                      "_"
-                    )}`;
-                    typeNodeForCache = typeNode;
-                  } else {
-                    typeText = "unknown";
-                    typeNodeForCache = ctx.factory.createKeywordTypeNode(
-                      ctx.ts.SyntaxKind.UnknownKeyword
-                    )
-                  }
-                }
-              }
-
-              const stringifierName = this.getOrCreateStringifier(
-                typeText,
-                typeNodeForCache!
-              );
-
-              const newCall = ctx.factory.createCallExpression(
-                ctx.factory.createIdentifier(stringifierName),
-                undefined,
-                node.arguments
-              );
-
-              return newCall;
-            } else {
-              // Use inline typia.json.stringify
-              return ctx.factory.updateCallExpression(
-                node,
-                ctx.factory.createPropertyAccessExpression(
-                  ctx.factory.createPropertyAccessExpression(
-                    ctx.factory.createIdentifier("typia"),
-                    "json"
-                  ),
-                  "stringify"
-                ),
-                node.typeArguments,
-                node.arguments
-              );
-            }
-          } else if (propertyAccess.name.text === "parse") {
-            // For JSON.parse, we need to infer the expected type from context
-            // Check if this is part of a variable declaration or type assertion
-            let targetType: ts.TypeNode | undefined;
-
-            // Look for type annotations in parent nodes
-            let parent = node.parent;
-            while (parent) {
-              if (ts.isVariableDeclaration(parent) && parent.type) {
-                targetType = parent.type;
-                break;
-              } else if (ts.isAsExpression(parent)) {
-                targetType = parent.type;
-                break;
-              } else if (ts.isReturnStatement(parent)) {
-                // Look for function return type
-                let funcParent = parent.parent;
-                while (funcParent) {
-                  if (
-                    (ts.isFunctionDeclaration(funcParent) ||
-                      ts.isArrowFunction(funcParent) ||
-                      ts.isMethodDeclaration(funcParent)) &&
-                    funcParent.type
-                  ) {
-                    targetType = funcParent.type;
-                    break;
-                  }
-                  funcParent = funcParent.parent;
-                }
-                break;
-              }
-              parent = parent.parent;
-            }
-
-            if (this.config.reusableValidators && targetType) {
-              // Use reusable parser - use typeToString
-              const targetTypeObj = typeChecker.getTypeFromTypeNode(targetType);
-              const typeText = typeChecker.typeToString(targetTypeObj);
-              const parserName = this.getOrCreateParser(typeText, targetType);
-
-              const newCall = ctx.factory.createCallExpression(
-                ctx.factory.createIdentifier(parserName),
-                undefined,
-                node.arguments
-              );
-
-              return newCall;
-            } else {
-              // Use inline typia.json.assertParse
-              const typeArguments = targetType
-                ? [targetType]
-                : node.typeArguments;
-
-              return ctx.factory.updateCallExpression(
-                node,
-                ctx.factory.createPropertyAccessExpression(
-                  ctx.factory.createPropertyAccessExpression(
-                    ctx.factory.createIdentifier("typia"),
-                    "json"
-                  ),
-                  "assertParse"
-                ),
-                typeArguments,
-                node.arguments
-              );
-            }
-          }
-        }
-      }
-
-      // Transform function declarations
-      if (ts.isFunctionDeclaration(node)) {
-        needsTypiaImport = true;
-        return transformFunction(node);
-      }
-
-      // Transform arrow functions
-      if (ts.isArrowFunction(node)) {
-        needsTypiaImport = true;
-        return transformFunction(node);
-      }
-
-      // Transform method declarations
-      if (ts.isMethodDeclaration(node)) {
-        needsTypiaImport = true;
-        return transformFunction(node);
-      }
-
-      return ctx.ts.visitEachChild(node, visit, ctx.context);
-    };
-
-    const transformFunction = (
-      func: ts.FunctionDeclaration | ts.ArrowFunction | ts.MethodDeclaration
-    ): ts.Node => {
-      const body = func.body;
-      if (!body || !ts.isBlock(body)) return func;
-
-      // Add parameter validation
-      const validationStatements: ts.Statement[] = [];
-
-      func.parameters.forEach((param) => {
-        if (param.type) {
-          const paramName = ts.isIdentifier(param.name)
-            ? param.name.text
-            : "param";
-          const paramIdentifier = ctx.factory.createIdentifier(paramName);
-
-          if (this.config.reusableValidators) {
-            // Use reusable validators - use typeToString
-            const paramType = typeChecker.getTypeFromTypeNode(param.type);
-            const typeText = typeChecker.typeToString(paramType);
-            const validatorName = this.getOrCreateValidator(
-              typeText,
-              param.type
-            );
-
-            const validatorCall = ctx.factory.createCallExpression(
-              ctx.factory.createIdentifier(validatorName),
-              undefined,
-              [paramIdentifier]
-            );
-            const assertCall =
-              ctx.factory.createExpressionStatement(validatorCall);
-
-            validationStatements.push(assertCall);
-          } else {
-            // Use inline typia.assert calls
-            const typiaIdentifier = ctx.factory.createIdentifier("typia");
-            const assertIdentifier = ctx.factory.createIdentifier("assert");
-            const propertyAccess = ctx.factory.createPropertyAccessExpression(
-              typiaIdentifier,
-              assertIdentifier
-            );
-            const callExpression = ctx.factory.createCallExpression(
-              propertyAccess,
-              [param.type],
-              [paramIdentifier]
-            );
-            const assertCall =
-              ctx.factory.createExpressionStatement(callExpression);
-
-            validationStatements.push(assertCall);
-          }
-        }
-      });
-
-      // First visit all child nodes (including JSON calls) before adding validation
-      const visitedBody = ctx.ts.visitNode(body, visit) as ts.Block;
-
-      // Transform return statements - use explicit type or infer from type checker
-      let transformedStatements = visitedBody.statements;
-      let returnType = func.type;
-
-      // If no explicit return type, try to infer it from the type checker
-      let returnTypeForString: ts.Type | undefined;
-      if (!returnType) {
-        const signature = typeChecker.getSignatureFromDeclaration(func);
-        if (signature) {
-          const inferredReturnType = typeChecker.getReturnTypeOfSignature(signature);
-          returnType = typeChecker.typeToTypeNode(
-            inferredReturnType,
-            func,
-            ts.NodeBuilderFlags.InTypeAlias
-          );
-          returnTypeForString = inferredReturnType;
-        }
-      } else {
-        // For explicit return types, get the Type from the TypeNode
-        returnTypeForString = typeChecker.getTypeFromTypeNode(returnType);
-      }
-
-      if (returnType && returnTypeForString) {
-        const returnTransformer = (node: ts.Node): ts.Node => {
-          if (ts.isReturnStatement(node) && node.expression) {
-            if (this.config.reusableValidators) {
-              // Use reusable validators - always use typeToString
-              const returnTypeText = typeChecker.typeToString(returnTypeForString!);
-              const validatorName = this.getOrCreateValidator(
-                returnTypeText,
-                returnType
-              );
-
-              const validatorCall = ctx.factory.createCallExpression(
-                ctx.factory.createIdentifier(validatorName),
-                undefined,
-                [node.expression]
-              );
-
-              return ctx.factory.updateReturnStatement(node, validatorCall);
-            } else {
-              // Use inline typia.assert calls
-              const typiaIdentifier = ctx.factory.createIdentifier("typia");
-              const assertIdentifier = ctx.factory.createIdentifier("assert");
-              const propertyAccess = ctx.factory.createPropertyAccessExpression(
-                typiaIdentifier,
-                assertIdentifier
-              );
-              const callExpression = ctx.factory.createCallExpression(
-                propertyAccess,
-                [returnType],
-                [node.expression]
-              );
-
-              return ctx.factory.updateReturnStatement(node, callExpression);
-            }
-          }
-          return ctx.ts.visitEachChild(node, returnTransformer, ctx.context);
-        };
-
-        transformedStatements = ctx.ts.visitNodes(
-          visitedBody.statements,
-          returnTransformer
-        ) as ts.NodeArray<ts.Statement>;
-      }
-
-      // Insert validation statements at the beginning
-      const newStatements = ctx.factory.createNodeArray([
-        ...validationStatements,
-        ...transformedStatements,
-      ]);
-      const newBody = ctx.factory.updateBlock(visitedBody, newStatements);
-
-      if (ts.isFunctionDeclaration(func)) {
-        return ctx.factory.updateFunctionDeclaration(
-          func,
-          func.modifiers,
-          func.asteriskToken,
-          func.name,
-          func.typeParameters,
-          func.parameters,
-          func.type,
-          newBody
-        );
-      } else if (ts.isArrowFunction(func)) {
-        return ctx.factory.updateArrowFunction(
-          func,
-          func.modifiers,
-          func.typeParameters,
-          func.parameters,
-          func.type,
-          func.equalsGreaterThanToken,
-          newBody
-        );
-      } else if (ts.isMethodDeclaration(func)) {
-        return ctx.factory.updateMethodDeclaration(
-          func,
-          func.modifiers,
-          func.asteriskToken,
-          func.name,
-          func.questionToken,
-          func.typeParameters,
-          func.parameters,
-          func.type,
-          newBody
-        );
-      }
-
-      return func;
-    };
-
-    let transformedSourceFile = ctx.ts.visitNode(
-      sourceFile,
-      visit
-    ) as ts.SourceFile;
-
-    // Add typia import and validator statements if needed
-    if (needsTypiaImport) {
-      transformedSourceFile = this.addTypiaImport(transformedSourceFile, ctx);
-
-      // Add validator statements after imports (only if using reusable validators)
-      if (this.config.reusableValidators) {
-        const validatorStmts = this.createValidatorStatements(ctx);
-
-        if (validatorStmts.length > 0) {
-          const importStatements = transformedSourceFile.statements.filter(
-            ctx.ts.isImportDeclaration
-          );
-          const otherStatements = transformedSourceFile.statements.filter(
-            (stmt) => !ctx.ts.isImportDeclaration(stmt)
-          );
-
-          const newStatements = ctx.factory.createNodeArray([
-            ...importStatements,
-            ...validatorStmts,
-            ...otherStatements,
-          ]);
-
-          transformedSourceFile = ctx.factory.updateSourceFile(
-            transformedSourceFile,
-            newStatements
-          );
-        }
-      }
-    }
-
-    return transformedSourceFile;
-  }
-
-  public shouldTransformFile(fileName: string): boolean {
-    return shouldTransformFile(fileName, this.config);
-  }
-
-  private addTypiaImport(
-    sourceFile: ts.SourceFile,
-    ctx: TransformContext
-  ): ts.SourceFile {
-    const { factory } = ctx;
-
-    const existingImports = sourceFile.statements.filter(
-      ctx.ts.isImportDeclaration
-    );
-    const hasTypiaImport = existingImports.some(
-      (imp) =>
-        imp.moduleSpecifier &&
-        ctx.ts.isStringLiteral(imp.moduleSpecifier) &&
-        imp.moduleSpecifier.text === "typia"
-    );
-
-    if (!hasTypiaImport) {
-      const typiaImport = factory.createImportDeclaration(
-        undefined,
-        factory.createImportClause(
-          false,
-          factory.createIdentifier("typia"),
-          undefined
-        ),
-        factory.createStringLiteral("typia")
-      );
-
-      const newSourceFile = factory.updateSourceFile(
-        sourceFile,
-        factory.createNodeArray([typiaImport, ...sourceFile.statements])
-      );
-
-      return newSourceFile;
-    }
-
-    return sourceFile;
-  }
-
-  private getOrCreateValidator(
-    typeText: string,
-    typeNode: ts.TypeNode
-  ): string {
-    if (this.typeValidators.has(typeText)) {
-      return this.typeValidators.get(typeText)!.name;
-    }
-
-    const validatorName = `__typical_assert_${this.typeValidators.size}`;
-    this.typeValidators.set(typeText, { name: validatorName, typeNode });
-    return validatorName;
-  }
-
-  private getOrCreateStringifier(
-    typeText: string,
-    typeNode: ts.TypeNode
-  ): string {
-    if (this.typeStringifiers.has(typeText)) {
-      return this.typeStringifiers.get(typeText)!.name;
-    }
-
-    const stringifierName = `__typical_stringify_${this.typeStringifiers.size}`;
-    this.typeStringifiers.set(typeText, { name: stringifierName, typeNode });
-    return stringifierName;
-  }
-
-  private getOrCreateParser(typeText: string, typeNode: ts.TypeNode): string {
-    if (this.typeParsers.has(typeText)) {
-      return this.typeParsers.get(typeText)!.name;
-    }
-
-    const parserName = `__typical_parse_${this.typeParsers.size}`;
-    this.typeParsers.set(typeText, { name: parserName, typeNode });
-    return parserName;
-  }
-
-  private createValidatorStatements(ctx: TransformContext): ts.Statement[] {
-    const { factory } = ctx;
-    const statements: ts.Statement[] = [];
-
-    // Create assert validators
-    for (const [, { name: validatorName, typeNode }] of this.typeValidators) {
-      const createAssertCall = factory.createCallExpression(
-        factory.createPropertyAccessExpression(
-          factory.createIdentifier("typia"),
-          "createAssert"
-        ),
-        [typeNode],
-        []
-      );
-
-      const validatorDeclaration = factory.createVariableStatement(
-        undefined,
-        factory.createVariableDeclarationList(
-          [
-            factory.createVariableDeclaration(
-              validatorName,
-              undefined,
-              undefined,
-              createAssertCall
-            ),
-          ],
-          ctx.ts.NodeFlags.Const
-        )
-      );
-      statements.push(validatorDeclaration);
-    }
-
-    // Create stringifiers
-    for (const [, { name: stringifierName, typeNode }] of this
-      .typeStringifiers) {
-      const createStringifyCall = factory.createCallExpression(
-        factory.createPropertyAccessExpression(
-          factory.createPropertyAccessExpression(
-            factory.createIdentifier("typia"),
-            "json"
-          ),
-          "createStringify"
-        ),
-        [typeNode],
-        []
-      );
-
-      const stringifierDeclaration = factory.createVariableStatement(
-        undefined,
-        factory.createVariableDeclarationList(
-          [
-            factory.createVariableDeclaration(
-              stringifierName,
-              undefined,
-              undefined,
-              createStringifyCall
-            ),
-          ],
-          ctx.ts.NodeFlags.Const
-        )
-      );
-      statements.push(stringifierDeclaration);
-    }
-
-    // Create parsers
-    for (const [, { name: parserName, typeNode }] of this.typeParsers) {
-      const createParseCall = factory.createCallExpression(
-        factory.createPropertyAccessExpression(
-          factory.createPropertyAccessExpression(
-            factory.createIdentifier("typia"),
-            "json"
-          ),
-          "createAssertParse"
-        ),
-        [typeNode],
-        []
-      );
-
-      const parserDeclaration = factory.createVariableStatement(
-        undefined,
-        factory.createVariableDeclarationList(
-          [
-            factory.createVariableDeclaration(
-              parserName,
-              undefined,
-              undefined,
-              createParseCall
-            ),
-          ],
-          ctx.ts.NodeFlags.Const
-        )
-      );
-      statements.push(parserDeclaration);
-    }
-
-    return statements;
-  }
-}

package/src/tsc-plugin.ts

@@ -1,12 +0,0 @@
-import type ts from 'typescript';
-import type { TransformerExtras, PluginConfig } from 'ts-patch';
-import { TypicalTransformer } from './transformer.js';
-import { loadConfig } from './config.js';
-
-export default function (program: ts.Program, pluginConfig: PluginConfig, { ts: tsInstance }: TransformerExtras) {
-  const config = loadConfig();
-  const transformer = new TypicalTransformer(config, program, tsInstance);
-  
-  // Create the typical transformer with typia integration
-  return transformer.getTransformer(true);
-}