ttsc 0.3.1 → 0.4.0-dev.20260425

package/src/runner/register.ts

@@ -0,0 +1,487 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import {
+  build,
+  check,
+  type CommonOptions,
+  transform,
+} from "../api";
+import {
+  defaultCacheDirectory,
+  resolveProjectConfig,
+  resolveProjectRoot,
+} from "../project";
+import {
+  resolveBinary,
+} from "../platform";
+
+export interface RegisterOptions extends CommonOptions {
+  cacheDir?: string;
+  project?: string;
+  extensions?: readonly string[];
+}
+
+export interface PreparedExecution {
+  emitDir: string;
+  entryFile: string;
+  moduleKind: "cjs" | "esm";
+}
+
+type RequireExtension = (module: NodeJS.Module, filename: string) => void;
+type CompilableModule = NodeJS.Module & {
+  _compile(code: string, filename: string): void;
+};
+
+interface ProjectContext {
+  cacheDir: string;
+  cacheSalt: string;
+  compiledText: Map<string, string>;
+  emitDir: string;
+  emittedFiles: string[] | null;
+  diagnosticsChecked: boolean;
+  entryMap: Map<string, string>;
+  root: string;
+  tsconfig: string;
+}
+
+const DEFAULT_EXTENSIONS: readonly string[] = Object.freeze([
+  ".ts",
+  ".tsx",
+  ".cts",
+  ".mts",
+]);
+
+const PROCESS_CACHE_KEY = String(process.pid);
+const SINGLE_FILE_CACHE_VERSION = "v4";
+
+export function register(options: RegisterOptions = {}): () => void {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const extensions = [...(options.extensions ?? DEFAULT_EXTENSIONS)];
+  const contextCache = new Map<string, ProjectContext>();
+  const previous = new Map<string, RequireExtension | undefined>();
+
+  const getContext = (filename: string): ProjectContext => {
+    if (options.project) {
+      const key = path.resolve(cwd, options.project);
+      const cached = contextCache.get(key);
+      if (cached) return cached;
+      const tsconfig = resolveProjectConfig({ cwd, tsconfig: key });
+      const root = resolveProjectRoot({ cwd, tsconfig });
+      const cacheDir = options.cacheDir ?? defaultCacheDirectory(root, "ttsx");
+      const created = {
+        tsconfig,
+        root,
+        cacheDir,
+        cacheSalt: createCompilerCacheSalt(options),
+        compiledText: new Map<string, string>(),
+        diagnosticsChecked: false,
+        emitDir: path.join(cacheDir, "project", PROCESS_CACHE_KEY),
+        emittedFiles: null,
+        entryMap: new Map<string, string>(),
+      };
+      contextCache.set(key, created);
+      return created;
+    }
+
+    const tsconfig = resolveProjectConfig({ cwd, file: filename });
+    const cached = contextCache.get(tsconfig);
+    if (cached) return cached;
+    const root = resolveProjectRoot({ cwd, tsconfig });
+    const cacheDir = options.cacheDir ?? defaultCacheDirectory(root, "ttsx");
+    const created = {
+      tsconfig,
+      root,
+      cacheDir,
+      cacheSalt: createCompilerCacheSalt(options),
+      compiledText: new Map<string, string>(),
+      diagnosticsChecked: false,
+      emitDir: path.join(cacheDir, "project", PROCESS_CACHE_KEY),
+      emittedFiles: null,
+      entryMap: new Map<string, string>(),
+    };
+    contextCache.set(tsconfig, created);
+    return created;
+  };
+
+  const compile = (filename: string): string => {
+    const context = getContext(filename);
+    ensureProjectDiagnostics(context, options);
+    const output = readCompiledOutput(context, filename, options);
+    if (looksLikeESM(output)) {
+      throw new Error(
+        `ttsx: ESM output is not yet supported by the in-process CJS runner (${filename}).`,
+      );
+    }
+    return output;
+  };
+
+  for (const extension of extensions) {
+    previous.set(extension, require.extensions[extension]);
+    require.extensions[extension] = (module: NodeJS.Module, filename: string) => {
+      const compiled = compile(filename);
+      (module as CompilableModule)._compile(compiled, filename);
+    };
+  }
+
+  return () => {
+    for (const extension of extensions) {
+      const handler = previous.get(extension);
+      if (handler) {
+        require.extensions[extension] = handler;
+      } else {
+        delete require.extensions[extension];
+      }
+    }
+  };
+}
+
+export function prepareExecution(
+  entryFile: string,
+  options: RegisterOptions = {},
+): PreparedExecution {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const context = resolveProjectContext(cwd, entryFile, options);
+  ensureProjectDiagnostics(context, options);
+  const entryOutput = transformSingleFile(context, entryFile, options);
+  if (!looksLikeESM(entryOutput)) {
+    return {
+      emitDir: context.emitDir,
+      entryFile,
+      moduleKind: "cjs",
+    };
+  }
+  ensureProjectBuild(context, options);
+  const resolvedEntry = resolveEmittedFile(context, entryFile);
+  if (resolvedEntry === null) {
+    throw new Error(`ttsx: emitted entry not found for ${entryFile}`);
+  }
+  const output = fs.readFileSync(resolvedEntry, "utf8");
+  return {
+    emitDir: context.emitDir,
+    entryFile: resolvedEntry,
+    moduleKind: looksLikeESM(output) ? "esm" : "cjs",
+  };
+}
+
+function ensureProjectBuild(context: ProjectContext, options: RegisterOptions): void {
+  if (context.emittedFiles !== null) return;
+
+  fs.mkdirSync(context.cacheDir, { recursive: true });
+  fs.rmSync(context.emitDir, { recursive: true, force: true });
+  const result = build({
+    binary: options.binary,
+    cwd: context.root,
+    env: options.env,
+    emit: true,
+    outDir: context.emitDir,
+    quiet: true,
+    tsconfig: context.tsconfig,
+  });
+  if (result.status === 0) {
+    context.emittedFiles = listEmittedFiles(context.emitDir);
+    return;
+  }
+
+  fs.rmSync(context.emitDir, { recursive: true, force: true });
+  const detail = [
+    `ttsx: native project build failed for ${context.tsconfig}`,
+    result.stderr || result.stdout,
+  ]
+    .filter((line) => line.trim().length !== 0)
+    .join("\n");
+  throw new Error(detail);
+}
+
+function readCompiledOutput(
+  context: ProjectContext,
+  filename: string,
+  options: RegisterOptions,
+): string {
+  return transformSingleFile(context, filename, options);
+}
+
+function resolveProjectContext(
+  cwd: string,
+  filename: string,
+  options: RegisterOptions,
+): ProjectContext {
+  if (options.project) {
+    const tsconfig = resolveProjectConfig({
+      cwd,
+      tsconfig: path.resolve(cwd, options.project),
+    });
+    return createProjectContext(cwd, tsconfig, options);
+  }
+  const tsconfig = resolveProjectConfig({ cwd, file: filename });
+  return createProjectContext(cwd, tsconfig, options);
+}
+
+function createProjectContext(
+  cwd: string,
+  tsconfig: string,
+  options: RegisterOptions,
+): ProjectContext {
+  const root = resolveProjectRoot({ cwd, tsconfig });
+  const cacheDir = options.cacheDir ?? defaultCacheDirectory(root, "ttsx");
+  return {
+    tsconfig,
+    root,
+    cacheDir,
+    cacheSalt: createCompilerCacheSalt(options),
+    compiledText: new Map<string, string>(),
+    diagnosticsChecked: false,
+    emitDir: path.join(cacheDir, "project", PROCESS_CACHE_KEY),
+    emittedFiles: null,
+    entryMap: new Map<string, string>(),
+  };
+}
+
+function ensureProjectDiagnostics(
+  context: ProjectContext,
+  options: RegisterOptions,
+): void {
+  if (context.diagnosticsChecked) {
+    return;
+  }
+  const result = check({
+    binary: options.binary,
+    cwd: context.root,
+    env: options.env,
+    plugins: options.plugins,
+    quiet: true,
+    rewriteMode: options.rewriteMode,
+    tsconfig: context.tsconfig,
+  });
+  if (result.status !== 0) {
+    const detail = [result.stderr.trim(), result.stdout.trim()]
+      .filter(Boolean)
+      .join("\n");
+    throw new Error(
+      `ttsx: project check failed for ${context.tsconfig}` +
+        (detail ? `\n${detail}` : ""),
+    );
+  }
+  context.diagnosticsChecked = true;
+}
+
+function transformSingleFile(
+  context: ProjectContext,
+  filename: string,
+  options: RegisterOptions,
+): string {
+  const normalized = path.resolve(filename);
+  const cached = context.compiledText.get(normalized);
+  if (cached !== undefined) return cached;
+
+  const cacheFile = singleFileCachePath(context, normalized);
+  const sourceStat = safeStat(normalized);
+  const cacheStat = safeStat(cacheFile);
+  if (
+    sourceStat &&
+    cacheStat &&
+    cacheStat.isFile() &&
+    cacheStat.mtimeMs >= sourceStat.mtimeMs
+  ) {
+    const output = fs.readFileSync(cacheFile, "utf8");
+    context.compiledText.set(normalized, output);
+    return output;
+  }
+
+  const output = transform({
+    binary: options.binary,
+    cwd: context.root,
+    env: options.env,
+    file: normalized,
+    rewriteMode: options.rewriteMode,
+    tsconfig: context.tsconfig,
+  });
+  fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+  fs.writeFileSync(cacheFile, output, "utf8");
+  context.compiledText.set(normalized, output);
+  return output;
+}
+
+function singleFileCachePath(context: ProjectContext, filename: string): string {
+  const digest = createHash("sha1")
+    .update(context.cacheSalt)
+    .update("\0")
+    .update(filename)
+    .digest("hex");
+  return path.join(
+    context.cacheDir,
+    "single",
+    SINGLE_FILE_CACHE_VERSION,
+    `${digest}.js`,
+  );
+}
+
+function createCompilerCacheSalt(options: RegisterOptions): string {
+  const parts = [SINGLE_FILE_CACHE_VERSION];
+  const binary = resolveBinary(options);
+  if (binary) {
+    parts.push(fileSignature(binary));
+    for (const location of workspaceCompilerLocations(binary)) {
+      const signature = treeSignature(location);
+      if (signature) {
+        parts.push(signature);
+      }
+    }
+  }
+  return parts.join("|");
+}
+
+function workspaceCompilerLocations(binary: string): string[] {
+  const resolved = path.resolve(binary);
+  const packageRoot = path.resolve(path.dirname(resolved), "..");
+  const candidates = [
+    path.resolve(packageRoot, "cmd"),
+    path.resolve(packageRoot, "src"),
+  ];
+  return candidates.filter((location) => fs.existsSync(location));
+}
+
+function fileSignature(file: string): string {
+  const stat = safeStat(file);
+  if (!stat) return `missing:${path.resolve(file)}`;
+  return `file:${path.resolve(file)}:${stat.size}:${stat.mtimeMs}`;
+}
+
+function treeSignature(root: string): string | null {
+  if (!fs.existsSync(root)) return null;
+  let latest = 0;
+  let count = 0;
+  const stack = [root];
+  while (stack.length !== 0) {
+    const current = stack.pop()!;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const next = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(next);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!/\.(?:go|[cm]?js|ts)$/.test(entry.name)) continue;
+      const stat = safeStat(next);
+      if (!stat) continue;
+      latest = Math.max(latest, stat.mtimeMs);
+      count += 1;
+    }
+  }
+  return `tree:${path.resolve(root)}:${count}:${latest}`;
+}
+
+function safeStat(file: string): fs.Stats | null {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+}
+
+function resolveEmittedFile(context: ProjectContext, filename: string): string | null {
+  const normalized = path.resolve(filename);
+  const cached = context.entryMap.get(normalized);
+  if (cached && fs.existsSync(cached)) return cached;
+
+  const exact = resolveExactEmittedFile(context, normalized);
+  if (exact && fs.existsSync(exact)) {
+    context.entryMap.set(normalized, exact);
+    return exact;
+  }
+
+  const files = context.emittedFiles ?? [];
+  let best: string | null = null;
+  let bestScore = 0;
+  for (const file of files) {
+    const score = sharedSourceStemSegments(file, normalized);
+    if (score > bestScore) {
+      best = file;
+      bestScore = score;
+    }
+  }
+  if (!best || !fs.existsSync(best)) {
+    return null;
+  }
+  context.entryMap.set(normalized, best);
+  return best;
+}
+
+function resolveExactEmittedFile(
+  context: ProjectContext,
+  filename: string,
+): string | null {
+  const relative = path.relative(context.root, filename);
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return null;
+  }
+  return path.resolve(
+    context.emitDir,
+    relative.slice(0, relative.length - path.extname(relative).length) +
+      emittedJavaScriptExtension(filename),
+  );
+}
+
+function listEmittedFiles(root: string): string[] {
+  if (!fs.existsSync(root)) return [];
+  const output: string[] = [];
+  const stack = [root];
+  while (stack.length !== 0) {
+    const current = stack.pop()!;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const next = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(next);
+      } else if (entry.isFile() && isJavaScriptOutput(next)) {
+        output.push(path.resolve(next));
+      }
+    }
+  }
+  return output;
+}
+
+function sharedSourceStemSegments(outPath: string, srcPath: string): number {
+  const trim = (location: string): string[] => {
+    const normalized = location.split(path.sep).join("/");
+    return normalized
+      .slice(0, normalized.length - path.extname(normalized).length)
+      .split("/");
+  };
+  const a = trim(outPath);
+  const b = trim(srcPath);
+  const count = Math.min(a.length, b.length);
+  let shared = 0;
+  for (let i = 1; i <= count; i += 1) {
+    if (a[a.length - i] !== b[b.length - i]) break;
+    shared += 1;
+  }
+  return shared;
+}
+
+function looksLikeESM(output: string): boolean {
+  if (
+    /\bObject\.defineProperty\(exports\b/.test(output) ||
+    /\bmodule\.exports\b/.test(output) ||
+    /\brequire\(/.test(output) ||
+    /\bexports\./.test(output)
+  ) {
+    return false;
+  }
+  return /^\s*(import|export)\s/m.test(output);
+}
+
+function emittedJavaScriptExtension(filename: string): string {
+  switch (path.extname(filename).toLowerCase()) {
+    case ".mts":
+      return ".mjs";
+    case ".cts":
+      return ".cjs";
+    default:
+      return ".js";
+  }
+}
+
+function isJavaScriptOutput(filename: string): boolean {
+  return /\.(?:[cm]?js)$/i.test(filename);
+}

package/test/native.test.ts

@@ -0,0 +1,60 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { resolveNativeBackend } = require("../src/native.ts");
+
+test("resolveNativeBackend accepts versioned native backend descriptors", () => {
+  const backend = resolveNativeBackend({
+    name: "native-test",
+    native: {
+      mode: "native-test",
+      binary: "/tmp/ttsc-native-test",
+      contractVersion: 1,
+      capabilities: ["rewrite", "diagnostics"],
+    },
+  });
+
+  assert.deepEqual(backend, {
+    mode: "native-test",
+    binary: "/tmp/ttsc-native-test",
+    contractVersion: 1,
+    capabilities: ["rewrite", "diagnostics"],
+  });
+});
+
+test("resolveNativeBackend keeps nativeMode/nativeBinary as a legacy alias", () => {
+  const backend = resolveNativeBackend({
+    name: "legacy-native-test",
+    nativeMode: "legacy-native-test",
+    nativeBinary: "/tmp/ttsc-legacy-native-test",
+  });
+
+  assert.deepEqual(backend, {
+    mode: "legacy-native-test",
+    binary: "/tmp/ttsc-legacy-native-test",
+    contractVersion: 1,
+  });
+});
+
+test("resolveNativeBackend rejects ambiguous native declarations", () => {
+  assert.throws(
+    () =>
+      resolveNativeBackend({
+        name: "bad-native-test",
+        native: { mode: "native-test" },
+        nativeMode: "native-test",
+      }),
+    /must use either native or nativeMode\/nativeBinary/,
+  );
+});
+
+test("resolveNativeBackend rejects unsupported native contract versions", () => {
+  assert.throws(
+    () =>
+      resolveNativeBackend({
+        name: "future-native-test",
+        native: { mode: "native-test", contractVersion: 2 },
+      }),
+    /unsupported native contract version 2/,
+  );
+});

package/test/package.test.ts

@@ -0,0 +1,131 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+const workspaceRoot = path.resolve(__dirname, "../../..");
+
+test("package metadata separates monorepo source exports from publish exports", () => {
+  const packageJson = readPackageJson("ttsc");
+  assert.match(packageJson.main, /^src\/.+\.ts$/);
+  assert.match(packageJson.types, /^src\/.+\.ts$/);
+  assert.equal(packageJson.exports["."].types, "./src/index.ts");
+  assert.equal(packageJson.exports["."].import, "./src/index.ts");
+  assert.equal(packageJson.exports["."].require, "./lib/index.js");
+  assert.equal(packageJson.exports["."].default, "./src/index.ts");
+  assert.equal(packageJson.publishConfig.main, "lib/index.js");
+  assert.equal(packageJson.publishConfig.types, "lib/index.d.ts");
+  assert.equal(
+    packageJson.publishConfig.exports["."].types,
+    "./lib/index.d.ts",
+  );
+  assert.equal(
+    packageJson.publishConfig.exports["."].default,
+    "./lib/index.js",
+  );
+});
+
+test("ttsc package owns both compiler and runtime commands", () => {
+  const packageJson = readPackageJson("ttsc");
+  assert.deepEqual(packageJson.bin, {
+    ttsc: "src/launcher/ttsc.js",
+    ttsx: "src/launcher/ttsx.js",
+  });
+  assert.deepEqual(packageJson.publishConfig.bin, packageJson.bin);
+});
+
+test("ttsc exposes plugin helpers through the root package only", () => {
+  const packageJson = readPackageJson("ttsc");
+  assert.equal(packageJson.exports["./plugin"], undefined);
+  assert.equal(packageJson.publishConfig.exports["./plugin"], undefined);
+  assert.equal(
+    fs.existsSync(path.join(workspaceRoot, "packages", "ttsc", "src", "plugin.ts")),
+    true,
+  );
+  assert.equal(
+    fs.existsSync(path.join(workspaceRoot, "packages", "ttsc", "src", "index.ts")),
+    true,
+  );
+});
+
+test("ttsc declares platform packages as optional dependencies", () => {
+  const packageJson = readPackageJson("ttsc");
+  const expected = [
+    "@ttsc/linux-x64",
+    "@ttsc/linux-arm64",
+    "@ttsc/darwin-x64",
+    "@ttsc/darwin-arm64",
+    "@ttsc/win32-x64",
+    "@ttsc/win32-arm64",
+  ];
+
+  assert.deepEqual(
+    Object.keys(packageJson.optionalDependencies).sort(),
+    expected.toSorted(),
+  );
+  for (const name of expected) {
+    assert.equal(packageJson.optionalDependencies[name], "workspace:*");
+  }
+  assert.equal(packageJson.files.includes("native"), false);
+});
+
+test("published package file lists keep TypeScript and Go sources", () => {
+  const ttsc = readPackageJson("ttsc");
+  for (const entry of [
+    "cmd",
+    "driver",
+    "shim",
+    "src",
+    "test",
+    "tools",
+    "go.mod",
+    "go.sum",
+  ]) {
+    assert.equal(
+      ttsc.files.includes(entry),
+      true,
+      `ttsc files must include ${entry}`,
+    );
+  }
+  for (const entry of ["native", "node_modules", "THIRD-PARTY-LICENSES.md"]) {
+    assert.equal(
+      ttsc.files.includes(entry),
+      false,
+      `ttsc files must not include ${entry}`,
+    );
+  }
+  assert.equal(ttsc.files.includes("tsconfig.json"), false);
+
+  assert.equal(fs.existsSync(path.join(workspaceRoot, "packages", "ttsx")), false);
+});
+
+test("platform packages expose os cpu constrained native binaries", () => {
+  const matrix = {
+    "ttsc-linux-x64": ["@ttsc/linux-x64", "linux", "x64", "Linux x64"],
+    "ttsc-linux-arm64": ["@ttsc/linux-arm64", "linux", "arm64", "Linux arm64"],
+    "ttsc-darwin-x64": ["@ttsc/darwin-x64", "darwin", "x64", "macOS x64"],
+    "ttsc-darwin-arm64": ["@ttsc/darwin-arm64", "darwin", "arm64", "macOS arm64"],
+    "ttsc-win32-x64": ["@ttsc/win32-x64", "win32", "x64", "Windows x64"],
+    "ttsc-win32-arm64": ["@ttsc/win32-arm64", "win32", "arm64", "Windows arm64"],
+  };
+
+  for (const [dir, [name, os, cpu, label]] of Object.entries(matrix)) {
+    const packageJson = readPackageJson(dir);
+    assert.equal(packageJson.name, name);
+    assert.deepEqual(packageJson.os, [os]);
+    assert.deepEqual(packageJson.cpu, [cpu]);
+    assert.deepEqual(packageJson.files, ["bin", "package.json", "README.md"]);
+    assert.equal(packageJson.scripts.build, "node ../../scripts/build-platform-package.cjs");
+    assert.equal(packageJson.scripts.prepack, "pnpm run build");
+    assert.equal(packageJson.description.includes(label), true);
+  }
+});
+
+function readPackageJson(packageName) {
+  return JSON.parse(
+    fs.readFileSync(
+      path.join(workspaceRoot, "packages", packageName, "package.json"),
+      "utf8",
+    ),
+  );
+}