ttsc 0.32.1 → 0.33.0

package/src/launcher/internal/runtime/installRuntimeHooks.ts

@@ -32,6 +32,7 @@ import { DependencyBuildGeneration } from "./DependencyBuildGeneration";
 import { OwnedProjectSource } from "./OwnedProjectSource";
 import type { OwningModuleOptions } from "./OwningModuleOptions";
 import { PluginDescriptorInputObservation } from "./PluginDescriptorInputObservation";
+import { PluginDescriptorInputReport } from "./PluginDescriptorInputReport";
 import type { ResolveResult } from "./ResolveResult";
 import { RuntimeEmitProvenance } from "./RuntimeEmitProvenance";
 import { RuntimeEntrySources } from "./RuntimeEntrySources";
@@ -392,7 +393,7 @@ function observePluginDescriptorResolutionCandidates(
     );
     return {
       commit: (selectedURL) => {
-        appendPluginDescriptorInputs(
+        PluginDescriptorInputReport.append(
           observation
             .commit(
               selectedURL === undefined
@@ -431,7 +432,7 @@ function observePluginDescriptorResolutionCandidates(
         DESCRIPTOR_PROBE_EXTENSIONS,
       ),
     );
-    appendPluginDescriptorInputs([
+    PluginDescriptorInputReport.append([
       ...local,
       ...(reached === -1 ? roots : roots.slice(0, reached + 1)).flatMap(
         (root) => root.lines,
@@ -567,7 +568,8 @@ function observePluginDescriptorResolutionCandidates(
  * active for direct-evaluator user preloads after hook installation. The exact
  * generated evaluator entry bypasses these hooks and suspends recording only
  * while its synchronous implementation imports load; descriptor imports then
- * resume it.
+ * resume it. A selected file needs positive content and physical proof even
+ * when an earlier candidate enumeration did not name it.
  */
 function recordPluginDescriptorResolution(
   specifier: string,
@@ -578,11 +580,14 @@ function recordPluginDescriptorResolution(
   const resolved = runtimeFilePath(resolvedURL);
   if (resolved === undefined) return;
   const parent = runtimeFilePath(parentURL);
-  recordPluginDescriptorInput({
-    ...(parent === undefined ? {} : { parent }),
-    resolved,
-    specifier,
-  });
+  recordPluginDescriptorInput(
+    {
+      ...(parent === undefined ? {} : { parent }),
+      resolved,
+      specifier,
+    },
+    true,
+  );
   for (
     let directory = path.dirname(resolved);
     ;
@@ -599,38 +604,47 @@ function recordPluginDescriptorResolution(
   }
 }
 
-function recordPluginDescriptorInput(record: {
-  hash?: string | null;
-  parent?: string;
-  realpath?: string | null;
-  resolved: string;
-  signature?: string;
-  specifier?: string;
-  unstable?: boolean;
-}): void {
-  appendPluginDescriptorInputs(observePluginDescriptorInput(record));
+function recordPluginDescriptorInput(
+  record: {
+    hash?: string | null;
+    parent?: string;
+    realpath?: string | null;
+    resolved: string;
+    signature?: string;
+    specifier?: string;
+    unstable?: boolean;
+  },
+  requirePresent: boolean = false,
+): void {
+  PluginDescriptorInputReport.append(
+    observePluginDescriptorInput(record, requirePresent),
+  );
 }
 
 /**
  * Observe one path and every symbolic link among its lexical ancestors, as the
- * lines `appendPluginDescriptorInputs` reports, without reporting them yet.
+ * lines `PluginDescriptorInputReport.append` reports, without reporting them
+ * yet.
  */
-function observePluginDescriptorInput(record: {
-  hash?: string | null;
-  parent?: string;
-  realpath?: string | null;
-  resolved: string;
-  signature?: string;
-  specifier?: string;
-  unstable?: boolean;
-}): string[] {
+function observePluginDescriptorInput(
+  record: {
+    hash?: string | null;
+    parent?: string;
+    realpath?: string | null;
+    resolved: string;
+    signature?: string;
+    specifier?: string;
+    unstable?: boolean;
+  },
+  requirePresent: boolean = false,
+): string[] {
   if (process.env.TTSC_PLUGIN_DESCRIPTOR_INPUTS_ACTIVE !== "1") return [];
   const lines: string[] = [];
   const observe = (line: string | undefined): void => {
     if (line !== undefined) lines.push(line);
     else PluginDescriptorInputObservation.invalidate();
   };
-  observe(observePluginDescriptorInputOnce(record));
+  observe(observePluginDescriptorInputOnce(record, requirePresent));
   const resolved = path.resolve(record.resolved);
   const parsed = path.parse(resolved);
   let current = parsed.root;
@@ -649,33 +663,19 @@ function observePluginDescriptorInput(record: {
   return lines;
 }
 
-/** Report observed lines to the parent loader, in the order given. */
-function appendPluginDescriptorInputs(lines: readonly string[]): void {
-  if (lines.length === 0) return;
-  if (process.env.TTSC_PLUGIN_DESCRIPTOR_INPUTS_ACTIVE !== "1") return;
-  PluginDescriptorInputObservation.record(lines);
-  const out = process.env.TTSC_PLUGIN_DESCRIPTOR_INPUTS_OUT;
-  if (out === undefined || out.length === 0) {
-    PluginDescriptorInputObservation.invalidate();
-    return;
-  }
-  try {
-    fs.appendFileSync(out, lines.join(""), "utf8");
-  } catch {
-    PluginDescriptorInputObservation.invalidate();
-  }
-}
-
 /** Observe one path without recursively revisiting its lexical ancestors. */
-function observePluginDescriptorInputOnce(record: {
-  hash?: string | null;
-  parent?: string;
-  realpath?: string | null;
-  resolved: string;
-  signature?: string;
-  specifier?: string;
-  unstable?: boolean;
-}): string | undefined {
+function observePluginDescriptorInputOnce(
+  record: {
+    hash?: string | null;
+    parent?: string;
+    realpath?: string | null;
+    resolved: string;
+    signature?: string;
+    specifier?: string;
+    unstable?: boolean;
+  },
+  requirePresent: boolean = false,
+): string | undefined {
   try {
     const beforeSignature = pluginDescriptorInputMetadataSignature(
       record.resolved,
@@ -687,6 +687,8 @@ function observePluginDescriptorInputOnce(record: {
     );
     const unstable =
       record.unstable === true ||
+      (requirePresent &&
+        (observedHash === null || observedRealpath === null)) ||
       beforeSignature === undefined ||
       afterSignature === undefined ||
       beforeSignature !== afterSignature ||

package/src/launcher/internal/ttscserver/runTtscserver.ts

@@ -265,6 +265,11 @@ function lspSidecarEnvironment(options: {
   });
   const node = resolveNodeBinary(env, options.cwd, options.identities);
   SidecarEnvironment.write(env, "TTSC_NODE_BINARY", node);
+  SidecarEnvironment.write(
+    env,
+    "TTSC_NATIVE_PLUGIN_RECORD_ROOT",
+    options.identities?.root,
+  );
   SidecarEnvironment.write(
     env,
     "TTSC_PLUGIN_CONFIG_DIR",

package/src/launcher/internal/watch/WatchTopology.ts

@@ -2740,17 +2740,18 @@ function projectInputDeclarationKey(
  *
  * Modification time and size avoid a read on an ordinary broad scan. A strong
  * event compares the fingerprint, so a timestamp collision cannot hide an edit
- * and a metadata-only notification does not create a build. Device and inode
- * answer whether a POSIX per-file watcher still owns the path.
+ * and a metadata-only notification does not create a build. Exact device and
+ * inode values detect replacement even when Windows file IDs exceed the safe
+ * integer range; they also identify a POSIX per-file watcher's owner.
  */
 function compilerFileSnapshot(
   location: string,
   fingerprint: string,
 ): CompilerFileSnapshot {
   try {
-    const stats = fs.statSync(location);
+    const stats = fs.statSync(location, { bigint: true });
     return {
-      content: `${stats.mtimeMs}:${stats.size}`,
+      content: `${stats.mtimeNs}:${stats.size}`,
       fingerprint,
       owner: `${stats.dev}:${stats.ino}`,
     };

package/src/plugin/internal/CapabilityResolutionFormat.ts

@@ -40,10 +40,11 @@ export namespace CapabilityResolutionFormat {
    * runtime observation envelope, so a partial side channel cannot authorize an
    * answer for reuse, and the shared module recorder's independent completion
    * proof, including its public require.resolve hook capability. Mapped import
-   * candidates retain their pre-resolution witnesses; entries from before that
-   * producer rule must be discovered again even when their later hashes match.
+   * candidates retain their pre-resolution witnesses. A selected file without
+   * positive content and physical proof now withdraws reuse, so entries from
+   * before that producer rule must be discovered again.
    */
-  const FORMAT = "ttsc-capability-resolution-v7";
+  const FORMAT = "ttsc-capability-resolution-v8";
 
   /**
    * The character that joins fields a path could otherwise forge.

package/src/plugin/internal/load/COMMONJS_PLUGIN_DESCRIPTOR_SHIM_SOURCE.ts

@@ -1,3 +1,5 @@
+import path from "node:path";
+
 import {
   PLUGIN_INPUT_OBSERVATION_PATH,
   RESOLUTION_INPUT_RECORDER_PATH,
@@ -24,6 +26,7 @@ export const COMMONJS_PLUGIN_DESCRIPTOR_SHIM_SOURCE = [
   `const path = require("node:path");`,
   `const vm = require("node:vm");`,
   `const { PluginDescriptorInputObservation } = require.cache[${JSON.stringify(PLUGIN_INPUT_OBSERVATION_PATH)}]?.exports ?? require(${JSON.stringify(PLUGIN_INPUT_OBSERVATION_PATH)});`,
+  `const { PluginDescriptorInputReport } = require(${JSON.stringify(path.resolve(path.dirname(PLUGIN_INPUT_OBSERVATION_PATH), "PluginDescriptorInputReport.js"))});`,
   `const { fileURLToPath } = require("node:url");`,
   `const { createResolutionInputRecorder, requireResolveConsultsHooks } = (() => {`,
   `  const file = ${JSON.stringify(RESOLUTION_INPUT_RECORDER_PATH)};`,
@@ -164,6 +167,7 @@ export const COMMONJS_PLUGIN_DESCRIPTOR_SHIM_SOURCE = [
   // that influence.
   `  const serializedDescriptor = JSON.stringify(descriptor);`,
   `  const recorded = recorder.finish();`,
+  `  PluginDescriptorInputReport.finish();`,
   `  const observation = PluginDescriptorInputObservation.snapshot();`,
   `  observation.complete = observation.complete && recorded.complete === true;`,
   `  const payload = { inputHashes: recorded.hashes, inputRealpaths: recorded.realpaths, inputs: recorded.inputs, observation };`,

package/src/plugin/internal/load/PLUGIN_DESCRIPTOR_SHIM_SOURCE.ts

@@ -1,3 +1,5 @@
+import path from "node:path";
+
 import { PLUGIN_INPUT_OBSERVATION_PATH } from "./RESOLUTION_INPUT_RECORDER_PATH";
 
 /**
@@ -22,6 +24,7 @@ export const PLUGIN_DESCRIPTOR_SHIM_SOURCE = [
   // factory could have said.
   `try {`,
   `  const { PluginDescriptorInputObservation } = createRequire(import.meta.url).cache[${JSON.stringify(PLUGIN_INPUT_OBSERVATION_PATH)}].exports;`,
+  `  const { PluginDescriptorInputReport } = createRequire(import.meta.url)(${JSON.stringify(path.resolve(path.dirname(PLUGIN_INPUT_OBSERVATION_PATH), "PluginDescriptorInputReport.js"))});`,
   // Runtime hooks are installed before this shim loads. Arm their internal
   // side channel only for the descriptor import itself, after this shim's own
   // imports have resolved, so ttsc implementation files never become project
@@ -38,6 +41,7 @@ export const PLUGIN_DESCRIPTOR_SHIM_SOURCE = [
   `    throw new Error("ttsc: plugin descriptor declares unsupported JS transform functions; declare a native backend instead");`,
   `  }`,
   `  const serializedDescriptor = JSON.stringify(descriptor);`,
+  `  PluginDescriptorInputReport.finish();`,
   `  const payload = { observation: PluginDescriptorInputObservation.snapshot() };`,
   `  if (serializedDescriptor !== undefined) payload.descriptor = JSON.parse(serializedDescriptor);`,
   `  writeFileSync(process.env.TTSC_PLUGIN_DESCRIPTOR_OUT, JSON.stringify(payload));`,

package/src/plugin/internal/load/PluginDescriptorEvaluationCache.ts

@@ -352,9 +352,9 @@ export namespace PluginDescriptorEvaluationCache {
    * Entry format tag. Moves when the entry shape or its proof rule changes, so
    * an entry written under another rule is evaluated again.
    */
-  // Earlier generations could replace mapped-resolution pre-witnesses with
-  // later candidate state, so their apparently complete proofs are not reusable.
-  const FORMAT = "ttsc-descriptor-evaluation-v7";
+  // Earlier generations could prove a selected file's disappearance as a
+  // missing candidate, so their apparently complete proofs are not reusable.
+  const FORMAT = "ttsc-descriptor-evaluation-v8";
 
   interface IEntry {
     evaluation: IEvaluation;

package/src/plugin/internal/load/descriptorRecordEnvironment.ts

@@ -0,0 +1,24 @@
+import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
+
+/**
+ * Supplies a descriptor child with this load's selected record root. An absent
+ * store removes inherited spellings of the private channel, including Windows
+ * case aliases, so a nested child cannot adopt an earlier load's cache root.
+ *
+ * @evidence contracts/common.md#principled-implementation The selected store is the only authority for the child channel; SidecarEnvironment.write removes inherited aliases when it is absent.
+ * @evidence contracts/common.md#clear-and-simple-design One environment constructor serves direct and ttsx descriptor evaluators and their cache identity.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The helper copies the caller's environment and changes only ttsc's private channel instead of mutating process.env or inventing a cache root.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies ownership of the channel and the nested-process failure prevented by clearing it.
+ * @evidence contracts/portability.md#os-neutral-implementation SidecarEnvironment applies Windows native case-insensitive identity while preserving POSIX variable spelling.
+ * @evidence contracts/performance.md#efficient-algorithms Copying E environment entries and removing matching Windows aliases takes O(E) time and memory; descriptor setup already materializes an environment for each child.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The selected store and effective environment are invocation-specific, so no prior constructed child environment is reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned environment lives only with one descriptor spawn or cache identity and retains no external resource.
+ */
+export function descriptorRecordEnvironment(
+  env: NodeJS.ProcessEnv,
+  recordRoot: string | undefined,
+): NodeJS.ProcessEnv {
+  const child = { ...env };
+  SidecarEnvironment.write(child, "TTSC_PLUGIN_RECORD_ROOT", recordRoot);
+  return child;
+}

package/src/plugin/internal/load/loadProjectPlugins.ts

@@ -35,6 +35,7 @@ import { pluginBuildVersions } from "../source/pluginBuildVersions";
 import { pluginModuleReplaceDirectories } from "../source/pluginModuleReplaceDirectories";
 import { pluginSourceState } from "../source/pluginSourceState";
 import { resolvePluginGoModule } from "../source/resolvePluginGoModule";
+import { selectedRecordIdentityTempParent } from "../source/selectedRecordIdentityTempParent";
 import { COMMONJS_PLUGIN_DESCRIPTOR_SHIM_SOURCE } from "./COMMONJS_PLUGIN_DESCRIPTOR_SHIM_SOURCE";
 import { PLUGIN_DESCRIPTOR_SHIM_SOURCE } from "./PLUGIN_DESCRIPTOR_SHIM_SOURCE";
 import { PluginDescriptorAdmission } from "./PluginDescriptorAdmission";
@@ -44,6 +45,7 @@ import { ProjectPluginEntries } from "./ProjectPluginEntries";
 import { collectProjectHostInputs } from "./collectProjectHostInputs";
 import { composePluginSources } from "./composePluginSources";
 import { declaresHostInputReads } from "./declaresHostInputReads";
+import { descriptorRecordEnvironment } from "./descriptorRecordEnvironment";
 import { hashHostInputPaths } from "./hashHostInputPaths";
 import { moduleResolutionBaseSelects } from "./moduleResolutionBaseSelects";
 import { pluginLabel } from "./pluginLabel";
@@ -1547,9 +1549,11 @@ function loadCommonJsDescriptor(
     cwd: descriptorCache.projectRoot,
     // Everything the child receives besides the per-evaluation output paths.
     env: {
-      ...effectiveEnv,
+      ...descriptorRecordEnvironment(
+        effectiveEnv,
+        descriptorCache.identities?.root,
+      ),
       ...(node === undefined ? {} : { TTSC_NODE_BINARY: node }),
-      ...descriptorRecordRoot(descriptorCache.identities),
       TTSC_TTSX_BINARY: ttsx,
     },
     projectRoot: descriptorCache.projectRoot,
@@ -1579,7 +1583,7 @@ function loadCommonJsDescriptor(
     PluginDescriptorEvaluationCache.locate(cacheAuthority) === cacheFile
   )
     return cached;
-  const dir = createEvaluationTempDir();
+  const dir = createEvaluationTempDir(descriptorCache.identities);
   const out = path.join(dir, "descriptor.json");
   const inputsOut = path.join(dir, "descriptor-inputs.ndjson");
   const diagnostics = path.join(dir, "descriptor.stderr");
@@ -1635,11 +1639,13 @@ function loadCommonJsDescriptor(
         {
           cwd: descriptorCache.projectRoot,
           env: {
-            ...effectiveEnv,
+            ...descriptorRecordEnvironment(
+              effectiveEnv,
+              descriptorCache.identities?.root,
+            ),
             // The direct evaluator may be Bun, but ttsx and native config
             // loaders require a real Node runtime with synchronous hooks.
             ...(node === undefined ? {} : { TTSC_NODE_BINARY: node }),
-            ...descriptorRecordRoot(descriptorCache.identities),
             TTSC_TTSX_BINARY: ttsx,
             TTSC_PLUGIN_CONTEXT: JSON.stringify(context),
             TTSC_PLUGIN_DESCRIPTOR_LOAD: "1",
@@ -2038,7 +2044,7 @@ function loadDescriptorViaTtsx(
   if (node === undefined || ttsx === undefined || ttsx.length === 0) {
     return undefined;
   }
-  const dir = createEvaluationTempDir();
+  const dir = createEvaluationTempDir(descriptorCache.identities);
   const out = path.join(dir, "descriptor.json");
   const inputsOut = path.join(dir, "descriptor-inputs.ndjson");
   const shim = path.join(dir, "load-descriptor.mts");
@@ -2067,12 +2073,14 @@ function loadDescriptorViaTtsx(
       cwd: descriptorCache.projectRoot,
       encoding: "utf8",
       env: {
-        ...effectiveEnv,
+        ...descriptorRecordEnvironment(
+          effectiveEnv,
+          descriptorCache.identities?.root,
+        ),
         // Carry ttsc's own node/ttsx locators explicitly so the child (which
         // may recurse into further descriptor loads) finds them even when the
         // instance-env snapshot predates `withPluginLoaderEnv`.
         TTSC_NODE_BINARY: node,
-        ...descriptorRecordRoot(descriptorCache.identities),
         TTSC_TTSX_BINARY: ttsx,
         TTSC_PLUGIN_CONTEXT: JSON.stringify({
           binary: context.binary,
@@ -2157,20 +2165,6 @@ interface TtsxDescriptorResolutionRecord {
   unstable?: boolean;
 }
 
-/**
- * The private variable that hands a descriptor evaluator the plugin cache root
- * this load's record store selected, so the child proves the compiler it runs
- * from that root's records instead of streaming it (#1726) and never selects a
- * cache root of its own. Absent without a store.
- */
-function descriptorRecordRoot(
-  identities: PluginContentIdentities.Store | undefined,
-): { TTSC_PLUGIN_RECORD_ROOT?: string } {
-  return identities === undefined
-    ? {}
-    : { TTSC_PLUGIN_RECORD_ROOT: identities.root };
-}
-
 /**
  * Expand the ttsx runtime's selected module edges into the same exact and
  * missing resolution inputs used by the direct isolated evaluator.
@@ -2197,22 +2191,38 @@ function readTtsxDescriptorInputs(
   const signatures = new Map<string, string>();
   const unstableInputs = new Set<string>();
   let complete = false;
-  let text = "";
+  let envelopeText: string | undefined;
   if (
     PluginPackageResolution.isRecord(observation) &&
     Array.isArray(observation.lines) &&
     observation.lines.every((line: unknown) => typeof line === "string")
   ) {
     complete = observation.complete === true;
-    text = observation.lines.join("");
+    envelopeText = observation.lines.join("");
   }
+  let reportText: string | undefined;
   try {
-    text += fs.readFileSync(file, "utf8");
+    reportText = fs.readFileSync(file, "utf8");
   } catch {
     // The directly serialized observation copy remains authoritative when
     // no side-channel file was produced. A missing completion copy is never
     // repaired by whichever partial lines happen to remain on disk.
   }
+  if (
+    envelopeText !== undefined &&
+    reportText !== undefined &&
+    envelopeText !== reportText
+  ) {
+    // A partial or contradictory side channel cannot certify completeness.
+    // Keep both records so watch callers still learn every reported input.
+    complete = false;
+  }
+  const text =
+    envelopeText === undefined
+      ? (reportText ?? "")
+      : reportText === undefined || reportText === envelopeText
+        ? envelopeText
+        : `${envelopeText}\n${reportText}`;
   for (const line of text.split(/\r?\n/)) {
     if (line.trim() === "") continue;
     let record: TtsxDescriptorResolutionRecord;
@@ -2516,11 +2526,17 @@ function ttscPackageRoot(): string {
 }
 
 /**
- * Create an evaluator directory whose cleanup path cannot follow a retargeted
- * parent alias.
+ * Create an evaluator directory under the current selected record store when it
+ * has an ordinary identities child. Canonical allocation fixes the physical
+ * cleanup path; an absent or unproved store retains system TEMP.
  */
-function createEvaluationTempDir(): string {
-  return createCanonicalTempDirectory("ttsc-plugin-descriptor-");
+function createEvaluationTempDir(
+  identities: PluginContentIdentities.Store | undefined,
+): string {
+  return createCanonicalTempDirectory(
+    "ttsc-plugin-descriptor-",
+    selectedRecordIdentityTempParent(identities?.root),
+  );
 }
 
 /**

package/src/plugin/internal/source/SourceBuildCacheLayout.ts

@@ -44,6 +44,9 @@ export namespace SourceBuildCacheLayout {
   /** Directory name of ttsc's own Go object cache inside the cache root. */
   export const GO_BUILD_CACHE_DIRNAME = "go-build";
 
+  /** Directory of publisher package bodies and local Go cache writes. */
+  export const PACKAGE_ARTIFACTS_DIRNAME = "package-artifacts";
+
   /** File inside a plugin cache entry recording when it was last used. */
   export const CACHE_LAST_USED_FILE = ".last-used";