ttsc 0.18.3 → 0.19.0

package/src/TtscService.ts

@@ -58,9 +58,14 @@ export class TtscService {
    * carries the host's diagnostics so callers can surface a real build error.
    */
   public async transformFile(fileName: string): Promise<string | undefined> {
-    const reply = await this.resident.request({
-      file: this.absolutePath(fileName),
-    });
+    const reply = await this.resident.request(
+      { file: this.absolutePath(fileName) },
+      "transform",
+    );
+    // The resident client already validated the reply shape (boolean `found`,
+    // string `typescript` when found), so a malformed or wrong-shape reply
+    // rejected instead of reaching here. `found: false` is the only path to
+    // `undefined`; a protocol failure never masquerades as an absent file.
     return reply.found === true && typeof reply.typescript === "string"
       ? reply.typescript
       : undefined;
@@ -74,10 +79,13 @@ export class TtscService {
    * `fileName` is resolved against the project root.
    */
   public async updateFile(fileName: string, content: string): Promise<boolean> {
-    const reply = await this.resident.request({
-      content,
-      update: this.absolutePath(fileName),
-    });
+    const reply = await this.resident.request(
+      { content, update: this.absolutePath(fileName) },
+      "update",
+    );
+    // The resident client validated the reply carries a boolean `updated`, so a
+    // malformed or wrong-shape reply rejected instead of collapsing to `false`.
+    // `false` here means only that the edit did not compile.
     return reply.updated === true;
   }
 

package/src/compiler/internal/compileProjectInMemory.ts

@@ -36,7 +36,7 @@ export function compileProjectInMemory(options: ITtscCompilerContext): {
     projectRoot: options.projectRoot,
     tsconfig: options.tsconfig,
   });
-  if (hasConfiguredPlugins(options, project)) {
+  if (shouldUsePluginBuild(options, project)) {
     return compileProjectWithPlugins(options, cwd, project);
   }
   const tsconfig = project.path;
@@ -82,6 +82,22 @@ function hasConfiguredPlugins(
   return hasProjectPluginEntries(project, options.plugins);
 }
 
+/**
+ * Route plugin discovery failures through runBuild's recoverable setup path.
+ * The fast native-host lane cannot surface the plugin error or run the
+ * post-failure TypeScript check, while the plugin-backed lane can do both.
+ */
+function shouldUsePluginBuild(
+  options: ITtscCompilerContext,
+  project: ITtscParsedProjectConfig,
+): boolean {
+  try {
+    return hasConfiguredPlugins(options, project);
+  } catch {
+    return true;
+  }
+}
+
 /**
  * Plugin-backed compilation: emit into a temp directory via `runBuild`, then
  * read back every file the build wrote so they can be returned as strings.
@@ -104,6 +120,7 @@ function compileProjectWithPlugins(
       forceListEmittedFiles: true,
       outDir: tempOutDir,
       quiet: true,
+      resolvedProject: project,
       structuredDiagnostics: true,
       tsconfig: project.path,
     });

package/src/compiler/internal/project/createNativeProjectContextArgs.ts

@@ -0,0 +1,15 @@
+import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
+
+/** Serialize the retained project identity for a native sidecar invocation. */
+export function createNativeProjectContextArgs(
+  project: ITtscParsedProjectConfig,
+  pluginConfigOrigin?: string,
+): string[] {
+  return [
+    "--project-context-json=" +
+      JSON.stringify({
+        ...project.identity,
+        ...(pluginConfigOrigin === undefined ? {} : { pluginConfigOrigin }),
+      }),
+  ];
+}

package/src/compiler/internal/project/readProjectConfig.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import type { ITtscProjectPluginConfig } from "../../../structures/ITtscProjectPluginConfig";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
-import { resolveProjectConfig } from "./resolveProjectConfig";
+import { resolveProjectIdentity } from "./resolveProjectConfig";
 
 /**
  * Compiler option keys whose values are file-system paths that must be resolved
@@ -40,10 +40,9 @@ type ResolvedCompilerOptions = {
 export function readProjectConfig(
   opts: ITtscProjectLocatorOptions = {},
 ): ITtscParsedProjectConfig {
-  const tsconfig = resolveProjectConfig(opts);
-  const root = opts.projectRoot
-    ? path.resolve(opts.cwd ?? process.cwd(), opts.projectRoot)
-    : path.dirname(tsconfig);
+  const identity = resolveProjectIdentity(opts);
+  const tsconfig = identity.physicalConfigPath;
+  const root = identity.physicalProjectRoot;
   const compilerOptions = readResolvedCompilerOptions(tsconfig);
   return {
     compilerOptions: {
@@ -51,6 +50,7 @@ export function readProjectConfig(
       outDir: compilerOptions.outDir,
       plugins: compilerOptions.plugins,
     },
+    identity,
     path: tsconfig,
     pluginBaseDirs: compilerOptions.pluginBaseDirs,
     root,
@@ -254,6 +254,14 @@ function resolveExtendsConfig(tsconfig: string, specifier: string): string {
     return resolveExistingExtendsPath(path.resolve(baseDir, specifier));
   }
   const resolver = createRequire(tsconfig);
+  // A bare package root selects its preset through `package.json#tsconfig`,
+  // matching TypeScript's config resolution. Presets shipped this way often
+  // have no JavaScript/JSON entrypoint at all, so Node's entrypoint resolver
+  // and the `<specifier>.json` fallback below both miss them.
+  const viaManifest = resolvePackageManifestTsconfig(resolver, specifier);
+  if (viaManifest !== undefined) {
+    return resolveExistingExtendsPath(viaManifest);
+  }
   try {
     return resolveRealPath(resolver.resolve(specifier));
   } catch {
@@ -261,6 +269,54 @@ function resolveExtendsConfig(tsconfig: string, specifier: string): string {
   }
 }
 
+/**
+ * When `specifier` names a bare package root, resolve the config file its
+ * `package.json#tsconfig` field selects (anchored at the package directory).
+ * Returns `undefined` when the specifier is a subpath, the manifest is
+ * unresolvable/unparsable, or it declares no `tsconfig` field, so the caller
+ * falls back to Node entrypoint resolution.
+ */
+function resolvePackageManifestTsconfig(
+  resolver: NodeRequire,
+  specifier: string,
+): string | undefined {
+  if (!isBarePackageRoot(specifier)) {
+    return undefined;
+  }
+  let manifestPath: string;
+  try {
+    manifestPath = resolver.resolve(`${specifier}/package.json`);
+  } catch {
+    return undefined;
+  }
+  let field: unknown;
+  try {
+    field = (
+      JSON.parse(stripLeadingBom(fs.readFileSync(manifestPath, "utf8"))) as {
+        tsconfig?: unknown;
+      }
+    ).tsconfig;
+  } catch {
+    return undefined;
+  }
+  if (typeof field !== "string" || field.length === 0) {
+    return undefined;
+  }
+  return path.resolve(path.dirname(manifestPath), field);
+}
+
+/**
+ * Return true when `specifier` is a bare package root (no subpath): a plain
+ * package name (`preset`) or a scoped name (`@scope/preset`). Subpaths such as
+ * `@scope/preset/base.json` resolve directly and keep their current meaning.
+ */
+function isBarePackageRoot(specifier: string): boolean {
+  if (specifier.startsWith("@")) {
+    return specifier.split("/").length === 2;
+  }
+  return !specifier.includes("/");
+}
+
 /**
  * Given an on-disk location, try the path as-is, with `.json` appended, and as
  * a directory containing `tsconfig.json`. Returns the first match or throws.

package/src/compiler/internal/project/resolveProjectConfig.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 
+import type { ITtscProjectIdentity } from "../../../structures/internal/ITtscProjectIdentity";
 import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
 
 /**
@@ -13,13 +14,29 @@ import type { ITtscProjectLocatorOptions } from "../../../structures/internal/IT
  *    walking up from the file's directory.
  * 3. `opts.cwd` — the nearest ancestor config walking up from cwd.
  *
- * Always returns a real (symlink-resolved) absolute path. Throws when no config
- * is found or the explicitly supplied path does not exist.
+ * Returns the real (symlink-resolved) absolute config path. Use
+ * {@link resolveProjectIdentity} when both the caller-selected spelling and the
+ * Program identity are required.
  */
 export function resolveProjectConfig(
   opts: ITtscProjectLocatorOptions = {},
 ): string {
+  return resolveProjectIdentity(opts).physicalConfigPath;
+}
+
+/**
+ * Resolve the selected config while retaining its lexical spelling separately
+ * from the physical paths used by the TypeScript Program.
+ */
+export function resolveProjectIdentity(
+  opts: ITtscProjectLocatorOptions = {},
+): Omit<ITtscProjectIdentity, "pluginConfigOrigin"> {
   const cwd = path.resolve(opts.cwd ?? process.cwd());
+  const explicitProjectRoot =
+    opts.projectRoot === undefined || opts.projectRoot === ""
+      ? undefined
+      : resolveAbsolutePath(cwd, opts.projectRoot);
+  let logicalConfigPath: string;
   if (opts.tsconfig) {
     const resolved = resolveAbsolutePath(cwd, opts.tsconfig);
     if (!fs.existsSync(resolved)) {
@@ -35,30 +52,43 @@ export function resolveProjectConfig(
     if (isDirectory(resolved)) {
       const tsconfigInDir = path.join(resolved, "tsconfig.json");
       if (fs.existsSync(tsconfigInDir)) {
-        return resolveRealPath(tsconfigInDir);
-      }
-      const jsconfigInDir = path.join(resolved, "jsconfig.json");
-      if (fs.existsSync(jsconfigInDir)) {
-        return resolveRealPath(jsconfigInDir);
+        logicalConfigPath = tsconfigInDir;
+      } else {
+        const jsconfigInDir = path.join(resolved, "jsconfig.json");
+        if (fs.existsSync(jsconfigInDir)) {
+          logicalConfigPath = jsconfigInDir;
+        } else {
+          throw new Error(
+            `ttsc: directory has no tsconfig.json / jsconfig.json: ${resolved}`,
+          );
+        }
       }
+    } else {
+      logicalConfigPath = resolved;
+    }
+  } else {
+    const start = opts.file ? resolveAbsolutePath(cwd, opts.file) : cwd;
+    const from = isDirectory(start) ? start : path.dirname(start);
+    const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
+    if (!found) {
       throw new Error(
-        `ttsc: directory has no tsconfig.json / jsconfig.json: ${resolved}`,
+        `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
       );
     }
-    return resolveRealPath(resolved);
-  }
-
-  const start = opts.file
-    ? resolveRealPath(resolveAbsolutePath(cwd, opts.file))
-    : cwd;
-  const from = isDirectory(start) ? start : path.dirname(start);
-  const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
-  if (!found) {
-    throw new Error(
-      `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
-    );
+    logicalConfigPath = found;
   }
-  return resolveRealPath(found);
+  const physicalConfigPath = resolveRealPath(logicalConfigPath);
+  const physicalProjectRoot = resolveRealPath(
+    explicitProjectRoot ?? path.dirname(physicalConfigPath),
+  );
+  return {
+    ...(explicitProjectRoot === undefined ? {} : { explicitProjectRoot }),
+    invocationCwd: cwd,
+    logicalConfigPath,
+    logicalProjectRoot: path.dirname(logicalConfigPath),
+    physicalConfigPath,
+    physicalProjectRoot,
+  };
 }
 
 /** Resolve `target` against `cwd` when it is not already absolute. */

package/src/compiler/internal/residentTransformProcess.ts

@@ -4,6 +4,19 @@ import { type Interface, createInterface } from "node:readline";
 /** Cap on retained stderr so a long-lived host cannot grow it without bound. */
 const STDERR_TAIL_LIMIT = 64 * 1024;
 
+/** Cap on how much of an offending line an error message echoes back. */
+const REPLY_ECHO_LIMIT = 200;
+
+/**
+ * The operation a request expects a reply for. The host answers a transform
+ * request (`{"file":...}`) with `{"typescript":...,"found":...}` and an update
+ * request (`{"update":...,"content":...}`) with `{"updated":...}`. The client
+ * knows which it sent, so it validates the reply's shape against the operation
+ * before handing it back — a well-formed JSON object of the wrong operation
+ * shape is a protocol error, not a valid negative result.
+ */
+export type ResidentReplyKind = "transform" | "update";
+
 /** Options for spawning the resident transform host. */
 export interface ResidentTransformProcessOptions {
   args: readonly string[];
@@ -13,6 +26,7 @@ export interface ResidentTransformProcessOptions {
 }
 
 interface PendingRequest {
+  kind: ResidentReplyKind;
   reject: (reason: Error) => void;
   resolve: (reply: Record<string, unknown>) => void;
 }
@@ -78,13 +92,16 @@ export class ResidentTransformProcess {
   }
 
   /**
-   * Send one request to the host and resolve with its parsed JSON reply. The
-   * host answers in FIFO order, so the caller interprets the reply shape by the
-   * payload it sent (a transform reply vs an update reply). Rejects when the
-   * host has already failed or exited, or if writing the request fails.
+   * Send one request to the host and resolve with its validated JSON reply. The
+   * host answers in FIFO order; `kind` tells the client which reply shape the
+   * payload asks for, so the reply is validated as a well-formed `kind` reply
+   * before it resolves. Rejects when the reply is not a valid `kind` reply,
+   * when the host has already failed or exited, or if writing the request
+   * fails.
    */
   public request(
     payload: Record<string, unknown>,
+    kind: ResidentReplyKind,
   ): Promise<Record<string, unknown>> {
     if (this.failure !== undefined) {
       return Promise.reject(this.failure);
@@ -96,7 +113,7 @@ export class ResidentTransformProcess {
       );
     }
     return new Promise<Record<string, unknown>>((resolve, reject) => {
-      const pending: PendingRequest = { reject, resolve };
+      const pending: PendingRequest = { kind, reject, resolve };
       this.pending.push(pending);
       stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
         if (error) {
@@ -149,7 +166,39 @@ export class ResidentTransformProcess {
       }
       return;
     }
-    request.resolve(parseReply(trimmed));
+    const reply = parseReplyObject(trimmed);
+    if (reply === undefined) {
+      // Framing violation: the line is not a JSON object, so it cannot
+      // represent any reply. This request already left the FIFO, so reject it,
+      // then fail the whole process: a bad line may be corruption that shifted
+      // the stream, and the host's real reply that follows must not be paired
+      // with a later request. `fail` marks the failure so that trailing line is
+      // treated as benign instead of unsolicited.
+      const error = new Error(
+        `ttsc: resident transform host sent a malformed reply: ${echoLine(
+          trimmed,
+        )}`,
+      );
+      request.reject(error);
+      this.fail(error);
+      return;
+    }
+    if (!isValidReply(reply, request.kind)) {
+      // Operation-shape violation: a well-formed JSON object that is not a valid
+      // reply for the operation this request sent. FIFO framing is intact — one
+      // line consumed exactly one slot — so only this request is corrupt; later
+      // replies still pair correctly. Reject just this request instead of
+      // failing the whole process.
+      request.reject(
+        new Error(
+          `ttsc: resident transform host sent an invalid ${request.kind} reply: ${echoLine(
+            trimmed,
+          )}`,
+        ),
+      );
+      return;
+    }
+    request.resolve(reply);
   }
 
   private onReaderClose(): void {
@@ -194,23 +243,48 @@ export class ResidentTransformProcess {
 }
 
 /**
- * Parse one reply line into a plain object. A malformed line degrades to an
- * empty object rather than throwing, so one bad line never rejects a request
- * the FIFO has already advanced past; the caller reads missing fields as
- * absent.
+ * Parse one reply line into a plain object, or `undefined` when the line is not
+ * a JSON object. Invalid JSON, arrays, primitives, and `null` all yield
+ * `undefined`: none of them can carry a reply's fields, so the caller treats
+ * them as a framing failure rather than an empty reply. Returning `{}` here
+ * would let a corrupt line masquerade as a valid negative result.
  */
-function parseReply(line: string): Record<string, unknown> {
+function parseReplyObject(line: string): Record<string, unknown> | undefined {
+  let parsed: unknown;
   try {
-    const parsed = JSON.parse(line) as unknown;
-    if (
-      typeof parsed === "object" &&
-      parsed !== null &&
-      !Array.isArray(parsed)
-    ) {
-      return parsed as Record<string, unknown>;
-    }
+    parsed = JSON.parse(line);
   } catch {
-    // A non-object or unparseable line is treated as an empty reply.
+    return undefined;
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed as Record<string, unknown>;
+  }
+  return undefined;
+}
+
+/**
+ * Whether a parsed reply object is a well-formed reply for the given operation.
+ * A transform reply must carry a boolean `found`, and when `found` is `true` a
+ * string `typescript` (a found file always carries its transformed text); when
+ * `found` is `false` the text is irrelevant. An update reply must carry a
+ * boolean `updated`. Every other object shape is a protocol error.
+ */
+function isValidReply(
+  reply: Record<string, unknown>,
+  kind: ResidentReplyKind,
+): boolean {
+  if (kind === "transform") {
+    if (typeof reply.found !== "boolean") {
+      return false;
+    }
+    return reply.found ? typeof reply.typescript === "string" : true;
   }
-  return {};
+  return typeof reply.updated === "boolean";
+}
+
+/** Truncate an offending reply line so error messages stay bounded. */
+function echoLine(line: string): string {
+  return line.length > REPLY_ECHO_LIMIT
+    ? `${line.slice(0, REPLY_ECHO_LIMIT)}…`
+    : line;
 }