@ttsc/unplugin 0.31.5 → 0.32.0

package/src/core/transform/envelope/selectNotifiableAbsentInputs.ts

@@ -8,6 +8,7 @@ import { relativeToProject } from "../filesystem/relativeToProject";
 import { isTransformScratchInput } from "../tsconfig/isTransformScratchInput";
 import { envelopeDerivation } from "./envelopeDerivation";
 import { envelopeGraphIndexes } from "./envelopeGraphIndexes";
+import { generationCaseSensitivity } from "./generationCaseSensitivity";
 
 /**
  * The generation's resolution candidates recorded as not files, so its
@@ -72,7 +73,10 @@ export function selectNotifiableAbsentInputs(props: {
   if (graph === undefined) {
     return empty;
   }
-  const identities = createHostPathIdentityContext(props.filesystem);
+  const identities = createHostPathIdentityContext(
+    props.filesystem,
+    generationCaseSensitivity(props),
+  );
   const graphState = envelopeDerivation({
     projectRoot: props.projectRoot,
     result: props.result,

package/src/core/transform/filesystem/createHostPathIdentityContext.ts

@@ -29,6 +29,8 @@ import type { TtscTransformFilesystemOperations } from "./TtscTransformFilesyste
  *   The returned context memoizes path, realpath and case observations for
  *   repeated questions within one filesystem transaction. Callers must create
  *   a new context when later filesystem changes can invalidate those observations.
+ *   A caller capturing one generation can hand in that generation's case answers,
+ *   so its contexts do not each ask the filesystem again (samchon/ttsc#1742).
  * @evidence contracts/performance.md#bound-retention-and-release-resources
  *   Ownership of the context and its maps transfers to the caller. Retained
  *   entries grow with queried paths and ancestors and have no internal eviction;
@@ -36,9 +38,15 @@ import type { TtscTransformFilesystemOperations } from "./TtscTransformFilesyste
  */
 export function createHostPathIdentityContext(
   filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+  /**
+   * Case answers this context shares with the others of its unit of work,
+   * observed through the same `filesystem`; omitted, the context asks for
+   * itself.
+   */
+  caseSensitive: TtscTransformFilesystemOperations["caseSensitive"] = filesystem.caseSensitive,
 ): FilesystemPathIdentityContext {
   return createFilesystemPathIdentityContext({
-    caseSensitive: filesystem.caseSensitive,
+    caseSensitive,
     lstat: filesystem.lstat,
     platform: filesystem.platform,
     readdir: (directory) =>

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/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.

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

@@ -38,10 +38,12 @@ import { watchLocationIdentity } from "./watchLocationIdentity";
  * directory excluded in both lexical and native spellings. Unknown, missing and
  * 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. 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.
+ * 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
@@ -193,6 +195,26 @@ export async function createProjectMutationTracker(
     }
     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);
@@ -221,8 +243,14 @@ export async function createProjectMutationTracker(
     // 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.
-    if (!membership && !excludedFromWalk(changed, true))
+    // 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;
   };

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