@ttsc/unplugin 0.31.4 → 0.32.0

package/src/core/transform/generation/captureTransformGeneration.ts

@@ -12,6 +12,7 @@ import { TRANSFORM_RESULT_MEMBERSHIP } from "../cache/TRANSFORM_RESULT_MEMBERSHI
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
 import { refreshFilesystemClockReference } from "../clock/refreshFilesystemClockReference";
 import { reportDivergentDelivery } from "../diagnostics/reportDivergentDelivery";
+import { generationCaseSensitivity } from "../envelope/generationCaseSensitivity";
 import { selectDeclaredProjectInputKeys } from "../envelope/selectDeclaredProjectInputKeys";
 import { selectExternalInputPaths } from "../envelope/selectExternalInputPaths";
 import { selectNotifiableAbsentInputs } from "../envelope/selectNotifiableAbsentInputs";
@@ -457,6 +458,13 @@ export async function captureTransformGeneration(props: {
       clockReferenceDirectory ?? scratchDirectory,
       props.filesystem,
     );
+    // Every context capturing this generation below shares the generation's
+    // directory case answers, rather than each asking again (samchon/ttsc#1742).
+    const generationCase = generationCaseSensitivity({
+      filesystem: props.filesystem,
+      projectRoot,
+      result,
+    });
     const persistentHostInputs = selectPersistentHostInputs({
       filesystem: props.filesystem,
       projectRoot,
@@ -518,6 +526,7 @@ export async function captureTransformGeneration(props: {
               projectRoot,
               result,
             }),
+            generationCase,
           )
         : undefined;
     compileTrace?.("bridge-tracker-lifecycle", {
@@ -566,6 +575,7 @@ export async function captureTransformGeneration(props: {
                 .filter((input) => !absentCandidates.has(input))
                 .map((input) => [path.resolve(input), "presence" as const]),
             ),
+            generationCase,
           )
         : undefined;
     compileTrace?.("bridge-tracker-lifecycle", {

package/src/core/transform/generation/selectPersistentHostInputs.ts

@@ -1,5 +1,6 @@
 import type { ITtscCompilerTransformation } from "ttsc";
 
+import { generationCaseSensitivity } from "../envelope/generationCaseSensitivity";
 import { selectListedFiles } from "../envelope/selectListedFiles";
 import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
 import { createHostPathIdentityContext } from "../filesystem/createHostPathIdentityContext";
@@ -43,7 +44,10 @@ export function selectPersistentHostInputs(props: {
     props.temporaryTsconfig === undefined
   )
     return inputs;
-  const identities = createHostPathIdentityContext(props.filesystem);
+  const identities = createHostPathIdentityContext(
+    props.filesystem,
+    generationCaseSensitivity(props),
+  );
   const temporary =
     props.temporaryTsconfig === undefined
       ? undefined

package/src/core/transform/inputs/nativeInputPredicateState.ts

@@ -69,9 +69,7 @@ export function nativeInputPredicateState(
     } else if (kind === "optional-file") {
       try {
         digest = filesystem.stat(file).isFile()
-          ? hash(
-              Buffer.concat([Buffer.from("file\0"), readBytes()]),
-            )
+          ? hash(Buffer.concat([Buffer.from("file\0"), readBytes()]))
           : hash("missing\0");
       } catch (error) {
         if (!missing(error)) return undefined;

package/src/core/transform/tracker/broker/watchBrokerSource.ts

@@ -119,6 +119,8 @@ const registrations = new Map();
 const DROPPED = 0x1 | 0x2 | 0x4 | 0x8 | 0x20 | 0x40 | 0x80;
 const MODIFIED = 0x400 | 0x1000 | 0x2000 | 0x4000 | 0x8000;
 const RENAMED = 0x100 | 0x200 | 0x800;
+const CREATED = 0x100;
+const MOVED = 0x200 | 0x800;
 const fsevents = load();
 let probeSequence = 0;
 
@@ -203,6 +205,8 @@ function stream(location, deliver, registration) {
   const root = probe === undefined ? directory : probe.root;
   const within = (parent, file) => file === parent || file.startsWith(parent.endsWith("/") ? parent : parent + "/");
   const opened = { close: undefined, location: location.directory, pending: new Map(), probe, proven: probe === undefined };
+  // Anything born before this instant was not created in this stream.
+  const openedAt = Date.now();
   const stop = fsevents.watch(root, (file, flags) => {
     // Loss authority is independent of the path, including our own probe.
     if ((flags & DROPPED) !== 0) {
@@ -232,6 +236,16 @@ function stream(location, deliver, registration) {
     }
     const filename = file.slice(directory.length + 1);
     if (location.recursive !== true && filename.includes("/")) return;
+    // FSEvents keeps ItemCreated on later writes to a path it saw created, so a
+    // plain edit of a file older than this stream arrived as a rename, a
+    // membership change that replaced generations for an unrelated write. An
+    // object born before the stream opened was not created in it; its other
+    // flags decide. A removal or a rename keeps the event structural.
+    if ((flags & CREATED) !== 0 && (flags & MOVED) === 0 && (flags & MODIFIED) !== 0) {
+      try {
+        if (fs.lstatSync(file).birthtimeMs < openedAt) flags &= ~CREATED;
+      } catch {}
+    }
     deliver((flags & MODIFIED) !== 0 && (flags & RENAMED) === 0 ? "change" : "rename", filename);
   });
   opened.close = () => {

package/src/core/transform/tracker/createHostInputMutationTracker.ts

@@ -114,12 +114,21 @@ export async function createHostInputMutationTracker(
    * filesystem.
    */
   scopes?: ReadonlyMap<string, TtscTrackedInputScope>,
+  /**
+   * The case answers of the generation this tracker watches, for its baseline
+   * (`generationCaseSensitivity`); omitted, the baseline observes for itself.
+   * An event's re-check always observes afresh.
+   */
+  caseSensitive?: TtscTransformFilesystemOperations["caseSensitive"],
 ): Promise<TtscProjectMutationTracker> {
   const paths =
     (filesystem.platform ?? process.platform) === "win32"
       ? path.win32
       : path.posix;
-  const identities = createHostPathIdentityContext(filesystem);
+  const identities = createHostPathIdentityContext(
+    filesystem,
+    caseSensitive ?? filesystem.caseSensitive,
+  );
   // The project root in both of its spellings: an input the compiler reported
   // physically is the project's as much as one spelled as the project was
   // named, and the root's observer is opened once, under the name.
@@ -399,6 +408,17 @@ export async function createHostInputMutationTracker(
    * an event the backend could not attribute to a name may concern any input
    * below the watched directory, so it always counts.
    */
+  // Whether a path names an existing object that no other name can reach:
+  // not a link, and not a file with a second hard link, whose writes could
+  // land on a tracked input without an event on its name.
+  const distinctExistingObject = (location: string): boolean => {
+    try {
+      const stats = filesystem.lstat(location);
+      return !stats.isSymbolicLink() && !(stats.isFile() && stats.nlink > 1n);
+    } catch {
+      return false;
+    }
+  };
   const classify = (
     directory: string,
     filename: string | null,
@@ -477,6 +497,13 @@ export async function createHostInputMutationTracker(
         return "mutation";
       }
     }
+    // An object that exists now resolves to its own identity under every alias,
+    // so one that is neither a link nor a second name of a file, and resolves
+    // to nothing tracked above, is a different object. A recursive backend
+    // (macOS, Windows) hears every write below the project root, and
+    // withdrawing authority for each sent every later delivery past its
+    // notifications.
+    if (distinctExistingObject(changed)) return undefined;
     // A missing native alias cannot be recovered by current realpath. Neither
     // ASCII spelling nor OS name proves this event unrelated to a tracked path.
     // Keep exact metadata validation without inventing a membership mutation.

package/src/core/transform/tracker/createProjectMutationTracker.ts

@@ -36,11 +36,14 @@ import { watchLocationIdentity } from "./watchLocationIdentity";
  * recorded-state validation supplies the actual verdict. Content witnesses
  * preserve captured native input aliases, then reject only an observed normal
  * directory excluded in both lexical and native spellings. Unknown, missing and
- * linked ancestry remains conservative. Membership rejection still withdraws
- * notification authority even when content is outside the walk. Named events
- * also compare current native identity and case policy with the retained
- * identity transaction. Retargeting withdraws notification authority without
- * changing the meaning of earlier recorded event spellings.
+ * linked ancestry remains conservative. Membership rejection withdraws
+ * notification authority except below such a proven excluded directory, so a
+ * recursive backend's writes to a cache or output tree cost no proof, nor does
+ * an edit to an existing unlinked file whose every name the program cannot
+ * admit (samchon/ttsc#1737). Named events also compare current native identity
+ * and case policy with the retained identity transaction. Retargeting withdraws
+ * notification authority without changing the meaning of earlier recorded event
+ * spellings.
  *
  * @evidence contracts/common.md#principled-implementation
  *   The project walk and membership policy own structural relevance; content
@@ -48,8 +51,8 @@ import { watchLocationIdentity } from "./watchLocationIdentity";
  *   A lexical nonmatch is uncertainty rather than native alias exclusion.
  *   Changed native identity premises also withdraw notification proof while
  *   membership and content witnesses keep their independent classifications.
- *   Content exclusion requires normal directory identity and both policy
- *   spellings; captured native input aliases remain content witnesses.
+ *   Content and membership exclusion require normal directory identity and both
+ *   policy spellings; captured native input aliases remain content witnesses.
  * @evidence contracts/common.md#clear-and-simple-design
  *   One root, directory index and filter set define the tracker; broker and local
  *   paths share those decisions rather than duplicating backend-specific policies.
@@ -145,6 +148,73 @@ export async function createProjectMutationTracker(
       .filter((directory) => directory.relevant)
       .map((directory) => paths.resolve(directory.path)),
   );
+  // Whether an event path lies below a directory the walk excludes, proven by
+  // an observed normal directory excluded in both its lexical and its native
+  // spelling. A missing ancestor, one outside the root, or a link before that
+  // directory proves nothing. Content stops at the excluded directory, since a
+  // captured input reached through a deeper link is already caught by its
+  // identity above. Membership has no identity to catch a new file created
+  // through such a link (`node_modules/linked -> src`), so for it the whole
+  // path must be links-free.
+  const excludedFromWalk = (changed: string, wholePath: boolean): boolean => {
+    const relative = paths.relative(root, paths.dirname(changed));
+    if (
+      relative === ".." ||
+      relative.startsWith(".." + paths.sep) ||
+      paths.isAbsolute(relative)
+    )
+      return false;
+    let directory = root;
+    let excluded = false;
+    for (const component of relative.split(paths.sep).filter(Boolean)) {
+      directory = paths.join(directory, component);
+      try {
+        const before = filesystem.lstat(directory);
+        if (!before.isDirectory() || before.isSymbolicLink()) return false;
+        const physical = filesystem.realpath(directory);
+        const after = filesystem.lstat(directory);
+        if (
+          !after.isDirectory() ||
+          after.isSymbolicLink() ||
+          before.dev !== after.dev ||
+          before.ino !== after.ino
+        )
+          return false;
+        if (
+          !excluded &&
+          !isProjectWalkDirectory(directory, policy, filesystem.platform) &&
+          !isProjectWalkDirectory(physical, policy, filesystem.platform)
+        ) {
+          if (!wholePath) return true;
+          excluded = true;
+        }
+      } catch {
+        // Missing/deleted ancestors and unknown native spellings remain events.
+        return false;
+      }
+    }
+    return excluded;
+  };
+  // Whether an event names an existing file no spelling can make a program
+  // member: a regular file with no second hard link, whose own and physical
+  // names are both names the program cannot admit. A directory alias can move
+  // a file into the program but cannot rename it, and a removed name, a link
+  // or a directory stays conservative.
+  const existingNonProgramFile = (changed: string): boolean => {
+    try {
+      const stats = filesystem.lstat(changed);
+      if (!stats.isFile() || stats.nlink > 1n) return false;
+      return (
+        !isPossibleProgramFileName(paths.basename(changed), policy) &&
+        !isPossibleProgramFileName(
+          paths.basename(filesystem.realpath(changed)),
+          policy,
+        )
+      );
+    } catch {
+      return false;
+    }
+  };
   const reportsMembership = (location: string, filename: string): boolean => {
     const changed = paths.join(location, filename);
     const current = createHostPathIdentityContext(filesystem);
@@ -169,8 +239,19 @@ export async function createProjectMutationTracker(
         filesystem,
       );
     // Current realpath cannot identify a deleted alias. Policy checks only
-    // lexical spellings, so rejection cannot establish unchanged program state.
-    if (!membership) tracker.unverified = true;
+    // lexical spellings, so rejection cannot establish unchanged program state,
+    // except below a directory the walk provably excludes. A recursive backend
+    // (macOS, Windows) hears every write under the root, a cache or an output
+    // directory among them, and withdrawing authority for each sent every later
+    // delivery to the whole-snapshot proof. An existing file whose every name
+    // the program cannot admit is no member either, a stylesheet or an asset
+    // edited in a source directory among them, on every backend.
+    if (
+      !membership &&
+      !excludedFromWalk(changed, true) &&
+      !existingNonProgramFile(changed)
+    )
+      tracker.unverified = true;
     return membership;
   };
   // Content belongs to the walk too. A recursive native backend can report
@@ -201,39 +282,7 @@ export async function createProjectMutationTracker(
       tracker.unverified = true;
       return true;
     }
-    const relative = paths.relative(root, paths.dirname(changed));
-    if (
-      relative === ".." ||
-      relative.startsWith(".." + paths.sep) ||
-      paths.isAbsolute(relative)
-    )
-      return true;
-    let directory = root;
-    for (const component of relative.split(paths.sep).filter(Boolean)) {
-      directory = paths.join(directory, component);
-      try {
-        const before = filesystem.lstat(directory);
-        if (!before.isDirectory() || before.isSymbolicLink()) return true;
-        const physical = filesystem.realpath(directory);
-        const after = filesystem.lstat(directory);
-        if (
-          !after.isDirectory() ||
-          after.isSymbolicLink() ||
-          before.dev !== after.dev ||
-          before.ino !== after.ino
-        )
-          return true;
-        if (
-          !isProjectWalkDirectory(directory, policy, filesystem.platform) &&
-          !isProjectWalkDirectory(physical, policy, filesystem.platform)
-        )
-          return false;
-      } catch {
-        // Missing/deleted ancestors and unknown native spellings remain events.
-        return true;
-      }
-    }
-    return true;
+    return !excludedFromWalk(changed, false);
   };
   const reportsNewMembership = (
     location: string,

package/src/core/transform/transformTtsc.ts

@@ -33,6 +33,7 @@ import type { TtscTransformHooks } from "./watch/TtscTransformHooks";
 import type { TtscWatchSelection } from "./watch/TtscWatchSelection";
 import { notifyRejectedGenerationInputs } from "./watch/notifyRejectedGenerationInputs";
 import { prepareProjectRecordDirectories } from "./watch/prepareProjectRecordDirectories";
+import { recordedDependencyWitnesses } from "./watch/recordedDependencyWitnesses";
 
 /**
  * Apply the ttsc plugin transform to a single source file.
@@ -282,10 +283,13 @@ export async function transformTtsc(
           cache === undefined
             ? undefined
             : TRANSFORM_CACHE_CASE_POLICIES.get(cache)?.get(key),
+        // A cache without a list of its own takes the names the project's
+        // record carries from an earlier process (samchon/ttsc#1743).
         witnessedDependencies:
           cache === undefined
             ? undefined
-            : TRANSFORM_CACHE_DEPENDENCY_WITNESSES.get(cache)?.get(key),
+            : (TRANSFORM_CACHE_DEPENDENCY_WITNESSES.get(cache)?.get(key) ??
+              recordedDependencyWitnesses(hooks?.project, tsconfig)),
       });
       cache?.set(key, transformed);
     }

package/src/core/transform/watch/TtscWatchInputBaseline.ts

@@ -23,7 +23,8 @@ import type { TtscWatchInputFileBaseline } from "./TtscWatchInputFileBaseline";
 export interface TtscWatchInputBaseline extends TtscWatchInputFileBaseline {
   /**
    * Current version-one native codec facts, captured only for requested kinds.
-   * These observations do not certify a producer's identityStable flag or scope.
+   * These observations do not certify a producer's identityStable flag or
+   * scope.
    */
   nativePredicates?: Partial<
     Record<

package/src/core/transform/watch/isWatchInputKeyBaseline.ts

@@ -115,9 +115,11 @@ function isNativePredicateBaselines(value: unknown): boolean {
       stableStringify(Object.keys(state).sort()) !==
         stableStringify(["digest", "realpath"]) ||
       !isContentHash(state.digest) ||
-      !(state.realpath === null ||
+      !(
+        state.realpath === null ||
         (typeof state.realpath === "string" &&
-          isAbsoluteFilesystemPath(state.realpath)))
+          isAbsoluteFilesystemPath(state.realpath))
+      )
     ) {
       return false;
     }

package/src/core/transform/watch/notifyProjectRecord.ts

@@ -73,10 +73,9 @@ const HANDED = new WeakMap<
  * loses acceptance and enters persistence again without rereading generation
  * inputs. Hosts and bridge readers own current byte proof, including concurrent
  * changes and unreadable/torn bytes; availability here cannot exclude removal
- * after the check. A host that keeps no
- * snapshot of the file, Rollup's cache, is handed the digest of the bytes
- * written for the generation to compare against instead
- * (`TtscProjectRegistration.digest`).
+ * after the check. A host that keeps no snapshot of the file, Rollup's cache,
+ * is handed the digest of the bytes written for the generation to compare
+ * against instead (`TtscProjectRegistration.digest`).
  *
  * A record lives below the host's tool directory, or, when that cannot be
  * written, below the fallback the host accepts (`fallbackToolDirectory`,
@@ -226,7 +225,9 @@ function recordOf(
   cached: TtscCachedProjectTransform,
   inputs: readonly TtscWatchInput[],
 ): TtscProjectRecord {
+  const dependencies = cached.externalDependencyInputs ?? [];
   const record: TtscProjectRecord = {
+    ...(dependencies.length === 0 ? {} : { dependencies }),
     inputs: {},
     membership:
       cached.projectDirectories === undefined

package/src/core/transform/watch/recordedDependencyWitnesses.ts

@@ -0,0 +1,50 @@
+import { projectRecordFile } from "../../bridge/projectRecordFile";
+import { readProjectRecordFile } from "../../bridge/readProjectRecordFile";
+import type { TtscTransformHooks } from "./TtscTransformHooks";
+
+/**
+ * The dependency-only paths the project record of `tsconfig` carries
+ * (`TtscProjectRecord.dependencies`), for a transform cache that has no witness
+ * list of its own yet.
+ *
+ * A compile learns a plugin-reported dependency path only from its own
+ * envelope, and one it had no witness for compiles again
+ * (`onlyLearnedCompileFacts`). A transform cache keeps the paths in memory
+ * (`TRANSFORM_CACHE_DEPENDENCY_WITNESSES`), so every new cache, a dev-server
+ * start or a build process, compiled such a project twice (samchon/ttsc#1743).
+ * The record the previous process wrote names them. They only say what to read:
+ * the capture still witnesses each path afresh, a path the compile no longer
+ * reports costs one read, and one the record does not name is retried as
+ * before.
+ *
+ * @param project The host's record directories, when it keeps records.
+ * @param tsconfig The project's tsconfig, as the adapter names it.
+ * @returns The record's paths, or `undefined` when no readable record names
+ *   any.
+ * @evidence contracts/common.md#principled-implementation The record is the host's persisted project state, written from a completed generation; its paths are hints that the capture re-witnesses, never certified state.
+ * @evidence contracts/common.md#clear-and-simple-design One reader selects the first readable record of the host's directories, in the order the writer tries them.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No witness or digest is taken from the record; an unreadable or absent record supplies nothing.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the doubled first compile, the hint semantics and the absent cases.
+ * @evidence contracts/portability.md#os-neutral-implementation Record paths come from the host's own directories through `projectRecordFile`.
+ * @evidence contracts/performance.md#efficient-algorithms At most two record reads and JSON parses, only when a cache has no witness list for the key.
+ * @evidence contracts/performance.md#reuse-equivalent-work A new process reuses the dependency names the last generation's record holds instead of compiling once to learn them.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned list belongs to the caller; nothing is retained here.
+ */
+export function recordedDependencyWitnesses(
+  project: TtscTransformHooks["project"],
+  tsconfig: string,
+): readonly string[] | undefined {
+  if (project === undefined) return undefined;
+  for (const directory of [
+    project.toolDirectory,
+    ...(project.fallbackToolDirectory === undefined
+      ? []
+      : [project.fallbackToolDirectory]),
+  ]) {
+    const record = readProjectRecordFile(
+      projectRecordFile(directory, tsconfig),
+    );
+    if (record !== undefined) return record.dependencies;
+  }
+  return undefined;
+}

package/src/core/transform/watch/watchInputEvidenceMatchesBaseline.ts

@@ -10,8 +10,7 @@ import { isWatchInputKeyBaseline } from "./isWatchInputKeyBaseline";
  *
  * A codec matches only the facts the baseline actually captured. Native,
  * listing and plugin-tree observations require their optional payloads;
- * membership is a
- * separate project walk and cannot match one path's baseline.
+ * membership is a separate project walk and cannot match one path's baseline.
  *
  * @evidence contracts/common.md#principled-implementation Identity and every recorded codec fact must agree with a validated baseline; native predicates additionally require a supported version, stable producer identity, matching raw digest and physical target. Narrow discovery facts and absent optional native/listing/tree payloads cannot establish broader observations.
  * @evidence contracts/common.md#clear-and-simple-design Codec branches reuse the strict baseline guard and native realpath comparator, with one private refinement exposing the broader carrier.

package/src/core/tsconfig/TsconfigReadTransaction.ts

@@ -7,14 +7,16 @@ import { resolveExtendsConfig } from "./resolveExtendsConfig";
 import { resolveRealPath } from "./resolveRealPath";
 
 /**
- * Share config observations and contextual selections within one synchronous read.
+ * Share config observations and contextual selections within one synchronous
+ * read.
  *
  * Lexical paths own parsing and relative extends resolution. Physical paths
  * only guard ancestry cycles. A completed selection can be borrowed when the
  * current ancestors intersect its encountered physical identities exactly as
  * they did originally; otherwise a different cycle cut requires evaluation.
  * Ordered source observations travel with a completed selection, including
- * unresolved file candidates, so reuse preserves the caller's invalidation inputs.
+ * unresolved file candidates, so reuse preserves the caller's invalidation
+ * inputs.
  *
  * Create a new transaction for each independent freshness observation. This
  * owner neither validates reuse across reads nor supplies compiler diagnostics.
@@ -94,12 +96,13 @@ export class TsconfigReadTransaction {
   /**
    * Select one declaration, preserving its lexical directory and observations.
    *
-   * An undefined own selection inherits. Null masks inheritance without supplying
-   * a value, as an invalid own file list does; a parent ignores that empty result.
-   * First queries search later bases first; last queries visit all bases forward.
-   * The caller's physical ancestor set is copied once and never mutated.
-   * Selectors must preserve the parsed inputs and give the same declaration for
-   * the same source; query reuse does not repeat their incidental effects.
+   * An undefined own selection inherits. Null masks inheritance without
+   * supplying a value, as an invalid own file list does; a parent ignores that
+   * empty result. First queries search later bases first; last queries visit
+   * all bases forward. The caller's physical ancestor set is copied once and
+   * never mutated. Selectors must preserve the parsed inputs and give the same
+   * declaration for the same source; query reuse does not repeat their
+   * incidental effects.
    *
    * @evidence contracts/common.md#principled-implementation A completed answer is reusable only when its encountered physical identities have the same intersection with current ancestry. That preserves every observed cycle decision, including cuts; own declarations and first/last traversal retain lexical origins and key-specific precedence.
    * @evidence contracts/common.md#clear-and-simple-design A query-local visitor owns selection and contextual completed answers; transaction nodes separately share lexical source, identity and edge observations across keys.

package/src/core/tsconfig/findDeclaredCompilerOption.ts

@@ -6,8 +6,9 @@ import { findDeclaredValue } from "./findDeclaredValue";
  *
  * Own key presence is significant even for null or undefined values; the caller
  * decides whether the selected option value is usable. An optional
- * decoded-source map or graph transaction belongs to one caller read; independent
- * option searches retain their selectors and physical ancestry contexts.
+ * decoded-source map or graph transaction belongs to one caller read;
+ * independent option searches retain their selectors and physical ancestry
+ * contexts.
  *
  * @evidence contracts/common.md#principled-implementation
  *   A wrapper preserves key presence through the generic selector, so the own

package/src/core/tsconfig/findDeclaredFileSpecs.ts

@@ -13,8 +13,9 @@ import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
  * anchored at the named declaring config, including independent link aliases.
  *
  * @returns The list and its directory, undefined when no array is selected, or
- *   null when the root config cannot be read as an object. A supplied transaction
- *   belongs to this freshness observation; later reads require a fresh owner.
+ *   null when the root config cannot be read as an object. A supplied
+ *   transaction belongs to this freshness observation; later reads require a
+ *   fresh owner.
  * @evidence contracts/common.md#principled-implementation
  *   Own invalid values stop inheritance at that node. Forward inherited
  *   traversal keeps the last array and ignores empty selections, preserving

package/src/core/tsconfig/findDeclaredPaths.ts

@@ -1,5 +1,5 @@
-import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import type { IDeclaredPaths } from "./IDeclaredPaths";
+import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { findDeclaredValue } from "./findDeclaredValue";
 
 /**
@@ -7,8 +7,8 @@ import { findDeclaredValue } from "./findDeclaredValue";
  * rooted at `tsconfig`. The own config wins over its bases; within an `extends`
  * array, later entries win over earlier ones. `seen` breaks circular chains;
  * the compiler reports the actual config error. Optional decoded sources or
- * graph observations share only within the caller's current read; physical cycle
- * guards remain branch-local.
+ * graph observations share only within the caller's current read; physical
+ * cycle guards remain branch-local.
  *
  * @evidence contracts/common.md#principled-implementation
  *   The selector accepts a non-array paths record and the shared value reader

package/src/core/tsconfig/findDeclaredValue.ts

@@ -7,7 +7,8 @@ import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
  * remain anchored at the named config; physical identity only cuts branch
  * cycles. Independent aliases can therefore resolve different relative bases.
  * Missing or malformed configs remain best-effort absence; the compiler owns
- * configuration diagnostics. Unresolved file candidates remain observed inputs.
+ * configuration diagnostics. Unresolved file candidates remain observed
+ * inputs.
  *
  * A supplied transaction shares source, identity and edge observations across
  * keys. A decoded-source map remains supported for callers that own that map;

package/src/core/tsconfig/readEffectiveTsconfigTemplateCompilerOptions.ts

@@ -1,8 +1,8 @@
 import path from "node:path";
 
-import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { CONFIG_DIR_TEMPLATE_LIST_OPTIONS } from "./CONFIG_DIR_TEMPLATE_LIST_OPTIONS";
 import { CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS } from "./CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS";
+import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { absolutizePathsTarget } from "./absolutizePathsTarget";
 import { findDeclaredCompilerOption } from "./findDeclaredCompilerOption";
 import { findDeclaredPaths } from "./findDeclaredPaths";

package/src/core/tsconfig/readEffectiveTsconfigTemplateFileSpecs.ts

@@ -15,8 +15,8 @@ const CONFIG_DIR_TEMPLATE_FILE_SPECS = ["exclude", "files", "include"] as const;
  * Lists use the compiler's last-inherited-array rule: a later base declaring
  * null cannot erase an earlier array. Invalid elements are preserved so this
  * overlay does not hide the compiler's configuration diagnostics. The three
- * list searches share graph observations only within this call; a later call reads
- * current bytes in a fresh transaction.
+ * list searches share graph observations only within this call; a later call
+ * reads current bytes in a fresh transaction.
  *
  * @param configDir The directory `${configDir}` stands for, as
  *   `readEffectiveTsconfigTemplateCompilerOptions` takes it.

package/src/core/tsconfig/readProjectMembershipPolicy.ts

@@ -2,9 +2,9 @@ import path from "node:path";
 
 import { TYPESCRIPT_TRANSFORM_EXTENSIONS } from "../source/TYPESCRIPT_TRANSFORM_EXTENSIONS";
 import type { ITtscProjectMembershipPolicy } from "./ITtscProjectMembershipPolicy";
-import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { JAVASCRIPT_INPUT_EXTENSIONS } from "./JAVASCRIPT_INPUT_EXTENSIONS";
 import { OUTPUT_DIRECTORY_OPTIONS } from "./OUTPUT_DIRECTORY_OPTIONS";
+import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { absolutizePathsTarget } from "./absolutizePathsTarget";
 import { findDeclaredFileSpecs } from "./findDeclaredFileSpecs";
 import { findDeclaredValue } from "./findDeclaredValue";
@@ -40,9 +40,9 @@ const DEFAULT_INCLUDE_SPEC = "**/*";
  * refuses to guess in the direction that loses correctness.
  *
  * Source, identity and extends observations share this transaction. Completed
- * selections, including absence, require matching physical ancestry intersections.
- * Later calls start fresh, so unchanged metadata cannot conceal changed source
- * text or resolution.
+ * selections, including absence, require matching physical ancestry
+ * intersections. Later calls start fresh, so unchanged metadata cannot conceal
+ * changed source text or resolution.
  *
  * @evidence contracts/common.md#principled-implementation
  *   Config-derived root specs, allowed extensions and exclusion provenance