ttsc 0.6.0 → 0.7.0

package/test/compiler.test.ts

@@ -0,0 +1,234 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const { TtscCompiler } = require("../lib/index.js");
+const { resolveTsgo } = require("../lib/compiler/internal/resolveTsgo.js");
+const tsgo = resolveTsgo({ cwd: path.resolve(__dirname, "..") }).binary;
+
+test("TtscCompiler.compile returns output without writing project files", () => {
+  const root = createProject();
+  const compiler = new TtscCompiler({ binary: tsgo, cwd: root, plugins: false });
+
+  const result = compiler.compile();
+
+  assert.equal(result.type, "success");
+  assert.match(result.output["dist/main.js"], /api-ok/);
+  assert.match(result.output["dist/main.js"], /console\.log\(\s*message\s*\)/);
+  assert.match(result.output["dist/main.d.ts"], /declare const message/);
+  assert.match(result.output["dist/main.js.map"], /"version":3/);
+  assert.match(result.output["dist/main.d.ts.map"], /"version":3/);
+  assert.equal(fs.existsSync(path.join(root, "dist")), false);
+});
+
+test("TtscCompiler can disable project plugin loading", () => {
+  const root = createProject({
+    plugins: [{ transform: "./missing-plugin.cjs" }],
+  });
+  const compiler = new TtscCompiler({ binary: tsgo, cwd: root, plugins: false });
+
+  const result = compiler.compile();
+
+  assert.equal(result.type, "success");
+});
+
+test("TtscCompiler.compile applies configured source plugins without project output", () => {
+  const root = createProject({
+    plugins: [{ transform: "./plugin.cjs" }],
+    source: 'export const value = goUpper("plugin");\nconsole.log(value);\n',
+  });
+  writeCompilerPlugin(root);
+  const compiler = new TtscCompiler({ binary: tsgo, cwd: root });
+
+  const result = compiler.compile();
+
+  assert.equal(result.type, "success");
+  assert.match(result.output["dist/main.js"], /PLUGIN/);
+  assert.equal(fs.existsSync(path.join(root, "dist")), false);
+});
+
+test("TtscCompiler.compile returns structured diagnostics", () => {
+  const root = createProject({
+    source: 'const value: number = "not-a-number";\nconsole.log(value);\n',
+  });
+  const compiler = new TtscCompiler({ binary: tsgo, cwd: root, plugins: false });
+
+  const result = compiler.compile();
+
+  assert.equal(result.type, "failure");
+  assert.equal(result.diagnostics.length, 1);
+  assert.equal(result.diagnostics[0].category, "error");
+  assert.equal(result.diagnostics[0].code, 2322);
+  assert.equal(typeof result.diagnostics[0].start, "number");
+  assert.equal(typeof result.diagnostics[0].length, "number");
+  assert.equal(result.diagnostics[0].line, 1);
+  assert.equal(result.diagnostics[0].character, 7);
+  assert.equal(result.diagnostics[0].file.endsWith("src/main.ts"), true);
+  assert.match(result.diagnostics[0].messageText, /not assignable/);
+  assert.equal(typeof result.output, "object");
+  assert.equal(fs.existsSync(path.join(root, "dist")), false);
+});
+
+test("TtscCompiler.compile does not accept per-call context overrides", () => {
+  const root = createProject();
+  const other = createProject({
+    plugins: [{ transform: "./missing-plugin.cjs" }],
+  });
+  const compiler = new TtscCompiler({ binary: tsgo, cwd: root, plugins: false });
+
+  const result = compiler.compile({
+    binary: path.join(other, "missing-tsgo"),
+    cwd: other,
+    plugins: [{ transform: "./missing-plugin.cjs" }],
+  });
+
+  assert.equal(result.type, "success");
+  assert.match(result.output["dist/main.js"], /api-ok/);
+  assert.equal(fs.existsSync(path.join(root, "dist")), false);
+  assert.equal(fs.existsSync(path.join(other, "dist")), false);
+});
+
+test("TtscCompiler.prepare builds source plugins and clean removes context cache", () => {
+  const root = createProject({
+    plugins: [{ transform: "./plugin.cjs" }],
+  });
+  writeSourcePlugin(root);
+  const cacheDir = path.join(root, ".cache", "ttsc");
+  const compiler = new TtscCompiler({ binary: tsgo, cacheDir, cwd: root });
+
+  const prepared = compiler.prepare();
+
+  assert.equal(prepared.length, 1);
+  assert.equal(fs.existsSync(prepared[0]), true);
+  assert.equal(prepared[0].startsWith(path.join(cacheDir, "plugins")), true);
+
+  const removed = compiler.clean();
+
+  assert.deepEqual(removed, [cacheDir]);
+  assert.equal(fs.existsSync(cacheDir), false);
+});
+
+function createProject(options = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-compiler-api-"));
+  fs.mkdirSync(path.join(root, "src"), { recursive: true });
+  fs.writeFileSync(
+    path.join(root, "src", "main.ts"),
+    options.source ??
+      'const message: string = "api-ok";\nconsole.log(message);\n',
+    "utf8",
+  );
+  fs.writeFileSync(
+    path.join(root, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "commonjs",
+          strict: true,
+          outDir: "dist",
+          declaration: true,
+          declarationMap: true,
+          rootDir: "src",
+          sourceMap: true,
+          plugins: options.plugins,
+        },
+        include: ["src"],
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  return root;
+}
+
+function writeSourcePlugin(root) {
+  fs.writeFileSync(
+    path.join(root, "plugin.cjs"),
+    'module.exports = { name: "prepare-fixture", source: "./plugin-go" };\n',
+    "utf8",
+  );
+  fs.mkdirSync(path.join(root, "plugin-go"), { recursive: true });
+  fs.writeFileSync(
+    path.join(root, "plugin-go", "go.mod"),
+    "module example.com/preparefixture\n\ngo 1.26\n",
+    "utf8",
+  );
+  fs.writeFileSync(
+    path.join(root, "plugin-go", "main.go"),
+    "package main\n\nfunc main() {}\n",
+    "utf8",
+  );
+}
+
+function writeCompilerPlugin(root) {
+  fs.writeFileSync(
+    path.join(root, "plugin.cjs"),
+    'module.exports = { name: "compile-fixture", source: "./plugin-go" };\n',
+    "utf8",
+  );
+  fs.mkdirSync(path.join(root, "plugin-go"), { recursive: true });
+  fs.writeFileSync(
+    path.join(root, "plugin-go", "go.mod"),
+    "module example.com/compilefixture\n\ngo 1.26\n",
+    "utf8",
+  );
+  fs.writeFileSync(
+    path.join(root, "plugin-go", "main.go"),
+    [
+      "package main",
+      "",
+      "import (",
+      '\t"flag"',
+      '\t"fmt"',
+      '\t"os"',
+      '\t"path/filepath"',
+      '\t"strings"',
+      ")",
+      "",
+      "func main() { os.Exit(run(os.Args[1:])) }",
+      "",
+      "func run(args []string) int {",
+      "\tif len(args) == 0 { return 2 }",
+      "\tswitch args[0] {",
+      '\tcase "build":',
+      "\t\treturn build(args[1:])",
+      '\tcase "check", "version":',
+      "\t\treturn 0",
+      "\tdefault:",
+      "\t\treturn 2",
+      "\t}",
+      "}",
+      "",
+      "func build(args []string) int {",
+      '\tfs := flag.NewFlagSet("build", flag.ContinueOnError)',
+      '\tfs.SetOutput(os.Stderr)',
+      '\tcwd := fs.String("cwd", "", "")',
+      '\toutDir := fs.String("outDir", "dist", "")',
+      '\t_ = fs.String("tsconfig", "", "")',
+      '\t_ = fs.String("plugins-json", "", "")',
+      '\t_ = fs.Bool("emit", false, "")',
+      '\t_ = fs.Bool("quiet", false, "")',
+      '\t_ = fs.Bool("verbose", false, "")',
+      '\t_ = fs.Bool("noEmit", false, "")',
+      "\tif err := fs.Parse(args); err != nil { return 2 }",
+      "\troot := *cwd",
+      "\tif root == \"\" { root, _ = os.Getwd() }",
+      '\tinput, err := os.ReadFile(filepath.Join(root, "src", "main.ts"))',
+      '\tif err != nil { fmt.Fprintln(os.Stderr, err); return 2 }',
+      '\tvalue := "PLUGIN"',
+      '\tif !strings.Contains(string(input), `goUpper("plugin")`) { value = "UNKNOWN" }',
+      '\toutput := fmt.Sprintf("\\"use strict\\";\\nObject.defineProperty(exports, \\"__esModule\\", { value: true });\\nexports.value = void 0;\\nconst value = %q;\\nexports.value = value;\\nconsole.log(value);\\n", value)',
+      '\tfile := filepath.Join(*outDir, "main.js")',
+      "\tif !filepath.IsAbs(*outDir) { file = filepath.Join(root, *outDir, \"main.js\") }",
+      "\tif err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil { fmt.Fprintln(os.Stderr, err); return 2 }",
+      "\tif err := os.WriteFile(file, []byte(output), 0o644); err != nil { fmt.Fprintln(os.Stderr, err); return 2 }",
+      "\treturn 0",
+      "}",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+}

package/test/platform.test.ts

@@ -1,58 +1,14 @@
 const assert = require("node:assert/strict");
 const test = require("node:test");
 const {
-  binaryName,
-  installHint,
-  platformPackageRequest,
   resolveBinary,
-} = require("../src/platform.ts");
+} = require("../lib/compiler/internal/resolveBinary.js");
 
 test("resolveBinary prefers TTSC_BINARY absolute override", () => {
   const resolved = resolveBinary({
     env: {
       TTSC_BINARY: "/tmp/custom-ttsc",
     },
-    localBinaryLookup: () => "/tmp/local-ttsc",
-    resolver: () => {
-      throw new Error("resolver should not be called when TTSC_BINARY is set");
-    },
   });
   assert.equal(resolved, "/tmp/custom-ttsc");
 });
-
-test("resolveBinary falls back to local binary when optional package is missing", () => {
-  const resolved = resolveBinary({
-    env: {},
-    localBinaryLookup: () => "/tmp/local-ttsc",
-    resolver: () => {
-      throw new Error("optional package missing");
-    },
-  });
-  assert.equal(resolved, "/tmp/local-ttsc");
-});
-
-test("resolveBinary returns null when only published and local binaries are missing", () => {
-  const resolved = resolveBinary({
-    env: {},
-    localBinaryLookup: () => null,
-    moduleDir: `${process.cwd()}/src`,
-    resolver: () => {
-      throw new Error("optional package missing");
-    },
-  });
-  assert.equal(resolved, null);
-});
-
-test("platform helpers describe the published package contract", () => {
-  assert.equal(binaryName({ platform: "win32" }), "ttsc.exe");
-  assert.equal(binaryName({ platform: "linux" }), "ttsc");
-  assert.equal(
-    platformPackageRequest({ platform: "linux", arch: "x64" }),
-    "@ttsc/linux-x64/bin/ttsc",
-  );
-
-  const hint = installHint({ platform: "linux", arch: "x64" });
-  assert.match(hint, /@ttsc\/linux-x64/);
-  assert.match(hint, /TTSC_BINARY env var/);
-  assert.doesNotMatch(hint, /ttsc-dev\.js/);
-});

package/test/project.test.ts

@@ -6,8 +6,10 @@ const test = require("node:test");
 
 const {
   readProjectConfig,
+} = require("../lib/compiler/internal/project/readProjectConfig.js");
+const {
   resolveProjectConfig,
-} = require("../src/project.ts");
+} = require("../lib/compiler/internal/project/resolveProjectConfig.js");
 
 test("resolveProjectConfig canonicalizes symlinked tsconfig paths", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-project-"));

package/test/source-build.test.ts

@@ -5,228 +5,41 @@ const path = require("node:path");
 const test = require("node:test");
 
 const {
-  bundledGoPackageRequest,
-  computeCacheKey,
-  goBinaryName,
-  pluginCacheCleanupTargets,
-  resolveDefaultPluginCacheRoot,
-  resolveGoCompiler,
-  resolvePluginCacheRoot,
-  sourceBuildWorkspaceReplacements,
-} = require("../src/source-build.ts");
-
-function withTempSourceDir(files: Record<string, string>): string {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-cache-key-"));
-  for (const [name, contents] of Object.entries(files)) {
-    const file = path.join(root, name);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, contents, "utf8");
-  }
-  return root;
-}
-
-test("computeCacheKey is stable across calls for identical inputs", () => {
-  const dir = withTempSourceDir({
-    "go.mod": "module example\n\ngo 1.26\n",
-    "main.go": "package main\nfunc main() {}\n",
-  });
-  const inputs = { dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev" };
-  assert.equal(computeCacheKey(inputs), computeCacheKey(inputs));
-});
-
-test("computeCacheKey changes when ttscVersion changes", () => {
-  const dir = withTempSourceDir({
-    "go.mod": "module example\n\ngo 1.26\n",
-    "main.go": "package main\nfunc main() {}\n",
-  });
-  const a = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev" });
-  const b = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.1", tsgoVersion: "7.0.0-dev" });
-  assert.notEqual(a, b);
-});
-
-test("computeCacheKey changes when tsgoVersion changes", () => {
-  const dir = withTempSourceDir({
-    "go.mod": "module example\n\ngo 1.26\n",
-    "main.go": "package main\nfunc main() {}\n",
-  });
-  const a = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev.A" });
-  const b = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev.B" });
-  assert.notEqual(a, b);
-});
-
-test("computeCacheKey changes when entry changes", () => {
-  const dir = withTempSourceDir({
-    "go.mod": "module example\n\ngo 1.26\n",
-    "main.go": "package main\nfunc main() {}\n",
-    "cmd/foo/main.go": "package main\nfunc main() {}\n",
-  });
-  const a = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
-  const b = computeCacheKey({ dir, entry: "./cmd/foo", ttscVersion: "1.0.0", tsgoVersion: "x" });
-  assert.notEqual(a, b);
-});
-
-test("computeCacheKey changes when source content changes", () => {
-  const dir = withTempSourceDir({
-    "go.mod": "module example\n\ngo 1.26\n",
-    "main.go": "package main\nfunc main() {}\n",
-  });
-  const before = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
-  fs.writeFileSync(
-    path.join(dir, "main.go"),
-    "package main\nfunc main() { _ = 1 }\n",
-  );
-  const after = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
-  assert.notEqual(before, after);
-});
-
-test("computeCacheKey ignores non-Go files (e.g. README.md)", () => {
-  const dir = withTempSourceDir({
-    "go.mod": "module example\n\ngo 1.26\n",
-    "main.go": "package main\nfunc main() {}\n",
-  });
-  const before = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
-  fs.writeFileSync(path.join(dir, "README.md"), "documentation\n");
-  const after = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
-  assert.equal(before, after);
-});
-
-test("resolveGoCompiler prefers TTSC_GO_BINARY override", () => {
-  const resolved = resolveGoCompiler({
-    env: { TTSC_GO_BINARY: "/tmp/custom-go" },
-    localGoLookup: () => "/tmp/local-go",
-    resolver: () => {
-      throw new Error("resolver should not be called when TTSC_GO_BINARY is set");
-    },
-  });
-  assert.equal(resolved, "/tmp/custom-go");
-});
-
-test("resolveGoCompiler uses bundled platform package before PATH fallback", () => {
-  const resolved = resolveGoCompiler({
-    arch: "x64",
-    env: {},
-    localGoLookup: () => null,
-    platform: "linux",
-    resolver: (request) => {
-      assert.equal(request, "@ttsc/linux-x64/bin/go/bin/go");
-      return "/node_modules/@ttsc/linux-x64/bin/go/bin/go";
-    },
-  });
-  assert.equal(resolved, "/node_modules/@ttsc/linux-x64/bin/go/bin/go");
-});
-
-test("resolveGoCompiler falls back to package-local bundled Go before PATH", () => {
-  const resolved = resolveGoCompiler({
-    env: {},
-    localGoLookup: () => "/workspace/packages/ttsc/native/go/bin/go",
-    resolver: () => {
-      throw new Error("platform package missing");
-    },
-  });
-  assert.equal(resolved, "/workspace/packages/ttsc/native/go/bin/go");
-});
-
-test("resolveGoCompiler keeps go on PATH as the last development fallback", () => {
-  const resolved = resolveGoCompiler({
-    env: {},
-    localGoLookup: () => null,
-    resolver: () => {
-      throw new Error("platform package missing");
-    },
-  });
-  assert.equal(resolved, "go");
-});
-
-test("bundled Go package request follows platform package layout", () => {
-  assert.equal(goBinaryName({ platform: "win32" }), "go.exe");
-  assert.equal(goBinaryName({ platform: "linux" }), "go");
-  assert.equal(
-    bundledGoPackageRequest({ platform: "darwin", arch: "arm64" }),
-    "@ttsc/darwin-arm64/bin/go/bin/go",
-  );
-  assert.equal(
-    bundledGoPackageRequest({ platform: "win32", arch: "x64" }),
-    "@ttsc/win32-x64/bin/go/bin/go.exe",
+  buildSourcePlugin,
+} = require("../lib/plugin/internal/buildSourcePlugin.js");
+
+test("buildSourcePlugin rejects a source outside a nearby Go module", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-source-plugin-"));
+  const source = path.join(root, "a", "b", "c", "d", "cmd");
+  fs.mkdirSync(source, { recursive: true });
+
+  assert.throws(
+    () =>
+      buildSourcePlugin({
+        baseDir: root,
+        pluginName: "missing-go-mod",
+        source,
+        ttscVersion: "1.0.0",
+        tsgoVersion: "7.0.0-dev",
+      }),
+    /go\.mod within 3 parent directories/,
   );
 });
 
-test("sourceBuildWorkspaceReplacements pins the ttsc module for source plugins", () => {
-  const ttscRoot = withTempSourceDir({
-    "go.mod": "module github.com/samchon/ttsc/packages/ttsc\n\ngo 1.26\n",
-  });
-  const otherRoot = withTempSourceDir({
-    "go.mod": "module example.com/other\n\ngo 1.26\n",
-  });
-  assert.deepEqual(sourceBuildWorkspaceReplacements([otherRoot, ttscRoot]), [
-    `replace github.com/samchon/ttsc/packages/ttsc v0.0.0 => ${ttscRoot.replace(/\\/g, "/")}`,
-  ]);
-});
-
-test("resolvePluginCacheRoot prefers project node_modules cache", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
-  fs.mkdirSync(path.join(root, "node_modules"));
-  assert.equal(
-    resolvePluginCacheRoot(root),
-    path.join(root, "node_modules", ".ttsc", "plugins"),
+test("buildSourcePlugin rejects non-directory and non-go.mod sources", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-source-plugin-"));
+  const source = path.join(root, "plugin.txt");
+  fs.writeFileSync(source, "not a Go package\n", "utf8");
+
+  assert.throws(
+    () =>
+      buildSourcePlugin({
+        baseDir: root,
+        pluginName: "bad-source",
+        source,
+        ttscVersion: "1.0.0",
+        tsgoVersion: "7.0.0-dev",
+      }),
+    /Go package directory or go\.mod file/,
   );
 });
-
-test("resolvePluginCacheRoot falls back to project .ttsc without node_modules", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
-  assert.equal(resolvePluginCacheRoot(root), path.join(root, ".ttsc", "plugins"));
-});
-
-test("resolveDefaultPluginCacheRoot ignores TTSC_CACHE_DIR for local clean paths", () => {
-  const previous = process.env.TTSC_CACHE_DIR;
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
-  fs.mkdirSync(path.join(root, "node_modules"));
-  try {
-    process.env.TTSC_CACHE_DIR = path.join(root, "override");
-    assert.equal(
-      resolveDefaultPluginCacheRoot(root),
-      path.join(root, "node_modules", ".ttsc", "plugins"),
-    );
-  } finally {
-    if (previous === undefined) {
-      delete process.env.TTSC_CACHE_DIR;
-    } else {
-      process.env.TTSC_CACHE_DIR = previous;
-    }
-  }
-});
-
-test("resolvePluginCacheRoot honors TTSC_CACHE_DIR as an explicit test override", () => {
-  const previous = process.env.TTSC_CACHE_DIR;
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
-  const override = path.join(root, "override");
-  try {
-    process.env.TTSC_CACHE_DIR = override;
-    assert.equal(resolvePluginCacheRoot(root), path.join(override, "plugins"));
-  } finally {
-    if (previous === undefined) {
-      delete process.env.TTSC_CACHE_DIR;
-    } else {
-      process.env.TTSC_CACHE_DIR = previous;
-    }
-  }
-});
-
-test("pluginCacheCleanupTargets deletes both local roots and explicit override", () => {
-  const previous = process.env.TTSC_CACHE_DIR;
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
-  const override = path.join(root, "override");
-  try {
-    process.env.TTSC_CACHE_DIR = override;
-    assert.deepEqual(pluginCacheCleanupTargets(root), [
-      path.join(root, "node_modules", ".ttsc"),
-      path.join(root, ".ttsc"),
-      path.join(override, "plugins"),
-    ]);
-  } finally {
-    if (previous === undefined) {
-      delete process.env.TTSC_CACHE_DIR;
-    } else {
-      process.env.TTSC_CACHE_DIR = previous;
-    }
-  }
-});

package/test/tsgo.test.ts

@@ -3,10 +3,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 const test = require("node:test");
-const {
-  nativePreviewPlatformPackage,
-  resolveTsgo,
-} = require("../src/tsgo.ts");
+const { resolveTsgo } = require("../lib/compiler/internal/resolveTsgo.js");
 
 test("resolveTsgo accepts TTSC_TSGO_BINARY as an explicit compiler", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-tsgo-test-"));
@@ -61,8 +58,4 @@ test("resolveTsgo resolves the consumer native-preview platform package", () =>
   assert.equal(resolved.version, "7.0.0-dev.consumer");
   assert.equal(resolved.gitHead, "abc123");
   assert.equal(resolved.binary, path.join(platformRoot, "lib", "tsgo"));
-  assert.equal(
-    nativePreviewPlatformPackage({ platform: "linux", arch: "x64" }),
-    "@typescript/native-preview-linux-x64",
-  );
 });

package/lib/api.d.ts

@@ -1,40 +0,0 @@
-import type { ITtscBuildOptions } from "./structures/ITtscBuildOptions";
-import type { ITtscBuildResult } from "./structures/ITtscBuildResult";
-import type { ITtscCheckOptions } from "./structures/ITtscCheckOptions";
-import type { ITtscCommonOptions } from "./structures/ITtscCommonOptions";
-import type { ITtscTransformOptions } from "./structures/ITtscTransformOptions";
-export type { ITtscBuildOptions } from "./structures/ITtscBuildOptions";
-export type { ITtscBuildResult } from "./structures/ITtscBuildResult";
-export type { ITtscCheckOptions } from "./structures/ITtscCheckOptions";
-export type { ITtscCommonOptions } from "./structures/ITtscCommonOptions";
-export type { ITtscTransformOptions } from "./structures/ITtscTransformOptions";
-/**
- * Transform a single .ts file and return the rewritten JS as a string.
- *
- * Intended for bundler per-file transforms (unplugin `transform()`). The caller
- * passes the absolute path; ttsc loads the enclosing tsconfig, compiles with
- * tsgo, and returns the rewritten JS.
- *
- * Throws when the binary exits non-zero — the error includes stderr so bundler
- * error overlays surface the real cause.
- */
-export declare function transform(options: ITtscTransformOptions): string;
-/**
- * Run `ttsc` against a tsconfig. Returns once the binary exits so the caller
- * can decide how to surface diagnostics. Does not throw on non-zero exit —
- * bundler pipelines often want to continue and collect errors.
- */
-export declare function build(options?: ITtscBuildOptions): ITtscBuildResult;
-/**
- * Run `ttsc check` (build without emit) — CI gate / pre-commit hook use.
- * Resolves with an exit-code record; does not throw.
- */
-export declare function check(options?: ITtscCheckOptions): ITtscBuildResult;
-/** Ask the binary for its version banner. Handy for user-agent strings. */
-export declare function version(options?: ITtscCommonOptions): string;
-/**
- * Promise-facing variant of `transform()`. The host path stays synchronous so
- * plugin descriptors can stay dependency-free, but many adapter surfaces still
- * prefer a Promise-returning function.
- */
-export declare function transformAsync(options: ITtscTransformOptions): Promise<string>;