@elliots/typical 0.1.9 → 0.2.0-beta.1

package/README.md

@@ -1,89 +1,129 @@
 # Typical
 
-Typical adds runtime validation to typescript, making TypeScript type-safe at runtime *with no changes to your code*. 
+Typical makes TypeScript type-safe at runtime _with no changes to your code_.
 
-It can be used as a TSC plugin, ESM loader for Node.js, or with bundlers like Vite, Webpack, and Rollup via unplugin.
+It transforms your code to inject runtime validation based on your existing type annotations. With source maps, so errors point to the right lines in your original code.
 
 ## Why?
 
-For some use cases it can mean you don't need to use zod, yup, ajv, or other runtime validation libraries, as your types are already validated automatically.
+- Less need for zod, yup, ajv, or other runtime validation libraries - your types are already validated automatically. If you can express it in TypeScript, Typical can validate it at runtime.
+- Protects against data leaks via `JSON.stringify` by ensuring only properties defined in your types are included
+- Catches type mismatches at runtime that TypeScript can't catch at compile time (API responses, JSON parsing, un-typed/badly-typed libraries, vibe-coding coworkers etc.)
 
-It protects you from leaking data via JSON.stringify by making sure only the properties defined in your types are included in the output.
+## Features
 
-Why not.
+- Validation of function parameters and return types
+- Safe `JSON.parse` with type validation
+- Safe `JSON.stringify` that only includes defined properties
+- Validation of type casts (`as Type`)
+- Configurable include/exclude patterns
 
-## Features
+## Example
 
-- ✅ Automatic validation of function parameters
-- ✅ Automatic validation of return types
-- ✅ Replace `JSON.stringify` with a custom stringifier (very fast!)
-- ✅ Replace `JSON.parse` with a custom parser and validator (very fast!)
-- ✅ 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 @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`
-- ✅ Unplugin for Vite, Webpack, Rollup, esbuild, and more
+This code runs without errors in normal TypeScript, but Typical catches the invalid data:
 
-## Installation
+```ts
+interface User {
+  name: string;
+  email: `${string}@${string}`;
+}
 
-```bash
-npm add typical
+// This will throw - email doesn't match the template literal type
+const user = JSON.parse('{"name":"Alice","email":"not-an-email"}') as User;
 ```
 
-## Configuration
+---
+
+## Usage Options
+
+Choose the integration that fits your workflow:
 
-Optional: Create a `typical.json` file in your project root.
+| Method                                                    | Best For                        | Package                       |
+| --------------------------------------------------------- | ------------------------------- | ----------------------------- |
+| [ESM Loader](#nodejs-esm-loader)                          | Node.js scripts, development    | `@elliots/typical`            |
+| [ttsx](#ttsx-tsx-wrapper)                                 | Quick scripts with tsx          | `@elliots/typical` + `tsx`    |
+| [Bun Plugin](#bun)                                        | Bun projects                    | `@elliots/bun-plugin-typical` |
+| [Vite/Webpack/etc](#bundlers-vite-webpack-rollup-esbuild) | Frontend apps, bundled projects | `@elliots/unplugin-typical`   |
+| [tsc Plugin](#typescript-compiler-tsc)                    | Pure TypeScript compilation     | `@elliots/typical-tsc-plugin` |
 
-If not provided, these default settings will be used.
+---
+
+## Node.js (ESM Loader)
+
+The simplest way to run TypeScript with Typical validation.
+
+```bash
+npm add @elliots/typical
+```
+
+```bash
+node --import @elliots/typical/esm src/index.ts
+```
+
+Add to `package.json` scripts:
 
 ```json
 {
-  "include": ["**/*.ts", "**/*.tsx"],
-  "exclude": ["node_modules/**", "**/*.d.ts", "dist/**", "build/**"],
-  "reusableValidators": true,
-  "validateFunctions": true,
-  "validateCasts": false,
-  "hoistRegex": true,
-  "ignoreDOMTypes": true,
-  "ignoreTypes": []
+  "scripts": {
+    "start": "node --import @elliots/typical/esm src/index.ts"
+  }
 }
 ```
 
-### Configuration Options
+---
+
+## ttsx (tsx wrapper)
+
+A convenience wrapper that combines [tsx](https://github.com/privatenumber/tsx) with Typical.
+
+```bash
+npm add @elliots/typical tsx
+```
+
+```bash
+npx ttsx script.ts
+```
+
+Or install globally:
 
-| Option | Default | Description |
-|--------|---------|-------------|
-| `include` | `["**/*.ts", "**/*.tsx"]` | Glob patterns for files to transform |
-| `exclude` | `["node_modules/**", "**/*.d.ts", "dist/**", "build/**"]` | Glob patterns for files to skip |
-| `reusableValidators` | `true` | Create shared validators for identical types (smaller output, allows reuse) |
-| `validateFunctions` | `true` | Validate function parameters and return types at runtime |
-| `validateCasts` | `false` | Validate type assertions (`as Type`) at runtime |
-| `hoistRegex` | `true` | Hoist regex patterns to top-level constants (improves performance) |
-| `ignoreDOMTypes` | `true` | Skip validation for DOM types (Document, Element, etc.) |
-| `ignoreTypes` | `[]` | Type patterns to skip validation for (supports wildcards, e.g., `["React.*"]`) |
+```bash
+npm add -g @elliots/typical tsx
+ttsx script.ts
+```
 
-## Usage
+> **Note:** `tsx` must be installed separately. The `ttsx` command is a thin wrapper that runs `tsx` with the Typical ESM loader.
 
-See ./samples/esm and ./samples/tsc and ./samples/ttsx
+---
 
-Quickest way to try it out is to use ttsx:
+## Bun
 
 ```bash
-npm add @elliots/typical
-npx ttsx your-script.ts
+bun add @elliots/bun-plugin-typical
+```
+
+Create `bunfig.toml`:
+
+```toml
+preload = ["./preload.ts"]
+```
+
+Create `preload.ts`:
+
+```ts
+import { typicalPlugin } from "@elliots/bun-plugin-typical";
+
+Bun.plugin(typicalPlugin());
 ```
 
-or globally:
+Then run:
 
 ```bash
-npm add -g @elliots/typical
-ttsx your-script.ts
+bun run src/index.ts
 ```
 
-## Vite / Webpack / Rollup (unplugin)
+---
 
-Install the unplugin:
+## Bundlers (Vite, Webpack, Rollup, esbuild)
 
 ```bash
 npm add @elliots/unplugin-typical
@@ -91,91 +131,187 @@ npm add @elliots/unplugin-typical
 
 ### Vite
 
-```typescript
+```ts
 // vite.config.ts
-import Typical from '@elliots/unplugin-typical/vite'
+import Typical from "@elliots/unplugin-typical/vite";
 
 export default defineConfig({
-  plugins: [
-    Typical(),
-  ],
-})
+  plugins: [Typical()],
+});
 ```
 
 ### Webpack
 
-```typescript
+```js
 // webpack.config.js
-const Typical = require('@elliots/unplugin-typical/webpack').default
+const Typical = require("@elliots/unplugin-typical/webpack").default;
 
 module.exports = {
-  plugins: [
-    Typical(),
-  ],
-}
+  plugins: [Typical()],
+};
 ```
 
 ### Rollup
 
-```typescript
+```js
 // rollup.config.js
-import Typical from '@elliots/unplugin-typical/rollup'
+import Typical from "@elliots/unplugin-typical/rollup";
 
 export default {
-  plugins: [
-    Typical(),
-  ],
-}
+  plugins: [Typical()],
+};
 ```
 
 ### esbuild
 
-```typescript
-import { build } from 'esbuild'
-import Typical from '@elliots/unplugin-typical/esbuild'
+```ts
+import { build } from "esbuild";
+import Typical from "@elliots/unplugin-typical/esbuild";
 
 build({
   plugins: [Typical()],
-})
+});
 ```
 
-### Plugin Configuration
+### Rolldown
 
-Pass options directly to the plugin:
+```ts
+// rolldown.config.ts
+import Typical from "@elliots/unplugin-typical/rolldown";
 
-```typescript
-Typical({
-  validateFunctions: true,
-  validateCasts: false,
-  // ... other options
-})
+export default {
+  plugins: [Typical()],
+};
 ```
 
-Or use a `typical.json` file in your project root (shared with other entry points like TSC plugin and ESM loader).
+### Farm
 
-## Example
+```ts
+// farm.config.ts
+import Typical from "@elliots/unplugin-typical/farm";
 
-This code will run without errors when compiled normally, but will throw an error when using Typical.
+export default {
+  plugins: [Typical()],
+};
+```
 
+### Rspack
 
 ```ts
-interface User {
-  name: string;
-  email: `${string}@${string}`;
-} 
-const u = JSON.parse('{"name":"Alice","email":"oops-not-an-email"}') as User;
+// rspack.config.ts
+import Typical from "@elliots/unplugin-typical/rspack";
+
+export default {
+  plugins: [Typical()],
+};
+```
+
+---
+
+## TypeScript Compiler (tsc)
+
+For projects that compile with `tsc` directly using [ts-patch](https://github.com/nonara/ts-patch).
+
+```bash
+npm add @elliots/typical-tsc-plugin ts-patch
+```
+
+### Option 1: ttsc (auto-injects plugin)
+
+The `ttsc` command automatically injects the plugin - no config needed:
+
+```bash
+npx ttsc
+```
+
+Add to `package.json`:
+
+```json
+{
+  "scripts": {
+    "build": "ttsc"
+  }
+}
+```
+
+### Option 2: Manual tsconfig.json
+
+Add to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "transform": "@elliots/typical-tsc-plugin",
+        "transformProgram": true
+      }
+    ]
+  }
+}
 ```
 
-## How it works
+Then run ts-patch's tsc:
 
-Typical uses the TypeScript Compiler API to parse and transform your TypeScript code. It analyzes function signatures, return types, and JSON operations to inject appropriate typia validation calls.
+```bash
+npx ts-patch install
+npx tsc
+```
 
-But basically you shouldn't need to care about how it works internally, it makes typescript strongly typed*. You can still use `any` and `unknown` if you want to opt out of type safety.
+Or add a prepare script:
 
-* sort of. probably. something like it anyway.
+```json
+{
+  "scripts": {
+    "prepare": "ts-patch install -s",
+    "build": "tsc"
+  }
+}
+```
 
-## Credits
-The actual validation work is done by [typia](https://github.com/samchon/typia). This package just generates the necessary code to call typia's functions based on your TypeScript types.
+---
+
+## Configuration
+
+Create a `typical.json` file in your project root (optional):
+
+```json
+{
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules/**", "**/*.d.ts"],
+  "validateFunctions": true,
+  "validateCasts": false
+}
+```
+
+### Options
+
+| Option              | Default                                                   | Description                                   |
+| ------------------- | --------------------------------------------------------- | --------------------------------------------- |
+| `include`           | `["**/*.ts", "**/*.tsx"]`                                 | Files to transform                            |
+| `exclude`           | `["node_modules/**", "**/*.d.ts", "dist/**", "build/**"]` | Files to skip                                 |
+| `validateFunctions` | `true`                                                    | Validate function parameters and return types |
+| `validateCasts`     | `false`                                                   | Validate type assertions (`as Type`)          |
+
+---
+
+## How It Works
+
+Typical uses a Go-based compiler that leverages the TypeScript type checker to analyze your code. It generates runtime validators that check values against their declared types.
+
+Types that can't be validated at runtime (like generic type parameters `T`) are skipped. You can still use `any` and `unknown` to opt out of validation.
+
+## Debugging
+
+Set `DEBUG=1` for verbose logging:
+
+```bash
+DEBUG=1 npm run build
+```
 
-> NOTE: The whole package was all mostly LLM. Feel free to improve it without care for the author's feelings. 
+## Limitations
 
+- Generic type parameters (`T`) cannot be validated - no runtime type information
+- Type-only imports of classes aren't checked (can't do instanceof on type-only imports)
+- Validation of functions is just not done. Need to think about that one.
+- Some complex types may not be fully supported yet. If you find any that fail, please open an issue!

package/dist/src/cli.js

@@ -3,87 +3,41 @@ import { Command } from 'commander';
 import * as fs from 'fs';
 import * as path from 'path';
 import { TypicalTransformer } from './transformer.js';
-import { loadConfig } from './config.js';
+import { loadConfig, validateConfig } from './config.js';
 const program = new Command();
-program
-    .name('typical')
-    .description('Runtime safe TypeScript transformer using typia')
-    .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('-m, --mode <mode>', 'Transformation mode:  basic, typia, js', 'basic')
+    .option('-p, --project <file>', 'TypeScript config file path', 'tsconfig.json')
     .action(async (file, options) => {
+    let transformer = null;
     try {
-        const config = loadConfig(options.config);
-        const transformer = new TypicalTransformer(config);
+        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.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 result = await transformer.transform(path.resolve(file), 'ts');
+        // Determine output file path
         const outputFile = options.output ? path.resolve(options.output) : file + '.transformed.ts';
-        fs.writeFileSync(outputFile, transformedCode);
+        fs.writeFileSync(outputFile, result.code);
         console.log(`Transformed code written to ${outputFile}`);
     }
     catch (error) {
         console.error('Transformation failed:', error);
         process.exit(1);
     }
+    finally {
+        if (transformer) {
+            await transformer.close();
+        }
+    }
 });
-// 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();
 //# sourceMappingURL=cli.js.map

package/dist/src/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,KAAK,EAAE,MAAM,IAAI,CAAA;AACxB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAExD,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAA;AAE7B,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC,qCAAqC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;AAE3F,OAAO;KACJ,OAAO,CAAC,WAAW,CAAC;KACpB,WAAW,CAAC,qDAAqD,CAAC;KAClE,QAAQ,CAAC,QAAQ,EAAE,8BAA8B,CAAC;KAClD,MAAM,CAAC,qBAAqB,EAAE,aAAa,CAAC;KAC5C,MAAM,CAAC,qBAAqB,EAAE,kBAAkB,EAAE,cAAc,CAAC;KACjE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,EAAE,eAAe,CAAC;KAC9E,MAAM,CACL,KAAK,EACH,IAAY,EACZ,OAIC,EACD,EAAE;IACF,IAAI,WAAW,GAA8B,IAAI,CAAA;IACjD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;QACzD,WAAW,GAAG,IAAI,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;QAE7D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,OAAO,CAAC,KAAK,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAA;YACxC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACjB,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,KAAK,CAAC,CAAA;QACtC,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAA;QAEpE,6BAA6B;QAC7B,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAE3F,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;QACzC,OAAO,CAAC,GAAG,CAAC,+BAA+B,UAAU,EAAE,CAAC,CAAA;IAC1D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAA;QAC9C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IACjB,CAAC;YAAS,CAAC;QACT,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,WAAW,CAAC,KAAK,EAAE,CAAA;QAC3B,CAAC;IACH,CAAC;AACH,CAAC,CACF,CAAA;AAEH,OAAO,CAAC,KAAK,EAAE,CAAA"}

package/dist/src/cli.typical.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import typia from "typia";
+//@L:3
+import { Command } from 'commander';
+//@L:4
+import * as fs from 'fs';
+//@L:5
+import * as path from 'path';
+//@L:6
+import { TypicalTransformer } from './transformer.js';
+//@L:7
+import * as ts from 'typescript';
+//@L:8
+import { loadConfig, validateConfig } from './config.js';
+//@L:9
+import { shouldIncludeFile } from './file-filter.js';
+//@L:10
+import { inlineSourceMapComment, externalSourceMapComment } from './source-map.js';
+//@L:12
+const program = new Command();
+//@L:14
+program
+    .name('typical')
+    .description('Runtime safe TypeScript transformer using typia')
+    .version('0.1.0');
+//@L:19
+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')
+    .option('--source-map', 'Generate external source map file')
+    .option('--inline-source-map', 'Include inline source map in output')
+    .option('--no-source-map', 'Disable source map generation')
+    .action(async (file: string, options: {
+    output?: string;
+    config?: string;
+    mode?: 'basic' | 'typia' | 'js';
+    sourceMap?: boolean;
+    inlineSourceMap?: boolean;
+}) => {
+    try {
+        const config = validateConfig(loadConfig(options.config));
+        const transformer = new TypicalTransformer(config);
+        if (!fs.existsSync(file)) {
+            console.error(`File not found: ${file}`);
+            process.exit(1);
+        }
+        // Determine source map behavior
+        const generateSourceMap = options.inlineSourceMap || options.sourceMap !== false;
+        console.log(`Transforming ${file}...`);
+        const result = transformer.transform(path.resolve(file), options.mode ?? 'basic', {
+            sourceMap: generateSourceMap,
+        });
+        // Determine output file path
+        const outputFile = options.output
+            ? path.resolve(options.output)
+            : options.mode === 'js'
+                ? file.replace(/\.tsx?$/, '.js')
+                : file + '.transformed.ts';
+        let outputCode = result.code;
+        // Handle source maps
+        if (result.map) {
+            if (options.inlineSourceMap) {
+                // Inline source map as data URL
+                outputCode += '\n' + inlineSourceMapComment(result.map);
+            }
+            else if (options.sourceMap !== false) {
+                // Write external source map file
+                const mapFile = outputFile + '.map';
+                fs.writeFileSync(mapFile, typia.json.stringify(result.map, null, 2));
+                outputCode += '\n' + externalSourceMapComment(path.basename(mapFile));
+                console.log(`Source map written to ${mapFile}`);
+            }
+        }
+        fs.writeFileSync(outputFile, outputCode);
+        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);
+//     }
+//   });
+//@L:145
+program.parse();