typia 12.0.2 → 13.0.0-dev.20260425

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "typia",
-  "version": "12.0.2",
+  "version": "13.0.0-dev.20260425",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
@@ -24,11 +25,6 @@
   "bin": {
     "typia": "./lib/executable/typia.js"
   },
-  "tsp": {
-    "tscOptions": {
-      "parseAllJsDoc": true
-    }
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/samchon/typia"
@@ -46,23 +42,30 @@
     "inquirer": "^8.2.5",
     "package-manager-detector": "^0.2.0",
     "randexp": "^0.5.3",
-    "@typia/interface": "^12.0.2",
-    "@typia/transform": "^12.0.2",
-    "@typia/utils": "^12.0.2",
-    "@typia/core": "^12.0.2"
+    "ttsc": "^0.4.2",
+    "@typia/interface": "^13.0.0-dev.20260425",
+    "@typia/utils": "^13.0.0-dev.20260425"
   },
   "peerDependencies": {
-    "typescript": ">=4.8.0 <5.10.0"
+    "@typescript/native-preview": ">=7.0.0-dev.20260420.1"
+  },
+  "optionalDependencies": {
+    "@typia/linux-x64": "^13.0.0-dev.20260425",
+    "@typia/linux-arm": "^13.0.0-dev.20260425",
+    "@typia/darwin-x64": "^13.0.0-dev.20260425",
+    "@typia/linux-arm64": "^13.0.0-dev.20260425",
+    "@typia/darwin-arm64": "^13.0.0-dev.20260425",
+    "@typia/win32-x64": "^13.0.0-dev.20260425",
+    "@typia/win32-arm64": "^13.0.0-dev.20260425"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-typescript": "^12.3.0",
     "@types/inquirer": "^8.2.5",
     "@types/node": "^25.3.0",
-    "@types/ts-expose-internals": "npm:ts-expose-internals@5.6.3",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",
+    "@typescript/native-preview": "7.0.0-dev.20260421.2",
     "chalk": "^4.0.0",
     "eslint-plugin-deprecation": "^3.0.0",
     "rimraf": "^6.1.2",
@@ -70,13 +73,12 @@
     "rollup-plugin-auto-external": "^2.0.0",
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
-    "tinyglobby": "^0.2.12",
-    "ts-node": "^10.9.2",
-    "typescript": "~5.9.3"
+    "tinyglobby": "^0.2.12"
   },
   "sideEffects": false,
   "files": [
     "README.md",
+    "bin",
     "package.json",
     "lib",
     "src"
@@ -85,7 +87,6 @@
     "fast",
     "json",
     "stringify",
-    "typescript",
     "transform",
     "ajv",
     "io-ts",
@@ -121,9 +122,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsc && rollup -c && cp ../../README.md README.md",
-    "dev": "rimraf lib && tsc --watch"
+    "build": "rimraf lib && ttsc && rollup -c && cp ../../README.md README.md",
+    "dev": "ttsc --watch"
   },
-  "types": "lib/index.d.ts",
   "module": "lib/index.mjs"
 }

package/src/executable/TypiaGenerateWizard.ts

@@ -1,5 +1,6 @@
-import { TypiaGenerator } from "@typia/transform";
+import { transform } from "ttsc";
 import fs from "fs";
+import path from "path";
 
 import { ArgumentParser } from "./setup/ArgumentParser";
 import { PackageManager } from "./setup/PackageManager";
@@ -13,7 +14,7 @@ export namespace TypiaGenerateWizard {
     // LOAD PACKAGE.JSON INFO
     const pack: PackageManager = await PackageManager.mount();
     const options: IArguments = await ArgumentParser.parse(pack, inquiry);
-    await TypiaGenerator.build(options);
+    await build(options);
   }
 
   const inquiry: ArgumentParser.Inquiry<IArguments> = async (
@@ -79,4 +80,96 @@ export namespace TypiaGenerateWizard {
     output: string;
     project: string;
   }
+
+  async function build(location: IArguments): Promise<void> {
+    location.input = path.resolve(location.input);
+    location.output = path.resolve(location.output);
+    location.project = path.resolve(location.project);
+
+    if ((await isDirectory(location.input)) === false) {
+      throw new URIError(
+        "Error on TypiaGenerateWizard.generate(): input path is not a directory.",
+      );
+    } else if (fs.existsSync(location.output) === false) {
+      await fs.promises.mkdir(location.output, { recursive: true });
+    } else if ((await isDirectory(location.output)) === false) {
+      const parent: string = path.join(location.output, "..");
+      if ((await isDirectory(parent)) === false) {
+        throw new URIError(
+          "Error on TypiaGenerateWizard.generate(): output path is not a directory.",
+        );
+      }
+      await fs.promises.mkdir(location.output);
+    }
+
+    const files: string[] = [];
+    await gather({
+      location,
+      container: files,
+      from: location.input,
+      to: location.output,
+    });
+
+    const cwd = path.dirname(location.project);
+    for (const file of files) {
+      const relative = path.relative(location.input, file);
+      const target = path.join(location.output, relative);
+      const output = transform({
+        cwd,
+        file,
+        tsconfig: location.project,
+        plugins: [{ transform: "typia/lib/transform" }],
+      });
+      await fs.promises.mkdir(path.dirname(target), { recursive: true });
+      await fs.promises.writeFile(target, formatOutput(output), "utf8");
+    }
+  }
+
+  async function isDirectory(current: string): Promise<boolean> {
+    const stat: fs.Stats = await fs.promises.stat(current);
+    return stat.isDirectory();
+  }
+
+  async function gather(props: {
+    location: IArguments;
+    container: string[];
+    from: string;
+    to: string;
+  }): Promise<void> {
+    if (props.from === props.location.output) return;
+    if (fs.existsSync(props.to) === false) {
+      await fs.promises.mkdir(props.to);
+    }
+
+    for (const file of await fs.promises.readdir(props.from)) {
+      const next: string = path.join(props.from, file);
+      const stat: fs.Stats = await fs.promises.stat(next);
+
+      if (stat.isDirectory()) {
+        await gather({
+          location: props.location,
+          container: props.container,
+          from: next,
+          to: path.join(props.to, file),
+        });
+        continue;
+      }
+      if (isSupportedExtension(file)) {
+        props.container.push(next);
+      }
+    }
+  }
+
+  function isSupportedExtension(filename: string): boolean {
+    return TS_PATTERN.test(filename) && !DTS_PATTERN.test(filename);
+  }
+
+  function formatOutput(output: string): string {
+    return output.startsWith("// @ts-nocheck")
+      ? output
+      : `// @ts-nocheck\n${output}`;
+  }
 }
+
+const TS_PATTERN = /\.[cm]?tsx?$/;
+const DTS_PATTERN = /\.d\.[cm]?tsx?$/;

package/src/executable/TypiaSetupWizard.ts

@@ -2,11 +2,13 @@ import fs from "fs";
 import { DetectResult, detect } from "package-manager-detector";
 
 import { ArgumentParser } from "./setup/ArgumentParser";
-import { CommandExecutor } from "./setup/CommandExecutor";
 import { PackageManager } from "./setup/PackageManager";
 import { PluginConfigurator } from "./setup/PluginConfigurator";
 
 export namespace TypiaSetupWizard {
+  const TTSC_PACKAGE = "ttsc";
+  const TSGO_COMPILER_PACKAGE = "@typescript/native-preview";
+
   export interface IArguments {
     manager: "npm" | "pnpm" | "yarn" | "bun";
     project: string | null;
@@ -21,53 +23,61 @@ export namespace TypiaSetupWizard {
     const pack: PackageManager = await PackageManager.mount();
     const args: IArguments = await ArgumentParser.parse(pack, inquiry);
 
-    // INSTALL TYPESCRIPT COMPILERS
-    pack.install({
-      dev: true,
-      modulo: "typescript",
-      version: await getTypeScriptVersion(),
-    });
-    pack.install({ dev: true, modulo: "ts-patch", version: "latest" });
     args.project ??= (() => {
-      const runner: string = pack.manager === "npm" ? "npx" : pack.manager;
-      CommandExecutor.run(`${runner} tsc --init`);
+      fs.writeFileSync(
+        "tsconfig.json",
+        `${JSON.stringify({ compilerOptions: {} }, null, 2)}\n`,
+        "utf8",
+      );
       return (args.project = "tsconfig.json");
     })();
 
-    // SETUP TRANSFORMER
+    // CONFIGURE TYPIA
+    await PluginConfigurator.configure(args);
+
+    // NORMALIZE PROJECT SETTINGS
     await pack.save((data) => {
-      // COMPOSE PREPARE COMMAND
-      data.scripts ??= {};
-      if (
-        typeof data.scripts.prepare === "string" &&
-        data.scripts.prepare.trim().length !== 0
-      ) {
-        if (data.scripts.prepare.includes("ts-patch install") === false)
-          data.scripts.prepare = "ts-patch install && " + data.scripts.prepare;
-      } else data.scripts.prepare = "ts-patch install";
-
-      // NO MORE "typia patch" REQUIRED
-      data.scripts.prepare = data.scripts.prepare
-        .split("&&")
-        .map((str) => str.trim())
-        .filter((str) => str !== "typia patch")
-        .join(" && ");
-
-      // FOR OLDER VERSIONS
-      if (typeof data.scripts.postinstall === "string") {
-        data.scripts.postinstall = data.scripts.postinstall
-          .split("&&")
-          .map((str) => str.trim())
-          .filter((str) => str.indexOf("ts-patch install") === -1)
-          .join(" && ");
-        if (data.scripts.postinstall.length === 0)
-          delete data.scripts.postinstall;
+      if (typeof data.scripts?.prepare === "string") {
+        const prepare = removeLegacyCompilerPatchSteps(data.scripts.prepare);
+        if (prepare.length !== 0) data.scripts.prepare = prepare;
+        else delete data.scripts.prepare;
+        if (Object.keys(data.scripts).length === 0) delete data.scripts;
+      }
+      if (data.devDependencies?.["ts-patch"] !== undefined) {
+        delete data.devDependencies["ts-patch"];
+      }
+      if (data.devDependencies?.["@typia/ttsc"] !== undefined) {
+        delete data.devDependencies["@typia/ttsc"];
+      }
+      if (data.devDependencies?.["@typia/ttsx"] !== undefined) {
+        delete data.devDependencies["@typia/ttsx"];
+      }
+      if (data.devDependencies !== undefined) {
+        if (Object.keys(data.devDependencies).length === 0)
+          delete data.devDependencies;
+      }
+      if (data.dependencies?.["ts-patch"] !== undefined) {
+        delete data.dependencies["ts-patch"];
+      }
+      if (data.dependencies?.["@typia/ttsc"] !== undefined) {
+        delete data.dependencies["@typia/ttsc"];
+      }
+      if (data.dependencies?.["@typia/ttsx"] !== undefined) {
+        delete data.dependencies["@typia/ttsx"];
+      }
+      if (data.dependencies !== undefined) {
+        if (Object.keys(data.dependencies).length === 0)
+          delete data.dependencies;
       }
     });
 
-    // CONFIGURE TYPIA
-    await PluginConfigurator.configure(args);
-    CommandExecutor.run(`${pack.manager} run prepare`);
+    // INSTALL TSGO TOOLCHAIN
+    pack.install({
+      dev: true,
+      modulo: TSGO_COMPILER_PACKAGE,
+      version: "latest",
+    });
+    pack.install({ dev: true, modulo: TTSC_PACKAGE, version: "latest" });
   };
 
   const inquiry: ArgumentParser.Inquiry<IArguments> = async (
@@ -159,13 +169,15 @@ export namespace TypiaSetupWizard {
     }
   };
 
-  const getTypeScriptVersion = async (): Promise<string> => {
-    const content: string = await fs.promises.readFile(
-      `${__dirname}/../../package.json`,
-      "utf-8",
-    );
-    const json: { devDependencies: { typescript: string } } =
-      JSON.parse(content);
-    return json.devDependencies.typescript;
-  };
+  const isLegacyCompilerPatchStep = (str: string): boolean =>
+    str === "typia patch" || str.includes("ts-patch install");
+
+  const removeLegacyCompilerPatchSteps = (script: string): string =>
+    script
+      .split("&&")
+      .map((str) => str.trim())
+      .filter(
+        (str) => str.length !== 0 && isLegacyCompilerPatchStep(str) === false,
+      )
+      .join(" && ");
 }

package/src/executable/generate/ttsc.ts

@@ -0,0 +1,101 @@
+const { spawnSync } = require(
+  "node:child_process",
+) as typeof import("node:child_process");
+const fs = require("node:fs") as typeof import("node:fs");
+const path = require("node:path") as typeof import("node:path");
+
+const packageRoot = path.resolve(
+  path.dirname(path.resolve(process.argv[1] ?? "")),
+  "..",
+  "..",
+  "..",
+);
+const repoRoot = path.resolve(packageRoot, "..", "..");
+const nativeProject = path.resolve(repoRoot, "packages", "transform", "native");
+const nativeBinary = resolveNativeBinary();
+const nativeEntrypoint = path.resolve(
+  nativeProject,
+  "cmd",
+  "ttsc-typia",
+  "main.go",
+);
+const command = process.platform === "win32" ? "go.exe" : "go";
+const invocationCwd = process.cwd();
+const argv = [...process.argv.slice(2)];
+
+if (
+  argv.length > 0 &&
+  needsCwd(argv[0]!) &&
+  !argv.some((value) => value === "--cwd" || value.startsWith("--cwd="))
+) {
+  argv.push(`--cwd=${invocationCwd}`);
+}
+
+const hasNativeBinary = fs.existsSync(nativeBinary);
+const hasSourceEntrypoint = fs.existsSync(nativeEntrypoint);
+
+if (!hasNativeBinary && !hasSourceEntrypoint) {
+  process.stderr.write(
+    "ttsc-typia: backend is missing. Expected a platform @typia native package, a package-local ttsc-typia-native binary, or packages/transform/native/cmd/ttsc-typia/main.go.\n",
+  );
+  process.exitCode = 1;
+} else {
+  if (hasNativeBinary && process.platform !== "win32") {
+    try {
+      const mode = fs.statSync(nativeBinary).mode & 0o777;
+      if ((mode & 0o111) === 0) {
+        fs.chmodSync(nativeBinary, mode | 0o755);
+      }
+    } catch {
+      /* keep the original spawn error path */
+    }
+  }
+  const result = hasNativeBinary
+    ? spawnSync(nativeBinary, argv, {
+        env: process.env,
+        stdio: "inherit",
+        windowsHide: true,
+      })
+    : spawnSync(command, ["run", "./cmd/ttsc-typia", ...argv], {
+        cwd: nativeProject,
+        env: process.env,
+        stdio: "inherit",
+        windowsHide: true,
+      });
+  if (result.error) {
+    process.stderr.write(
+      hasNativeBinary
+        ? `ttsc-typia: failed to launch prebuilt backend: ${result.error.message}\n`
+        : `ttsc-typia: failed to launch source checkout via ${command}: ${result.error.message}\n`,
+    );
+    process.exitCode = 1;
+  } else {
+    process.exitCode = result.status ?? 1;
+  }
+}
+
+function needsCwd(commandName: string): boolean {
+  return (
+    commandName === "build" ||
+    commandName === "check" ||
+    commandName === "transform" ||
+    commandName === "-p" ||
+    commandName === "--project"
+  );
+}
+
+function resolveNativeBinary(): string {
+  const name =
+    process.platform === "win32"
+      ? "ttsc-typia-native.exe"
+      : "ttsc-typia-native";
+  const platformKey = `${process.platform}-${process.arch}`;
+  const optionalRequest = `@typia/${platformKey}/bin/${name}`;
+  try {
+    return require.resolve(optionalRequest, {
+      paths: [packageRoot, process.cwd()],
+    });
+  } catch {
+    return path.resolve(packageRoot, "bin", name);
+  }
+}

package/src/executable/setup/PluginConfigurator.ts

@@ -1,9 +1,11 @@
 import comments from "comment-json";
 import fs from "fs";
 
-import { TypiaSetupWizard } from "../TypiaSetupWizard";
+import type { TypiaSetupWizard } from "../TypiaSetupWizard";
 
 export namespace PluginConfigurator {
+  const TYPIA_TRANSFORM = "typia/lib/transform";
+
   export async function configure(
     args: TypiaSetupWizard.IArguments,
   ): Promise<void> {
@@ -11,13 +13,9 @@ export namespace PluginConfigurator {
     const config: comments.CommentObject = comments.parse(
       await fs.promises.readFile(args.project!, "utf8"),
     ) as comments.CommentObject;
-    const compilerOptions = config.compilerOptions as
-      | comments.CommentObject
-      | undefined;
-    if (compilerOptions === undefined)
-      throw new ReferenceError(
-        `${args.project} file does not have "compilerOptions" property.`,
-      );
+    const compilerOptions = (
+      config.compilerOptions ??= {} as comments.CommentObject
+    ) as comments.CommentObject;
 
     // PREPARE PLUGINS
     const plugins: comments.CommentArray<comments.CommentObject> = (() => {
@@ -40,32 +38,26 @@ export namespace PluginConfigurator {
     const skipLibCheck: boolean | undefined = compilerOptions.skipLibCheck as
       | boolean
       | undefined;
-    const oldbie: comments.CommentObject | undefined = plugins.find(
+    const filtered: comments.CommentObject[] = plugins.filter(
       (p) =>
-        typeof p === "object" &&
-        p !== null &&
-        p.transform === "typia/lib/transform",
-    );
-    if (
-      strictNullChecks !== false &&
-      (strict === true || strictNullChecks === true) &&
-      oldbie !== undefined &&
-      skipLibCheck === true
-    )
-      return;
+        typeof p === "object" && p !== null && p.transform !== TYPIA_TRANSFORM,
+    ) as comments.CommentObject[];
+    filtered.push({
+      transform: TYPIA_TRANSFORM,
+    } as unknown as comments.CommentObject);
+    const changed: boolean =
+      JSON.stringify(filtered) !== JSON.stringify(plugins) ||
+      strictNullChecks === false ||
+      (strict !== true && strictNullChecks !== true) ||
+      skipLibCheck !== true;
+    if (changed === false) return;
 
     // DO CONFIGURE
     compilerOptions.skipLibCheck = true;
     compilerOptions.strictNullChecks = true;
     if (strict === undefined && strictNullChecks === undefined)
       compilerOptions.strict = true;
-    if (oldbie === undefined)
-      plugins.push(
-        comments.parse(`
-                        {
-                            "transform": "typia/lib/transform"
-                        }`) as comments.CommentObject,
-      );
+    compilerOptions.plugins = filtered as any;
     await fs.promises.writeFile(
       args.project!,
       comments.stringify(config, null, 2),

package/src/executable/typia.ts

@@ -21,6 +21,25 @@ const halt = (desc: string): never => {
   process.exit(-1);
 };
 
+const loadNativePreview = (): void => {
+  const resolvers: Array<() => string> = [
+    () =>
+      require.resolve("@typescript/native-preview/package.json", {
+        paths: [process.cwd()],
+      }),
+    () => require.resolve("@typescript/native-preview/package.json"),
+  ];
+  for (const resolve of resolvers) {
+    try {
+      resolve();
+      return;
+    } catch {}
+  }
+  halt(
+    `@typescript/native-preview has not been installed. Run "npm i -D @typescript/native-preview" before.`,
+  );
+};
+
 const main = async (): Promise<void> => {
   try {
     await import("comment-json");
@@ -32,20 +51,11 @@ const main = async (): Promise<void> => {
 
   const type: string | undefined = process.argv[2];
   if (type === "setup") {
-    const { TypiaSetupWizard } = await import("./TypiaSetupWizard.js");
+    const { TypiaSetupWizard } = await import("./TypiaSetupWizard");
     await TypiaSetupWizard.setup();
-  } else if (type === "patch") {
-    const { TypiaPatchWizard } = await import("./TypiaPatchWizard.js");
-    await TypiaPatchWizard.main();
   } else if (type === "generate") {
-    try {
-      await import("typescript");
-    } catch {
-      halt(
-        `typescript has not been installed. Run "npm i -D typescript" before.`,
-      );
-    }
-    const { TypiaGenerateWizard } = await import("./TypiaGenerateWizard.js");
+    loadNativePreview();
+    const { TypiaGenerateWizard } = await import("./TypiaGenerateWizard");
     await TypiaGenerateWizard.generate();
   } else halt(USAGE);
 };

package/src/transform.ts

@@ -1,5 +1,73 @@
-import transform from "@typia/transform";
+import { definePlugin } from "ttsc";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 
-export default transform;
+const filename: string = currentFilename();
+const dirname: string = path.dirname(filename);
+const extension: string = path.extname(filename);
 
-export * from "@typia/transform";
+export default definePlugin((_config, context) => {
+  const root: string =
+    resolvePackageRoot(context.projectRoot) ?? inferPackageRoot();
+  const source: boolean = extension === ".ts";
+  return {
+    name: "typia",
+    native: {
+      binary: path.resolve(
+        root,
+        source
+          ? "src/executable/generate/ttsc.ts"
+          : "lib/executable/generate/ttsc.js",
+      ),
+      capabilities: ["rewrite", "diagnostics", "assets"],
+      contractVersion: 1,
+      mode: "typia",
+    },
+  };
+});
+
+function resolvePackageRoot(projectRoot: string): string | null {
+  try {
+    return path.dirname(
+      require.resolve("typia/package.json", { paths: [projectRoot] }),
+    );
+  } catch {
+    return null;
+  }
+}
+
+function inferPackageRoot(): string {
+  if (extension === ".ts") {
+    return path.resolve(dirname, "..");
+  }
+  return path.resolve(dirname, "..");
+}
+
+function currentFilename(): string {
+  if (
+    typeof __filename === "string" &&
+    __filename !== "[stdin]" &&
+    __filename.length !== 0
+  ) {
+    return normalizeFilename(__filename);
+  }
+  const line = new Error().stack
+    ?.split("\n")
+    .find(
+      (entry) =>
+        entry.includes("/src/transform.ts") ||
+        entry.includes("/lib/transform.js") ||
+        entry.includes("/lib/transform.mjs") ||
+        entry.includes("/lib/transform2.mjs"),
+    );
+  const matched = line?.match(/\(([^()]+):\d+:\d+\)|at ([^\s()]+):\d+:\d+/);
+  const fallback: string = typeof __filename === "string" ? __filename : "";
+  return normalizeFilename(matched?.[1] ?? matched?.[2] ?? fallback);
+}
+
+function normalizeFilename(value: string): string {
+  if (value.startsWith("file:")) {
+    return fileURLToPath(value);
+  }
+  return value;
+}

package/lib/executable/TypiaPatchWizard.d.ts

@@ -1,4 +0,0 @@
-export declare namespace TypiaPatchWizard {
-    const main: () => Promise<void>;
-    const patch: () => Promise<void>;
-}