@elliots/typical 0.2.3 → 0.2.5

package/dist/src/transformer.js

@@ -5,16 +5,16 @@
  * and validation code generation. This class just manages the lifecycle
  * and communication with the Go process.
  */
-import { resolve } from 'path';
-import { TypicalCompiler } from '@elliots/typical-compiler';
-import { loadConfig } from './config.js';
+import { resolve } from "path";
+import { TypicalCompiler } from "@elliots/typical-compiler";
+import { loadConfig } from "./config.js";
 export class TypicalTransformer {
     config;
     compiler;
     projectHandle = null;
     initPromise = null;
     configFile;
-    constructor(config, configFile = 'tsconfig.json') {
+    constructor(config, configFile = "tsconfig.json") {
         this.config = config ?? loadConfig();
         this.configFile = configFile;
         this.compiler = new TypicalCompiler({ cwd: process.cwd() });
@@ -23,7 +23,7 @@ export class TypicalTransformer {
      * Ensure the Go compiler is started and project is loaded.
      * Uses lazy initialization - only starts on first transform.
      */
-    async ensureInitialized() {
+    async ensureInitialized(x) {
         if (!this.initPromise) {
             this.initPromise = (async () => {
                 await this.compiler.start();
@@ -39,14 +39,14 @@ export class TypicalTransformer {
      * @param mode - Output mode: 'ts' returns TypeScript, 'js' would transpile (not yet supported)
      * @returns Transformed code with validation
      */
-    async transform(fileName, mode = 'ts') {
-        if (mode === 'js') {
+    async transform(fileName, mode = "ts") {
+        if (mode === "js") {
             throw new Error('Mode "js" not yet supported - use "ts" and transpile separately');
         }
         await this.ensureInitialized();
         const resolvedPath = resolve(fileName);
         // Pass config options to the Go compiler
-        const result = await this.compiler.transformFile(this.projectHandle, resolvedPath, this.config.ignoreTypes, this.config.maxGeneratedFunctions, this.config.reusableValidators);
+        const result = await this.compiler.transformFile(this.projectHandle, resolvedPath, this.config.ignoreTypes, this.config.maxGeneratedFunctions);
         return {
             code: result.code,
             map: result.sourceMap ?? null,

package/dist/src/transformer.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.js","sourceRoot":"","sources":["../../src/transformer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAC9B,OAAO,EAAE,eAAe,EAAyC,MAAM,2BAA2B,CAAA;AAElG,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAOxC,MAAM,OAAO,kBAAkB;IACtB,MAAM,CAAe;IACpB,QAAQ,CAAiB;IACzB,aAAa,GAAyB,IAAI,CAAA;IAC1C,WAAW,GAAyB,IAAI,CAAA;IACxC,UAAU,CAAQ;IAE1B,YAAY,MAAsB,EAAE,aAAqB,eAAe;QACtE,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,UAAU,EAAE,CAAA;QACpC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,eAAe,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;IAC7D,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,iBAAiB;QAC7B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,GAAG,CAAC,KAAK,IAAI,EAAE;gBAC7B,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;gBAC3B,IAAI,CAAC,aAAa,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YACvE,CAAC,CAAC,EAAE,CAAA;QACN,CAAC;QACD,MAAM,IAAI,CAAC,WAAW,CAAA;IACxB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,SAAS,CAAC,QAAgB,EAAE,OAAoB,IAAI;QACxD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAA;QACpF,CAAC;QAED,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAA;QAE9B,MAAM,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;QACtC,yCAAyC;QACzC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,aAAc,EAAE,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAA;QAE/K,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,GAAG,EAAE,MAAM,CAAC,SAAS,IAAI,IAAI;SAC9B,CAAA;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QACzB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAA;QACvB,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;IAC7B,CAAC;CACF"}
+{"version":3,"file":"transformer.js","sourceRoot":"","sources":["../../src/transformer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAyC,MAAM,2BAA2B,CAAC;AAEnG,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAOzC,MAAM,OAAO,kBAAkB;IACtB,MAAM,CAAgB;IACrB,QAAQ,CAAkB;IAC1B,aAAa,GAAyB,IAAI,CAAC;IAC3C,WAAW,GAAyB,IAAI,CAAC;IACzC,UAAU,CAAS;IAE3B,YAAY,MAAsB,EAAE,aAAqB,eAAe;QACtE,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,UAAU,EAAE,CAAC;QACrC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,IAAI,eAAe,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,iBAAiB,CAAC,CAAU;QACxC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,GAAG,CAAC,KAAK,IAAI,EAAE;gBAC7B,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;gBAC5B,IAAI,CAAC,aAAa,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACxE,CAAC,CAAC,EAAE,CAAC;QACP,CAAC;QACD,MAAM,IAAI,CAAC,WAAW,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,SAAS,CAAC,QAAgB,EAAE,OAAoB,IAAI;QACxD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;QACrF,CAAC;QAED,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE/B,MAAM,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QACvC,yCAAyC;QACzC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAC9C,IAAI,CAAC,aAAc,EACnB,YAAY,EACZ,IAAI,CAAC,MAAM,CAAC,WAAW,EACvB,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAClC,CAAC;QAEF,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,GAAG,EAAE,MAAM,CAAC,SAAS,IAAI,IAAI;SAC9B,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliots/typical",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Runtime safe TypeScript transformer using typia",
   "keywords": [
     "runtime",
@@ -40,7 +40,7 @@
   },
   "dependencies": {
     "commander": "14.0.2",
-    "@elliots/typical-compiler": "0.2.3"
+    "@elliots/typical-compiler": "0.2.5"
   },
   "devDependencies": {
     "@types/node": "22",
@@ -61,11 +61,11 @@
     "lint:fix": "oxlint --type-aware --fix",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
-    "build": "tsc",
-    "build:all": "pnpm run build:go:all && pnpm run build:ts",
+    "build": "pnpm run build:go:all && pnpm run build:ts",
     "build:go": "cd packages/compiler && npm run build:go",
     "build:go:all": "./scripts/build-binaries.sh",
-    "build:ts": "pnpm --filter './packages/*' run build && pnpm run build",
+    "build:ts": "pnpm --filter './packages/*' run build && tsc",
+    "build:website": "pnpm --filter typical-website run build",
     "dev": "tsc --watch",
     "test": "rm -f test/test.temp.ts && tsc && node --import ./dist/src/esm-loader-register.js --test dist/test/*.test.js",
     "test:coverage": "rm -f test/test.temp.ts && tsc && node --import ./dist/src/esm-loader-register.js --test --experimental-test-coverage dist/test/*.test.js",

package/src/cli.ts

@@ -1,58 +1,58 @@
 #!/usr/bin/env node
 
-import { Command } from 'commander'
-import * as fs from 'fs'
-import * as path from 'path'
-import { TypicalTransformer } from './transformer.js'
-import { loadConfig, validateConfig } from './config.js'
+import { Command } from "commander";
+import * as fs from "fs";
+import * as path from "path";
+import { TypicalTransformer } from "./transformer.js";
+import { loadConfig, validateConfig } from "./config.js";
 
-const program = new Command()
+const program = new Command();
 
-program.name('typical').description('Runtime safe TypeScript transformer').version('0.1.0')
+program.name("typical").description("Runtime safe TypeScript transformer").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('-p, --project <file>', 'TypeScript config file path', 'tsconfig.json')
+  .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("-p, --project <file>", "TypeScript config file path", "tsconfig.json")
   .action(
     async (
       file: string,
       options: {
-        output?: string
-        config?: string
-        project?: string
+        output?: string;
+        config?: string;
+        project?: string;
       },
     ) => {
-      let transformer: TypicalTransformer | null = null
+      let transformer: TypicalTransformer | null = null;
       try {
-        const config = validateConfig(loadConfig(options.config))
-        transformer = new TypicalTransformer(config, options.project)
+        const config = validateConfig(loadConfig(options.config));
+        transformer = new TypicalTransformer(config, options.project);
 
         if (!fs.existsSync(file)) {
-          console.error(`File not found: ${file}`)
-          process.exit(1)
+          console.error(`File not found: ${file}`);
+          process.exit(1);
         }
 
-        console.log(`Transforming ${file}...`)
-        const result = await transformer.transform(path.resolve(file), 'ts')
+        console.log(`Transforming ${file}...`);
+        const result = await transformer.transform(path.resolve(file), "ts");
 
         // Determine output file path
-        const outputFile = options.output ? path.resolve(options.output) : file + '.transformed.ts'
+        const outputFile = options.output ? path.resolve(options.output) : file + ".transformed.ts";
 
-        fs.writeFileSync(outputFile, result.code)
-        console.log(`Transformed code written to ${outputFile}`)
+        fs.writeFileSync(outputFile, result.code);
+        console.log(`Transformed code written to ${outputFile}`);
       } catch (error) {
-        console.error('Transformation failed:', error)
-        process.exit(1)
+        console.error("Transformation failed:", error);
+        process.exit(1);
       } finally {
         if (transformer) {
-          await transformer.close()
+          await transformer.close();
         }
       }
     },
-  )
+  );
 
-program.parse()
+program.parse();

package/src/config.ts

@@ -1,5 +1,5 @@
 export interface TypicalDebugConfig {
-  writeIntermediateFiles?: boolean
+  writeIntermediateFiles?: boolean;
 }
 
 /**
@@ -9,59 +9,52 @@ export interface TypicalSourceMapConfig {
   /**
    * Generate source maps. Default: true
    */
-  enabled?: boolean
+  enabled?: boolean;
   /**
    * Include original source content in the map. Default: true
    */
-  includeContent?: boolean
+  includeContent?: boolean;
   /**
    * Use inline source maps (data URL) instead of external files. Default: false
    */
-  inline?: boolean
+  inline?: boolean;
 }
 
 export interface TypicalConfig {
-  include?: string[]
-  exclude?: string[]
-  /**
-   * Controls whether validators are hoisted to module scope for reuse.
-   * - 'auto' (default): Hoist only validators used more than once
-   * - 'never': Never hoist, always generate inline validators
-   * - 'always': Always hoist validators, even if only used once
-   */
-  reusableValidators?: 'auto' | 'never' | 'always'
-  validateCasts?: boolean
-  hoistRegex?: boolean
-  debug?: TypicalDebugConfig
+  include?: string[];
+  exclude?: string[];
+  validateCasts?: boolean;
+  hoistRegex?: boolean;
+  debug?: TypicalDebugConfig;
   /**
    * Type patterns to skip validation for (supports wildcards).
    * Use this for types that typia cannot process (e.g., React event types).
    * Example: ["React.*", "Express.Request", "*.Event"]
    */
-  ignoreTypes?: string[]
+  ignoreTypes?: string[];
   /**
    * Validate function parameters and return types at runtime.
    * When enabled, typed function parameters get runtime validation calls injected.
    * Default: true
    */
-  validateFunctions?: boolean
+  validateFunctions?: boolean;
   /**
    * Transform JSON.parse<T>() calls to validate and filter the parsed result
    * to only include properties defined in type T.
    * Default: true
    */
-  transformJSONParse?: boolean
+  transformJSONParse?: boolean;
   /**
    * Transform JSON.stringify<T>() calls to only stringify properties defined
    * in type T, preventing accidental data leaks.
    * Default: true
    */
-  transformJSONStringify?: boolean
+  transformJSONStringify?: boolean;
   /**
    * Source map generation settings.
    * Controls whether and how source maps are generated for transformed code.
    */
-  sourceMap?: TypicalSourceMapConfig
+  sourceMap?: TypicalSourceMapConfig;
   /**
    * Maximum number of helper functions (_io0, _io1, etc.) that can be generated
    * for a single type before erroring. Complex DOM types or library types can
@@ -69,13 +62,12 @@ export interface TypicalConfig {
    * Set to 0 to disable the limit.
    * Default: 50
    */
-  maxGeneratedFunctions?: number
+  maxGeneratedFunctions?: number;
 }
 
 export const defaultConfig: TypicalConfig = {
-  include: ['**/*.ts', '**/*.tsx'],
-  exclude: ['node_modules/**', '**/*.d.ts', 'dist/**', 'build/**'],
-  reusableValidators: 'auto', // Hoists validators to module scope for reduced code size
+  include: ["**/*.ts", "**/*.tsx"],
+  exclude: ["node_modules/**", "**/*.d.ts", "dist/**", "build/**"],
   validateCasts: false,
   validateFunctions: true,
   transformJSONParse: true,
@@ -89,30 +81,30 @@ export const defaultConfig: TypicalConfig = {
     includeContent: true,
     inline: false,
   },
-}
+};
 
-import fs from 'fs'
-import path from 'path'
+import fs from "fs";
+import path from "path";
 
 export function loadConfig(configPath?: string): TypicalConfig {
-  const configFile = configPath || path.join(process.cwd(), 'typical.json')
+  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)
+      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
+      console.warn(`Failed to parse config file ${configFile}:`, error);
+      return defaultConfig;
     }
   }
 
-  return defaultConfig
+  return defaultConfig;
 }
 
 /**
@@ -124,5 +116,5 @@ export function loadConfig(configPath?: string): TypicalConfig {
 export function validateConfig(config: TypicalConfig): TypicalConfig {
   // Reusable validators now throw at the call site, so they work correctly
   // with source maps. No need for special handling.
-  return config
+  return config;
 }

package/src/esm-loader-register.ts

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

package/src/esm-loader.ts

@@ -1,18 +1,18 @@
-import { fileURLToPath, pathToFileURL } from 'url'
-import { existsSync } from 'fs'
-import { TypicalTransformer } from './transformer.js'
-import { loadConfig, validateConfig } from './config.js'
+import { fileURLToPath, pathToFileURL } from "url";
+import { existsSync } from "fs";
+import { TypicalTransformer } from "./transformer.js";
+import { loadConfig, validateConfig } from "./config.js";
 
-const config = validateConfig(loadConfig())
+const config = validateConfig(loadConfig());
 
 // Shared transformer - stays alive for the lifetime of the process
-let transformer: TypicalTransformer | null = null
+let transformer: TypicalTransformer | null = null;
 
 async function getTransformer(): Promise<TypicalTransformer> {
   if (!transformer) {
-    transformer = new TypicalTransformer(config)
+    transformer = new TypicalTransformer(config);
   }
-  return transformer
+  return transformer;
 }
 
 /**
@@ -20,23 +20,23 @@ async function getTransformer(): Promise<TypicalTransformer> {
  */
 export async function resolve(specifier: string, context: any, nextResolve: any) {
   // Only handle relative imports ending in .js
-  if (specifier.startsWith('.') && specifier.endsWith('.js')) {
-    const { parentURL } = context
+  if (specifier.startsWith(".") && specifier.endsWith(".js")) {
+    const { parentURL } = context;
     if (parentURL) {
-      const parentPath = fileURLToPath(parentURL)
-      const dir = parentPath.substring(0, parentPath.lastIndexOf('/'))
-      const tsPath = dir + '/' + specifier.slice(0, -3) + '.ts'
+      const parentPath = fileURLToPath(parentURL);
+      const dir = parentPath.substring(0, parentPath.lastIndexOf("/"));
+      const tsPath = dir + "/" + specifier.slice(0, -3) + ".ts";
 
       if (existsSync(tsPath)) {
         return {
           url: pathToFileURL(tsPath).href,
           shortCircuit: true,
-        }
+        };
       }
     }
   }
 
-  return nextResolve(specifier, context)
+  return nextResolve(specifier, context);
 }
 
 /**
@@ -44,19 +44,19 @@ export async function resolve(specifier: string, context: any, nextResolve: any)
  * Note: Source maps not yet supported in v2
  */
 export async function load(url: string, context: any, nextLoad: any) {
-  if (!url.endsWith('.ts')) {
-    return nextLoad(url, context)
+  if (!url.endsWith(".ts")) {
+    return nextLoad(url, context);
   }
-  const filePath = fileURLToPath(url)
+  const filePath = fileURLToPath(url);
 
   try {
-    const t = await getTransformer()
-    const result = await t.transform(filePath, 'ts')
+    const t = await getTransformer();
+    const result = await t.transform(filePath, "ts");
 
     // For now, output is TypeScript - need to transpile to JS
     // TODO: Add JS transpilation in Go or here
     // For now, use TypeScript's transpileModule as fallback
-    const ts = await import('typescript')
+    const ts = await import("typescript");
     const transpiled = ts.default.transpileModule(result.code, {
       compilerOptions: {
         module: ts.default.ModuleKind.ESNext,
@@ -64,15 +64,15 @@ export async function load(url: string, context: any, nextLoad: any) {
         esModuleInterop: true,
       },
       fileName: filePath,
-    })
+    });
 
     return {
-      format: 'module',
+      format: "module",
       source: transpiled.outputText,
       shortCircuit: true,
-    }
+    };
   } catch (error) {
-    console.error(`Error transforming ${filePath}:`, error)
-    throw error
+    console.error(`Error transforming ${filePath}:`, error);
+    throw error;
   }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
-export { TypicalTransformer } from './transformer.js'
-export type { TransformResult } from './transformer.js'
-export { loadConfig, validateConfig, defaultConfig } from './config.js'
-export type { TypicalConfig, TypicalSourceMapConfig } from './config.js'
-export { BuildTimer, buildTimer } from './timing.js'
+export { TypicalTransformer } from "./transformer.js";
+export type { TransformResult } from "./transformer.js";
+export { loadConfig, validateConfig, defaultConfig } from "./config.js";
+export type { TypicalConfig, TypicalSourceMapConfig } from "./config.js";
+export { BuildTimer, buildTimer } from "./timing.js";

package/src/patch-fs.cjs

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

package/src/timing.ts

@@ -1,74 +1,60 @@
 /**
- * Performance instrumentation for tracking build times
+ * Simple build timing utility for debugging performance.
  */
+
 export class BuildTimer {
-  private timings = new Map<string, number[]>()
-  private starts = new Map<string, number>()
+  private timings: Map<string, { start: number; total: number; count: number }> = new Map();
 
-  start(stage: string): void {
-    this.starts.set(stage, performance.now())
+  /**
+   * Reset all timing data.
+   */
+  reset(): void {
+    this.timings.clear();
   }
 
-  end(stage: string): void {
-    const start = this.starts.get(stage)
-    if (start !== undefined) {
-      const duration = performance.now() - start
-      const existing = this.timings.get(stage) ?? []
-      existing.push(duration)
-      this.timings.set(stage, existing)
-      this.starts.delete(stage)
+  /**
+   * Start timing a named section.
+   */
+  start(name: string): void {
+    const existing = this.timings.get(name);
+    if (existing) {
+      existing.start = performance.now();
+    } else {
+      this.timings.set(name, { start: performance.now(), total: 0, count: 0 });
     }
   }
 
-  reset(): void {
-    this.timings.clear()
-    this.starts.clear()
+  /**
+   * End timing a named section.
+   */
+  end(name: string): void {
+    const timing = this.timings.get(name);
+    if (timing && timing.start > 0) {
+      timing.total += performance.now() - timing.start;
+      timing.count++;
+      timing.start = 0;
+    }
   }
 
-  report(prefix = '[typical]'): void {
-    console.log(`\n${prefix} Build Performance Report:`)
-    console.log('─'.repeat(60))
-
-    // Sort stages by total time (descending) for better readability
-    const sortedStages = Array.from(this.timings.entries()).sort(([, a], [, b]) => b.reduce((x, y) => x + y, 0) - a.reduce((x, y) => x + y, 0))
-
-    let totalTime = 0
-    for (const [stage, times] of sortedStages) {
-      const total = times.reduce((a, b) => a + b, 0)
-      const avg = total / times.length
-      const min = Math.min(...times)
-      const max = Math.max(...times)
-      const count = times.length
-      totalTime += total
-
-      console.log(`${stage}:`)
-      console.log(`  Count: ${count}`)
-      console.log(`  Total: ${total.toFixed(2)}ms`)
-      console.log(`  Avg:   ${avg.toFixed(2)}ms`)
-      console.log(`  Min:   ${min.toFixed(2)}ms`)
-      console.log(`  Max:   ${max.toFixed(2)}ms`)
+  /**
+   * Print a timing report to console.
+   */
+  report(prefix: string = "[typical]"): void {
+    if (this.timings.size === 0) {
+      return;
     }
 
-    console.log('─'.repeat(60))
-    console.log(`Total transform time: ${totalTime.toFixed(2)}ms`)
-    console.log('')
-  }
-
-  getTimings(): Map<string, { count: number; total: number; avg: number; min: number; max: number }> {
-    const result = new Map()
-    for (const [stage, times] of this.timings) {
-      const total = times.reduce((a, b) => a + b, 0)
-      result.set(stage, {
-        count: times.length,
-        total,
-        avg: total / times.length,
-        min: Math.min(...times),
-        max: Math.max(...times),
-      })
+    console.log(`${prefix} Timing report:`);
+    for (const [name, timing] of this.timings) {
+      const avg = timing.count > 0 ? timing.total / timing.count : 0;
+      console.log(
+        `  ${name}: ${timing.total.toFixed(2)}ms total, ${timing.count} calls, ${avg.toFixed(2)}ms avg`,
+      );
     }
-    return result
   }
 }
 
-// Singleton instance for use across plugins
-export const buildTimer = new BuildTimer()
+/**
+ * Shared build timer instance.
+ */
+export const buildTimer = new BuildTimer();