ttsc 0.31.4 → 0.32.0

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 
 import { type ProjectInputPathIdentity } from "../../../internal/pathIdentity/ProjectInputPathIdentity";
+import { type ProjectInputPathIdentityContext } from "../../../internal/pathIdentity/ProjectInputPathIdentityContext";
 import { createProjectInputPathIdentityContext } from "../../../internal/pathIdentity/createProjectInputPathIdentityContext";
 import { literalGlobRoot } from "./literalGlobRoot";
 
@@ -12,6 +13,8 @@ import { literalGlobRoot } from "./literalGlobRoot";
  * lane only after the surrounding change detector admits the event; unchanged
  * bytes remain quiet before this classifier is observed.
  *
+ * @param identities The decision's identity transaction; absence creates a
+ *   native one for this classification alone.
  * @evidence contracts/common.md#principled-implementation Exact selection files and immediate resolution-directory entries choose execution reload; a strictly nested declared glob can explain its own ancestor's membership delta without exempting unrelated selection changes.
  * @evidence contracts/common.md#clear-and-simple-design Exact-file membership, immediate-entry membership and causal explanations have distinct helpers under one classification operation.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts A data exemption must explain the same directory's observed delta, not cancel every reload because some unrelated data event occurred.
@@ -22,15 +25,17 @@ import { literalGlobRoot } from "./literalGlobRoot";
  *
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity caches and predicate collections are local to one decision, without a resident historical cache or native handle.
  */
-export function projectInputReloadEventShouldNotify(input: {
-  causedBy?: readonly string[];
-  changed?: string;
-  changedInputs: readonly string[];
-  reloadDirectories?: readonly string[];
-  reloadFiles: readonly string[];
-  globs?: readonly string[];
-}): boolean {
-  const identities = createProjectInputPathIdentityContext();
+export function projectInputReloadEventShouldNotify(
+  input: {
+    causedBy?: readonly string[];
+    changed?: string;
+    changedInputs: readonly string[];
+    reloadDirectories?: readonly string[];
+    reloadFiles: readonly string[];
+    globs?: readonly string[];
+  },
+  identities: ProjectInputPathIdentityContext = createProjectInputPathIdentityContext(),
+): boolean {
   const reloadFiles = new Set(
     input.reloadFiles.map((location) => identities.resolve(location).key),
   );

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

@@ -9,6 +9,7 @@ import { readProjectConfig } from "../../../compiler/internal/project/readProjec
 import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { E2ETrace } from "../../../internal/E2ETrace";
 import { OwnedSynchronousProcess } from "../../../internal/OwnedSynchronousProcess";
+import { TtsxNodeOptions } from "../../../internal/TtsxNodeOptions";
 import { createCanonicalTempDirectory } from "../../../internal/createCanonicalTempDirectory";
 import { javascriptRuntimeCapabilities } from "../../../internal/javascriptRuntimeCapabilities";
 import { resolveNodeBinary } from "../../../internal/resolveNodeBinary";
@@ -445,6 +446,7 @@ export function loadProjectPlugins(options: {
         effectiveEnv,
         watchReplacements,
         packageReaders,
+        sourceIdentities,
       ))
         if (reportsPluginSource(directory)) interests.add(directory);
     }
@@ -534,6 +536,7 @@ export function loadProjectPlugins(options: {
     effectiveEnv,
     watchReplacements,
     packageReaders,
+    sourceIdentities,
   );
   // Admission can now narrow the provisional interests without restamping the
   // retained package/module baselines. Final host errors still keep these roots.
@@ -736,8 +739,10 @@ export function loadProjectPlugins(options: {
       binary,
       // This fallback is compiled from our utility-host, whose actual writer
       // publishes provenance and supports a separate compiler argument cwd.
-      // A separately selected executable host must opt
-      // in itself; a linked library cannot certify that foreign host.
+      // A separately selected executable host must opt in itself; a linked
+      // library cannot certify that foreign host. An undeclared capability
+      // only withholds the optional protocol: build execution still runs such
+      // a host and observes it from outside, never rejecting it.
       capabilities:
         record.stage === "transform" &&
         record.kind === "linked" &&
@@ -1436,9 +1441,13 @@ class CommonJsDescriptorLoadError extends Error {
 function loadCommonJsDescriptor(
   request: string,
   context: ITtscPluginFactoryContext,
-  effectiveEnv: NodeJS.ProcessEnv,
+  loadEnv: NodeJS.ProcessEnv,
   descriptorCache: DescriptorCacheOptions,
 ): IsolatedPluginDescriptor {
+  // The evaluator is ttsc's own helper: inside a ttsx run it gets the user's
+  // NODE_OPTIONS, not ttsx's preloads, which would refuse the descriptor cache
+  // and run in every evaluation (#1740). The runtime probe below does the same.
+  const effectiveEnv = TtsxNodeOptions.forHelpers(loadEnv);
   const runtime = pluginDescriptorRuntimeBinary(effectiveEnv);
   const ttsx = effectiveEnv.TTSC_TTSX_BINARY ?? process.env.TTSC_TTSX_BINARY;
   const runtimeCapabilities = javascriptRuntimeCapabilities(
@@ -2347,6 +2356,7 @@ function pluginBuildDirectories(
   env: NodeJS.ProcessEnv,
   replacements?: Map<string, readonly string[]>,
   readers?: Map<string, SourcePluginWorkspace.GoModReader>,
+  identities?: PluginContentIdentities.Store,
 ): string[] {
   const directories = new Set<string>();
   for (const record of records) {
@@ -2361,6 +2371,7 @@ function pluginBuildDirectories(
         env,
         replacements,
         readers,
+        identities,
       ))
         directories.add(directory);
     }
@@ -2380,17 +2391,20 @@ function pluginReplacementWatchDirectories(
   env: NodeJS.ProcessEnv,
   observed?: Map<string, readonly string[]>,
   readers?: Map<string, SourcePluginWorkspace.GoModReader>,
+  identities?: PluginContentIdentities.Store,
 ): readonly string[] {
   const previous = observed?.get(moduleRoot);
   if (previous !== undefined) return previous;
   let directories: readonly string[];
   try {
+    // The load's store goes with the reader this registers first (#1739).
     directories = pluginModuleReplaceDirectories(
       moduleRoot,
       env,
       undefined,
       undefined,
       readers,
+      identities,
     ).map((replacement) => replacement.directory);
   } catch {
     // An unreadable manifest/tool is not valid metadata. The already observed

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

@@ -30,13 +30,19 @@ export function resolveNativeSource(
   plugin: ITtscPlugin,
   config: ITtscProjectPluginConfig,
   index: number,
-  options?: { env?: NodeJS.ProcessEnv; observation?: NativeSourcePackages.Package },
+  options?: {
+    env?: NodeJS.ProcessEnv;
+    observation?: NativeSourcePackages.Package;
+  },
 ): { kind: "executable" | "linked"; moduleRoot: string } {
   const label = pluginLabel(plugin, config, index);
   requirePluginSource(source, label);
   const { moduleRoot } = resolvePluginGoModule(source, label);
-  const observation = options?.observation ?? NativeSourcePackages.propose([
-    { source, label, ownModule: plugin.stage === "check" },
-  ], SidecarEnvironment.merge(options?.env ?? process.env))[0]!.observation;
+  const observation =
+    options?.observation ??
+    NativeSourcePackages.propose(
+      [{ source, label, ownModule: plugin.stage === "check" }],
+      SidecarEnvironment.merge(options?.env ?? process.env),
+    )[0]!.observation;
   return { kind: NativeSourcePackages.kind(observation, label), moduleRoot };
 }

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import { resolvePhysicalPath } from "../../../internal/pathIdentity/resolvePhysicalPath";
 import { GoToolResolution } from "./GoToolResolution";
 import type { IPluginModuleReplaceDirectory } from "./IPluginModuleReplaceDirectory";
+import type { PluginContentIdentities } from "./PluginContentIdentities";
 import { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { resolveGoCompiler } from "./resolveGoCompiler";
 import { selectPluginModuleReplaceDirectories } from "./selectPluginModuleReplaceDirectories";
@@ -30,6 +31,8 @@ import { selectPluginModuleReplaceDirectories } from "./selectPluginModuleReplac
  * @param env The build's effective environment.
  * @param goBinary The Go tool the build runs, or `undefined` to resolve it as
  *   the build does.
+ * @param identities The load's record store, carried by a reader this call
+ *   registers so the load's later reads reuse recorded syntax.
  * @returns Each replacement outside the module, sorted by module path: the
  *   replaced module path and version, the target as `go.mod` spells it, and the
  *   target's absolute path.
@@ -52,6 +55,7 @@ export function pluginModuleReplaceDirectories(
   goBinary?: string,
   reader?: SourcePluginWorkspace.GoModReader,
   readers?: Map<string, SourcePluginWorkspace.GoModReader>,
+  identities?: PluginContentIdentities.Store,
 ): IPluginModuleReplaceDirectory[] {
   const root = path.resolve(moduleRoot);
   let text: string;
@@ -72,7 +76,12 @@ export function pluginModuleReplaceDirectories(
       root,
     );
   const parsed = (
-    reader ?? SourcePluginWorkspace.createGoModReader(go, root, env, readers)
+    reader ??
+    // WARNING (#1739): the first reader registered for a Go binary serves the
+    // whole load, so it must carry the load's record store, or every later
+    // reader request of the load gets a store-less one and the go.mod syntax
+    // records are never read or written.
+    SourcePluginWorkspace.createGoModReader(go, root, env, readers, identities)
   ).read(root);
   // Parsed syntax may be shared; physical containment is current native state
   // and must be recomputed even when these manifest bytes are unchanged.

package/src/structures/internal/TtscCommonOptions.ts

@@ -86,8 +86,8 @@ export interface TtscCommonOptions {
   }[];
 
   /**
-   * Retained native compiler argument base when project selection redirects
-   * the Program to a different root. Absent retains the selected project root.
+   * Retained native compiler argument base when project selection redirects the
+   * Program to a different root. Absent retains the selected project root.
    * Response frames and relative native options use this base; plugin/rule
    * context and config-relative paths retain their separate project authority.
    */

package/internal/graphsymbols/position_helpers_follow_ecma_line_terminators_test.go

@@ -1,78 +0,0 @@
-package graphsymbols
-
-import (
-  "testing"
-  "unicode/utf8"
-
-  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
-  "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
-)
-
-// TestPositionHelpersFollowECMALineTerminators verifies graph-backed LSP
-// positions use the compiler's LF, CRLF, CR, LS, and PS line boundaries.
-//
-// An offset-to-position helper that counted only LF while its inverse counted
-// CR too would map an editor cursor to a graph offset that returns on a
-// different line. Literal starts and ends establish three authored logical
-// lines; the test walks their UTF-8 boundaries, including an emoji, and requires
-// a round trip. Columns are not compared to literal UTF-16 counts, so symmetric
-// column mistakes can pass. No editor/server request is exercised.
-//
-// 1. Build three lines with each ECMAScript terminator.
-// 2. Enumerate every valid cursor boundary before each terminator.
-// 3. Convert each offset to UTF-16 LSP position and back to the same offset.
-//
-// @evidence contracts/testing.md#behavioral-verification Verifies graph-backed LSP positions use the compiler's LF, CRLF, CR, LS, and PS line boundaries.
-// @evidence contracts/testing.md#independent-expectations Each case embeds one ECMAScript terminator (LF, CRLF, CR, LS or PS) in a three-line literal, so the expected line count (three) and the line of every offset follow from the language's line-terminator definition. Columns are checked only by an offset -> position -> offset round trip over every UTF-8 rune boundary (including the two-unit emoji), not against literal UTF-16 column numbers, so a column error made symmetrically by both helpers would not be detected.
-// @evidence contracts/testing.md#distinguishing-cases Build three lines with each ECMAScript terminator; Enumerate every valid cursor boundary before each terminator; Convert each offset to UTF-16 LSP position and back to the same offset; the five terminator subtests differ only in the terminator, and a position on the line index just past the last line must not resolve (negative case). No empty-text or out-of-range-column input is exercised here.
-// @evidence contracts/testing.md#execution-ownership Directly calls the maintained line and position helpers on authored UTF-8 strings in this process. Literal byte boundaries establish enumeration; round-trip column expectations share the two converters and are not a separate UTF-16 oracle. It creates no native fixture, loads no Program, installs no consumer, and starts no product process or editor/server connection.
-func TestPositionHelpersFollowECMALineTerminators(t *testing.T) {
-  cases := []struct {
-    name       string
-    terminator string
-  }{
-    {name: "LF", terminator: "\n"},
-    {name: "CRLF", terminator: "\r\n"},
-    {name: "CR", terminator: "\r"},
-    {name: "LS", terminator: "\u2028"},
-    {name: "PS", terminator: "\u2029"},
-  }
-  for _, tc := range cases {
-    t.Run(tc.name, func(t *testing.T) {
-      text := "alpha😀" + tc.terminator + "beta" + tc.terminator + "gamma"
-      starts := graph.ECMALineStarts(text)
-      if len(starts) != 3 {
-        t.Fatalf("line starts = %v, want three lines", starts)
-      }
-      expectedStarts := []int{0, 9 + len(tc.terminator), 13 + 2*len(tc.terminator)}
-      expectedEnds := []int{9, 13 + len(tc.terminator), len(text)}
-      for line, start := range starts {
-        end := graph.LineEnd(text, starts, line)
-        if start != expectedStarts[line] || end != expectedEnds[line] {
-          t.Fatalf("line %d boundaries = (%d, %d), want (%d, %d)", line, start, end, expectedStarts[line], expectedEnds[line])
-        }
-        for offset := start; ; {
-          position := offsetToPosition(text, offset)
-          if position.Line != line {
-            t.Fatalf("offset %d position line = %d, want %d", offset, position.Line, line)
-          }
-          restored, ok := lspPositionToOffset(text, position)
-          if !ok || restored != offset {
-            t.Fatalf("offset %d -> %+v -> (%d, %t), want itself", offset, position, restored, ok)
-          }
-          if offset == end {
-            break
-          }
-          _, size := utf8.DecodeRuneInString(text[offset:])
-          if size == 0 {
-            t.Fatal("unexpected zero-width UTF-8 rune")
-          }
-          offset += size
-        }
-      }
-      if _, ok := lspPositionToOffset(text, lspserver.LSPPosition{Line: len(starts), Character: 0}); ok {
-        t.Fatal("position on a nonexistent source line must not resolve")
-      }
-    })
-  }
-}