@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/project/isProjectWalkDirectory.mjs

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { matchesProjectRootFile } from '../../tsconfig/matchesProjectRootFile.mjs';
+import { isExcludedProjectDirectory } from './isExcludedProjectDirectory.mjs';
+import { isIgnoredProjectEntry } from './isIgnoredProjectEntry.mjs';
+
+/**
+ * Whether `walkProjectInputs` descends into a directory it meets, by the same
+ * three tests it applies to each entry.
+ *
+ * The directory-level observer on Linux watches exactly these directories, so
+ * the project tracker hears every membership change the walk can see and
+ * nothing below a directory the walk never enters (samchon/ttsc#1389).
+ *
+ * @evidence contracts/common.md#principled-implementation Name fallback, configured subtree exclusion and compiler root-pattern admission jointly define directory descent, matching the walk and Linux observer's membership domain.
+ * @evidence contracts/common.md#clear-and-simple-design The predicate composes three existing policy owners with short-circuiting rather than duplicating their matching grammars.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Watch admission follows the same configuration semantics as enumeration instead of compensating with an independent directory-name list.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs identify the three conditions and explain why the Linux observer must share this boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit filesystem-view platform selects native basename and configured containment grammar throughout the delegated root rules; Linux observer use does not introduce a Linux-only directory policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Short-circuit name rejection precedes configured exclusion and root
+ *   matching. Basename and containment cost follow path text and excluded
+ *   directory count; matching follows root spelling variants, configured
+ *   patterns and their component states. Temporary normalized paths and
+ *   matching state belong to those delegated operations, while immutable
+ *   policy compilation is shared by the matching owner.
+ *   Wildcard component matching merges token states with work bounded by
+ *   pattern and candidate code-point dimensions; literal tests retain text cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function isProjectWalkDirectory(directory, policy, platform = process.platform) {
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    return (!isIgnoredProjectEntry(pathApi.basename(directory), policy) &&
+        !isExcludedProjectDirectory(directory, policy, platform) &&
+        matchesProjectRootFile(directory, policy, true, platform));
+}
+
+export { isProjectWalkDirectory };
+//# sourceMappingURL=isProjectWalkDirectory.mjs.map

package/lib/core/transform/project/isProjectWalkDirectory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isProjectWalkDirectory.mjs","sources":["../../../../src/core/transform/project/isProjectWalkDirectory.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACG,SAAU,sBAAsB,CACpC,SAAiB,EACjB,MAAoC,EACpC,QAAA,GAA4B,OAAO,CAAC,QAAQ,EAAA;AAE5C,IAAA,MAAM,OAAO,GAAG,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;AAC9D,IAAA,QACE,CAAC,qBAAqB,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;AAC3D,QAAA,CAAC,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC;QACxD,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC;AAE7D;;;;"}

package/lib/core/transform/project/isProjectWalkPath.d.cts

@@ -0,0 +1,36 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Report whether an absolute `file` belongs to the project walk universe of
+ * `root`: it lies under `root`, each component below that root exists without
+ * traversing a symbolic link, the leaf is a regular file, and the configured
+ * name, directory and file rules admit it. This establishes current walk
+ * eligibility, not that a particular capture actually read or hashed it.
+ * Missing paths and files reached through symlinks or Windows junctions are
+ * out-of-walk inputs that only the reference graph can prove relevant.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical root containment, admitted filename policy and lstat of every component establish that the actual walk reaches this regular file without traversing a symlink or junction.
+ * @evidence contracts/common.md#clear-and-simple-design Ordered early rejections separate containment, policy and filesystem-kind checks; physical identity is deliberately not substituted for lexical traversal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, missing and linked paths remain out-of-walk so graph proof must cover them instead of silently treating an unvisited physical target as hashed.
+ * @evidence contracts/common.md#meaningful-documentation The native summary states the complete walk-membership premise, and inline paragraphs explain why canonical identity and unadmitted extensions cannot stand in for traversal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native path operations preserve root and drive boundaries, while the supplied lstat view detects symbolic links and Windows junctions without assuming global filesystem case sensitivity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Resolves lexical root/file text, splits components, checks configured
+ *   exclusions and compiler patterns, then performs one native lstat per
+ *   reached component until rejection. Costs include path/extension text,
+ *   policy pattern populations and native component observations; joining
+ *   successive prefixes also processes their growing text. No byte read or
+ *   recursive directory enumeration is needed for this eligibility query.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This reports current native walk eligibility, not a saved capture proof.
+ *   Mutation can change the answer for the same spelling; enclosing validation
+ *   owns when an earlier observation may be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function isProjectWalkPath(
+/** Lexical project boundary; only components below it are inspected here. */
+root: string, 
+/** Native file address whose present walk eligibility is requested. */
+file: string, _identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): boolean;

package/lib/core/transform/project/isProjectWalkPath.d.mts

@@ -0,0 +1,36 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Report whether an absolute `file` belongs to the project walk universe of
+ * `root`: it lies under `root`, each component below that root exists without
+ * traversing a symbolic link, the leaf is a regular file, and the configured
+ * name, directory and file rules admit it. This establishes current walk
+ * eligibility, not that a particular capture actually read or hashed it.
+ * Missing paths and files reached through symlinks or Windows junctions are
+ * out-of-walk inputs that only the reference graph can prove relevant.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical root containment, admitted filename policy and lstat of every component establish that the actual walk reaches this regular file without traversing a symlink or junction.
+ * @evidence contracts/common.md#clear-and-simple-design Ordered early rejections separate containment, policy and filesystem-kind checks; physical identity is deliberately not substituted for lexical traversal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, missing and linked paths remain out-of-walk so graph proof must cover them instead of silently treating an unvisited physical target as hashed.
+ * @evidence contracts/common.md#meaningful-documentation The native summary states the complete walk-membership premise, and inline paragraphs explain why canonical identity and unadmitted extensions cannot stand in for traversal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native path operations preserve root and drive boundaries, while the supplied lstat view detects symbolic links and Windows junctions without assuming global filesystem case sensitivity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Resolves lexical root/file text, splits components, checks configured
+ *   exclusions and compiler patterns, then performs one native lstat per
+ *   reached component until rejection. Costs include path/extension text,
+ *   policy pattern populations and native component observations; joining
+ *   successive prefixes also processes their growing text. No byte read or
+ *   recursive directory enumeration is needed for this eligibility query.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This reports current native walk eligibility, not a saved capture proof.
+ *   Mutation can change the answer for the same spelling; enclosing validation
+ *   owns when an earlier observation may be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function isProjectWalkPath(
+/** Lexical project boundary; only components below it are inspected here. */
+root: string, 
+/** Native file address whose present walk eligibility is requested. */
+file: string, _identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): boolean;

package/lib/core/transform/project/isProjectWalkPath.d.ts

@@ -0,0 +1,36 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Report whether an absolute `file` belongs to the project walk universe of
+ * `root`: it lies under `root`, each component below that root exists without
+ * traversing a symbolic link, the leaf is a regular file, and the configured
+ * name, directory and file rules admit it. This establishes current walk
+ * eligibility, not that a particular capture actually read or hashed it.
+ * Missing paths and files reached through symlinks or Windows junctions are
+ * out-of-walk inputs that only the reference graph can prove relevant.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical root containment, admitted filename policy and lstat of every component establish that the actual walk reaches this regular file without traversing a symlink or junction.
+ * @evidence contracts/common.md#clear-and-simple-design Ordered early rejections separate containment, policy and filesystem-kind checks; physical identity is deliberately not substituted for lexical traversal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, missing and linked paths remain out-of-walk so graph proof must cover them instead of silently treating an unvisited physical target as hashed.
+ * @evidence contracts/common.md#meaningful-documentation The native summary states the complete walk-membership premise, and inline paragraphs explain why canonical identity and unadmitted extensions cannot stand in for traversal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native path operations preserve root and drive boundaries, while the supplied lstat view detects symbolic links and Windows junctions without assuming global filesystem case sensitivity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Resolves lexical root/file text, splits components, checks configured
+ *   exclusions and compiler patterns, then performs one native lstat per
+ *   reached component until rejection. Costs include path/extension text,
+ *   policy pattern populations and native component observations; joining
+ *   successive prefixes also processes their growing text. No byte read or
+ *   recursive directory enumeration is needed for this eligibility query.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This reports current native walk eligibility, not a saved capture proof.
+ *   Mutation can change the answer for the same spelling; enclosing validation
+ *   owns when an earlier observation may be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function isProjectWalkPath(
+/** Lexical project boundary; only components below it are inspected here. */
+root: string, 
+/** Native file address whose present walk eligibility is requested. */
+file: string, _identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): boolean;

package/lib/core/transform/project/isProjectWalkPath.js

@@ -0,0 +1,101 @@
+'use strict';
+
+var path = require('node:path');
+var PERMISSIVE_PROJECT_MEMBERSHIP_POLICY = require('../../tsconfig/PERMISSIVE_PROJECT_MEMBERSHIP_POLICY.js');
+var matchesProjectRootFile = require('../../tsconfig/matchesProjectRootFile.js');
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var isExcludedProjectDirectory = require('./isExcludedProjectDirectory.js');
+var isIgnoredProjectEntry = require('./isIgnoredProjectEntry.js');
+var isPossibleProgramFileName = require('./isPossibleProgramFileName.js');
+
+/**
+ * Report whether an absolute `file` belongs to the project walk universe of
+ * `root`: it lies under `root`, each component below that root exists without
+ * traversing a symbolic link, the leaf is a regular file, and the configured
+ * name, directory and file rules admit it. This establishes current walk
+ * eligibility, not that a particular capture actually read or hashed it.
+ * Missing paths and files reached through symlinks or Windows junctions are
+ * out-of-walk inputs that only the reference graph can prove relevant.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical root containment, admitted filename policy and lstat of every component establish that the actual walk reaches this regular file without traversing a symlink or junction.
+ * @evidence contracts/common.md#clear-and-simple-design Ordered early rejections separate containment, policy and filesystem-kind checks; physical identity is deliberately not substituted for lexical traversal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, missing and linked paths remain out-of-walk so graph proof must cover them instead of silently treating an unvisited physical target as hashed.
+ * @evidence contracts/common.md#meaningful-documentation The native summary states the complete walk-membership premise, and inline paragraphs explain why canonical identity and unadmitted extensions cannot stand in for traversal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native path operations preserve root and drive boundaries, while the supplied lstat view detects symbolic links and Windows junctions without assuming global filesystem case sensitivity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Resolves lexical root/file text, splits components, checks configured
+ *   exclusions and compiler patterns, then performs one native lstat per
+ *   reached component until rejection. Costs include path/extension text,
+ *   policy pattern populations and native component observations; joining
+ *   successive prefixes also processes their growing text. No byte read or
+ *   recursive directory enumeration is needed for this eligibility query.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This reports current native walk eligibility, not a saved capture proof.
+ *   Mutation can change the answer for the same spelling; enclosing validation
+ *   owns when an earlier observation may be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function isProjectWalkPath(
+/** Lexical project boundary; only components below it are inspected here. */
+root, 
+/** Native file address whose present walk eligibility is requested. */
+file, _identities = createHostPathIdentityContext.createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, policy = PERMISSIVE_PROJECT_MEMBERSHIP_POLICY.PERMISSIVE_PROJECT_MEMBERSHIP_POLICY) {
+    const platform = filesystem.platform ?? process.platform;
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    // Walk membership is lexical. Resolving `file` to physical identity first
+    // would turn `root/alias/value.ts` into `root/target/value.ts`, hide the
+    // symlink segment from the lstat loop below, and falsely claim the project
+    // walk hashed a path it deliberately never followed.
+    const resolvedRoot = pathApi.resolve(root);
+    const relative = pathApi.relative(resolvedRoot, pathApi.resolve(file));
+    if (relative.length === 0 ||
+        relative === ".." ||
+        relative.startsWith(`..${pathApi.sep}`) ||
+        pathApi.isAbsolute(relative)) {
+        return false;
+    }
+    const segments = relative.split(pathApi.sep);
+    // The last segment is the file itself, which the walk names rather than
+    // descends into, so only the directory components decide walk membership.
+    if (segments
+        .slice(0, -1)
+        .some((segment) => isIgnoredProjectEntry.isIgnoredProjectEntry(segment, policy))) {
+        return false;
+    }
+    if (isExcludedProjectDirectory.isExcludedProjectDirectory(pathApi.dirname(pathApi.resolve(file)), policy, platform)) {
+        return false;
+    }
+    // The walk hashes only files that could enter the program, so a path it does
+    // not hash is out of the walk by definition. Answering otherwise would leave
+    // a graph input the compiler really read in neither snapshot: absent from
+    // `inputHashes` because the walk skipped it, and absent from the out-of-walk
+    // snapshot because this predicate claimed the walk covered it.
+    if (!isPossibleProgramFileName.isPossibleProgramFileName(pathApi.basename(file), policy) ||
+        !matchesProjectRootFile.matchesProjectRootFile(file, policy, false, platform)) {
+        return false;
+    }
+    let current = resolvedRoot;
+    for (let index = 0; index < segments.length; ++index) {
+        current = pathApi.join(current, segments[index]);
+        let stats;
+        try {
+            stats = filesystem.lstat(current);
+        }
+        catch {
+            return false;
+        }
+        if (stats.isSymbolicLink()) {
+            return false;
+        }
+        const leaf = index === segments.length - 1;
+        if ((leaf && !stats.isFile()) || (!leaf && !stats.isDirectory())) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.isProjectWalkPath = isProjectWalkPath;
+//# sourceMappingURL=isProjectWalkPath.js.map

package/lib/core/transform/project/isProjectWalkPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isProjectWalkPath.js","sources":["../../../../src/core/transform/project/isProjectWalkPath.ts"],"sourcesContent":[null],"names":["createHostPathIdentityContext","DEFAULT_FILESYSTEM_OPERATIONS","PERMISSIVE_PROJECT_MEMBERSHIP_POLICY","isIgnoredProjectEntry","isExcludedProjectDirectory","isPossibleProgramFileName","matchesProjectRootFile"],"mappings":";;;;;;;;;;;AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;SACa,iBAAiB;AAC/B;AACA,IAAY;AACZ;AACA,IAAY,EACZ,cAA6CA,2DAA6B,EAAE,EAC5E,UAAA,GAAgDC,2DAA6B,EAC7E,MAAA,GAAuCC,yEAAoC,EAAA;IAE3E,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ;AACxD,IAAA,MAAM,OAAO,GAAG,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;;;;;IAK9D,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;AAC1C,IAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACtE,IAAA,IACE,QAAQ,CAAC,MAAM,KAAK,CAAC;AACrB,QAAA,QAAQ,KAAK,IAAI;QACjB,QAAQ,CAAC,UAAU,CAAC,CAAA,EAAA,EAAK,OAAO,CAAC,GAAG,EAAE,CAAC;AACvC,QAAA,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAC5B;AACA,QAAA,OAAO,KAAK;IACd;IACA,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;;;AAG5C,IAAA,IACE;AACG,SAAA,KAAK,CAAC,CAAC,EAAE,EAAE;AACX,SAAA,IAAI,CAAC,CAAC,OAAO,KAAKC,2CAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,EAC5D;AACA,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IACEC,qDAA0B,CACxB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EACtC,MAAM,EACN,QAAQ,CACT,EACD;AACA,QAAA,OAAO,KAAK;IACd;;;;;;IAMA,IACE,CAACC,mDAAyB,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAC1D,CAACC,6CAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,EACtD;AACA,QAAA,OAAO,KAAK;IACd;IACA,IAAI,OAAO,GAAG,YAAY;AAC1B,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE;AACpD,QAAA,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAE,CAAC;AACjD,QAAA,IAAI,KAAqB;AACzB,QAAA,IAAI;AACF,YAAA,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC;QACnC;AAAE,QAAA,MAAM;AACN,YAAA,OAAO,KAAK;QACd;AACA,QAAA,IAAI,KAAK,CAAC,cAAc,EAAE,EAAE;AAC1B,YAAA,OAAO,KAAK;QACd;QACA,MAAM,IAAI,GAAG,KAAK,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC;QAC1C,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,EAAE;AAChE,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/project/isProjectWalkPath.mjs

@@ -0,0 +1,99 @@
+import path from 'node:path';
+import { PERMISSIVE_PROJECT_MEMBERSHIP_POLICY } from '../../tsconfig/PERMISSIVE_PROJECT_MEMBERSHIP_POLICY.mjs';
+import { matchesProjectRootFile } from '../../tsconfig/matchesProjectRootFile.mjs';
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { isExcludedProjectDirectory } from './isExcludedProjectDirectory.mjs';
+import { isIgnoredProjectEntry } from './isIgnoredProjectEntry.mjs';
+import { isPossibleProgramFileName } from './isPossibleProgramFileName.mjs';
+
+/**
+ * Report whether an absolute `file` belongs to the project walk universe of
+ * `root`: it lies under `root`, each component below that root exists without
+ * traversing a symbolic link, the leaf is a regular file, and the configured
+ * name, directory and file rules admit it. This establishes current walk
+ * eligibility, not that a particular capture actually read or hashed it.
+ * Missing paths and files reached through symlinks or Windows junctions are
+ * out-of-walk inputs that only the reference graph can prove relevant.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical root containment, admitted filename policy and lstat of every component establish that the actual walk reaches this regular file without traversing a symlink or junction.
+ * @evidence contracts/common.md#clear-and-simple-design Ordered early rejections separate containment, policy and filesystem-kind checks; physical identity is deliberately not substituted for lexical traversal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, missing and linked paths remain out-of-walk so graph proof must cover them instead of silently treating an unvisited physical target as hashed.
+ * @evidence contracts/common.md#meaningful-documentation The native summary states the complete walk-membership premise, and inline paragraphs explain why canonical identity and unadmitted extensions cannot stand in for traversal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native path operations preserve root and drive boundaries, while the supplied lstat view detects symbolic links and Windows junctions without assuming global filesystem case sensitivity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Resolves lexical root/file text, splits components, checks configured
+ *   exclusions and compiler patterns, then performs one native lstat per
+ *   reached component until rejection. Costs include path/extension text,
+ *   policy pattern populations and native component observations; joining
+ *   successive prefixes also processes their growing text. No byte read or
+ *   recursive directory enumeration is needed for this eligibility query.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This reports current native walk eligibility, not a saved capture proof.
+ *   Mutation can change the answer for the same spelling; enclosing validation
+ *   owns when an earlier observation may be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function isProjectWalkPath(
+/** Lexical project boundary; only components below it are inspected here. */
+root, 
+/** Native file address whose present walk eligibility is requested. */
+file, _identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy = PERMISSIVE_PROJECT_MEMBERSHIP_POLICY) {
+    const platform = filesystem.platform ?? process.platform;
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    // Walk membership is lexical. Resolving `file` to physical identity first
+    // would turn `root/alias/value.ts` into `root/target/value.ts`, hide the
+    // symlink segment from the lstat loop below, and falsely claim the project
+    // walk hashed a path it deliberately never followed.
+    const resolvedRoot = pathApi.resolve(root);
+    const relative = pathApi.relative(resolvedRoot, pathApi.resolve(file));
+    if (relative.length === 0 ||
+        relative === ".." ||
+        relative.startsWith(`..${pathApi.sep}`) ||
+        pathApi.isAbsolute(relative)) {
+        return false;
+    }
+    const segments = relative.split(pathApi.sep);
+    // The last segment is the file itself, which the walk names rather than
+    // descends into, so only the directory components decide walk membership.
+    if (segments
+        .slice(0, -1)
+        .some((segment) => isIgnoredProjectEntry(segment, policy))) {
+        return false;
+    }
+    if (isExcludedProjectDirectory(pathApi.dirname(pathApi.resolve(file)), policy, platform)) {
+        return false;
+    }
+    // The walk hashes only files that could enter the program, so a path it does
+    // not hash is out of the walk by definition. Answering otherwise would leave
+    // a graph input the compiler really read in neither snapshot: absent from
+    // `inputHashes` because the walk skipped it, and absent from the out-of-walk
+    // snapshot because this predicate claimed the walk covered it.
+    if (!isPossibleProgramFileName(pathApi.basename(file), policy) ||
+        !matchesProjectRootFile(file, policy, false, platform)) {
+        return false;
+    }
+    let current = resolvedRoot;
+    for (let index = 0; index < segments.length; ++index) {
+        current = pathApi.join(current, segments[index]);
+        let stats;
+        try {
+            stats = filesystem.lstat(current);
+        }
+        catch {
+            return false;
+        }
+        if (stats.isSymbolicLink()) {
+            return false;
+        }
+        const leaf = index === segments.length - 1;
+        if ((leaf && !stats.isFile()) || (!leaf && !stats.isDirectory())) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { isProjectWalkPath };
+//# sourceMappingURL=isProjectWalkPath.mjs.map

package/lib/core/transform/project/isProjectWalkPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isProjectWalkPath.mjs","sources":["../../../../src/core/transform/project/isProjectWalkPath.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;SACa,iBAAiB;AAC/B;AACA,IAAY;AACZ;AACA,IAAY,EACZ,cAA6C,6BAA6B,EAAE,EAC5E,UAAA,GAAgD,6BAA6B,EAC7E,MAAA,GAAuC,oCAAoC,EAAA;IAE3E,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ;AACxD,IAAA,MAAM,OAAO,GAAG,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;;;;;IAK9D,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;AAC1C,IAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACtE,IAAA,IACE,QAAQ,CAAC,MAAM,KAAK,CAAC;AACrB,QAAA,QAAQ,KAAK,IAAI;QACjB,QAAQ,CAAC,UAAU,CAAC,CAAA,EAAA,EAAK,OAAO,CAAC,GAAG,EAAE,CAAC;AACvC,QAAA,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAC5B;AACA,QAAA,OAAO,KAAK;IACd;IACA,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;;;AAG5C,IAAA,IACE;AACG,SAAA,KAAK,CAAC,CAAC,EAAE,EAAE;AACX,SAAA,IAAI,CAAC,CAAC,OAAO,KAAK,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,EAC5D;AACA,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IACE,0BAA0B,CACxB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EACtC,MAAM,EACN,QAAQ,CACT,EACD;AACA,QAAA,OAAO,KAAK;IACd;;;;;;IAMA,IACE,CAAC,yBAAyB,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAC1D,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,EACtD;AACA,QAAA,OAAO,KAAK;IACd;IACA,IAAI,OAAO,GAAG,YAAY;AAC1B,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE;AACpD,QAAA,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAE,CAAC;AACjD,QAAA,IAAI,KAAqB;AACzB,QAAA,IAAI;AACF,YAAA,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC;QACnC;AAAE,QAAA,MAAM;AACN,YAAA,OAAO,KAAK;QACd;AACA,QAAA,IAAI,KAAK,CAAC,cAAc,EAAE,EAAE;AAC1B,YAAA,OAAO,KAAK;QACd;QACA,MAAM,IAAI,GAAG,KAAK,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC;QAC1C,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,EAAE;AAChE,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/project/projectMembershipDigest.d.cts

@@ -0,0 +1,27 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+import type { TtscProjectDirectorySnapshot } from "./TtscProjectDirectorySnapshot.cjs";
+/**
+ * Digest a project's root-file membership: the policy that decides it and every
+ * directory whose subtree currently contains an admitted regular file, with its
+ * membership signature.
+ *
+ * It is the same judgement `sameProjectDirectories` makes. Directories that
+ * contain no admitted regular file are left out, so a bundler filling its
+ * output directory leaves the digest alone, while a program input appearing
+ * anywhere the walk enters changes a signature and with it the digest. The
+ * policy is part of it, since the same directories under another rule are
+ * another membership, and a re-walk must apply the rule the digest was taken
+ * under.
+ *
+ * @param policy The rule the walk applied.
+ * @param directories The walk's directory snapshots.
+ * @evidence contracts/common.md#principled-implementation Relevant directory address/signature pairs and the exact membership policy define the digest; sorting the pairs removes enumeration order without discarding policy arrays or admitted-input meaning.
+ * @evidence contracts/common.md#clear-and-simple-design A projection, lexical sort and shared encoding/hash compose the identity without performing another filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant emitted trees are excluded by the walk's computed relevance, not hardcoded output names; changed policy remains part of the identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain policy inclusion, irrelevant-directory omission and equivalence to the membership comparison; parameter tags name the contributing values.
+ * @evidence contracts/portability.md#os-neutral-implementation Directory addresses and policy path spellings are serialized exactly as recorded by the same native project walk; sorting only removes enumeration order and introduces no independent case or alias equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary pairs and serialization are local to this call; the digest transfers to its caller and no resource is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all D directory records and retains r relevant address/signature pairs. Pair sorting uses O(r log r) path-text comparisons; stable encoding additionally sorts policy record keys and serializes policy arrays and selected path/signature text, then hashes the emitted bytes. Temporary filter/pair arrays, sorted record copies and JSON text follow those populations rather than only the relevant-directory count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The operation hashes caller-supplied values and coordinates no completed or in-flight computation; mutable snapshot arrays and policy do not authorize persistent memoization here.
+ */
+export declare function projectMembershipDigest(policy: ITtscProjectMembershipPolicy, directories: readonly TtscProjectDirectorySnapshot[]): string;

package/lib/core/transform/project/projectMembershipDigest.d.mts

@@ -0,0 +1,27 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+import type { TtscProjectDirectorySnapshot } from "./TtscProjectDirectorySnapshot.mjs";
+/**
+ * Digest a project's root-file membership: the policy that decides it and every
+ * directory whose subtree currently contains an admitted regular file, with its
+ * membership signature.
+ *
+ * It is the same judgement `sameProjectDirectories` makes. Directories that
+ * contain no admitted regular file are left out, so a bundler filling its
+ * output directory leaves the digest alone, while a program input appearing
+ * anywhere the walk enters changes a signature and with it the digest. The
+ * policy is part of it, since the same directories under another rule are
+ * another membership, and a re-walk must apply the rule the digest was taken
+ * under.
+ *
+ * @param policy The rule the walk applied.
+ * @param directories The walk's directory snapshots.
+ * @evidence contracts/common.md#principled-implementation Relevant directory address/signature pairs and the exact membership policy define the digest; sorting the pairs removes enumeration order without discarding policy arrays or admitted-input meaning.
+ * @evidence contracts/common.md#clear-and-simple-design A projection, lexical sort and shared encoding/hash compose the identity without performing another filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant emitted trees are excluded by the walk's computed relevance, not hardcoded output names; changed policy remains part of the identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain policy inclusion, irrelevant-directory omission and equivalence to the membership comparison; parameter tags name the contributing values.
+ * @evidence contracts/portability.md#os-neutral-implementation Directory addresses and policy path spellings are serialized exactly as recorded by the same native project walk; sorting only removes enumeration order and introduces no independent case or alias equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary pairs and serialization are local to this call; the digest transfers to its caller and no resource is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all D directory records and retains r relevant address/signature pairs. Pair sorting uses O(r log r) path-text comparisons; stable encoding additionally sorts policy record keys and serializes policy arrays and selected path/signature text, then hashes the emitted bytes. Temporary filter/pair arrays, sorted record copies and JSON text follow those populations rather than only the relevant-directory count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The operation hashes caller-supplied values and coordinates no completed or in-flight computation; mutable snapshot arrays and policy do not authorize persistent memoization here.
+ */
+export declare function projectMembershipDigest(policy: ITtscProjectMembershipPolicy, directories: readonly TtscProjectDirectorySnapshot[]): string;

package/lib/core/transform/project/projectMembershipDigest.d.ts

@@ -0,0 +1,27 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+import type { TtscProjectDirectorySnapshot } from "./TtscProjectDirectorySnapshot";
+/**
+ * Digest a project's root-file membership: the policy that decides it and every
+ * directory whose subtree currently contains an admitted regular file, with its
+ * membership signature.
+ *
+ * It is the same judgement `sameProjectDirectories` makes. Directories that
+ * contain no admitted regular file are left out, so a bundler filling its
+ * output directory leaves the digest alone, while a program input appearing
+ * anywhere the walk enters changes a signature and with it the digest. The
+ * policy is part of it, since the same directories under another rule are
+ * another membership, and a re-walk must apply the rule the digest was taken
+ * under.
+ *
+ * @param policy The rule the walk applied.
+ * @param directories The walk's directory snapshots.
+ * @evidence contracts/common.md#principled-implementation Relevant directory address/signature pairs and the exact membership policy define the digest; sorting the pairs removes enumeration order without discarding policy arrays or admitted-input meaning.
+ * @evidence contracts/common.md#clear-and-simple-design A projection, lexical sort and shared encoding/hash compose the identity without performing another filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant emitted trees are excluded by the walk's computed relevance, not hardcoded output names; changed policy remains part of the identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain policy inclusion, irrelevant-directory omission and equivalence to the membership comparison; parameter tags name the contributing values.
+ * @evidence contracts/portability.md#os-neutral-implementation Directory addresses and policy path spellings are serialized exactly as recorded by the same native project walk; sorting only removes enumeration order and introduces no independent case or alias equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary pairs and serialization are local to this call; the digest transfers to its caller and no resource is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all D directory records and retains r relevant address/signature pairs. Pair sorting uses O(r log r) path-text comparisons; stable encoding additionally sorts policy record keys and serializes policy arrays and selected path/signature text, then hashes the emitted bytes. Temporary filter/pair arrays, sorted record copies and JSON text follow those populations rather than only the relevant-directory count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The operation hashes caller-supplied values and coordinates no completed or in-flight computation; mutable snapshot arrays and policy do not authorize persistent memoization here.
+ */
+export declare function projectMembershipDigest(policy: ITtscProjectMembershipPolicy, directories: readonly TtscProjectDirectorySnapshot[]): string;

package/lib/core/transform/project/projectMembershipDigest.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var hashText = require('../utils/hashText.js');
+var stableStringify = require('../utils/stableStringify.js');
+
+/**
+ * Digest a project's root-file membership: the policy that decides it and every
+ * directory whose subtree currently contains an admitted regular file, with its
+ * membership signature.
+ *
+ * It is the same judgement `sameProjectDirectories` makes. Directories that
+ * contain no admitted regular file are left out, so a bundler filling its
+ * output directory leaves the digest alone, while a program input appearing
+ * anywhere the walk enters changes a signature and with it the digest. The
+ * policy is part of it, since the same directories under another rule are
+ * another membership, and a re-walk must apply the rule the digest was taken
+ * under.
+ *
+ * @param policy The rule the walk applied.
+ * @param directories The walk's directory snapshots.
+ * @evidence contracts/common.md#principled-implementation Relevant directory address/signature pairs and the exact membership policy define the digest; sorting the pairs removes enumeration order without discarding policy arrays or admitted-input meaning.
+ * @evidence contracts/common.md#clear-and-simple-design A projection, lexical sort and shared encoding/hash compose the identity without performing another filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant emitted trees are excluded by the walk's computed relevance, not hardcoded output names; changed policy remains part of the identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain policy inclusion, irrelevant-directory omission and equivalence to the membership comparison; parameter tags name the contributing values.
+ * @evidence contracts/portability.md#os-neutral-implementation Directory addresses and policy path spellings are serialized exactly as recorded by the same native project walk; sorting only removes enumeration order and introduces no independent case or alias equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary pairs and serialization are local to this call; the digest transfers to its caller and no resource is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all D directory records and retains r relevant address/signature pairs. Pair sorting uses O(r log r) path-text comparisons; stable encoding additionally sorts policy record keys and serializes policy arrays and selected path/signature text, then hashes the emitted bytes. Temporary filter/pair arrays, sorted record copies and JSON text follow those populations rather than only the relevant-directory count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The operation hashes caller-supplied values and coordinates no completed or in-flight computation; mutable snapshot arrays and policy do not authorize persistent memoization here.
+ */
+function projectMembershipDigest(policy, directories) {
+    return hashText.hashText(stableStringify.stableStringify({
+        directories: directories
+            .filter((directory) => directory.relevant)
+            .map((directory) => [directory.path, directory.signature])
+            .sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0),
+        policy,
+    }));
+}
+
+exports.projectMembershipDigest = projectMembershipDigest;
+//# sourceMappingURL=projectMembershipDigest.js.map

package/lib/core/transform/project/projectMembershipDigest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectMembershipDigest.js","sources":["../../../../src/core/transform/project/projectMembershipDigest.ts"],"sourcesContent":[null],"names":["hashText","stableStringify"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,uBAAuB,CACrC,MAAoC,EACpC,WAAoD,EAAA;IAEpD,OAAOA,iBAAQ,CACbC,+BAAe,CAAC;AACd,QAAA,WAAW,EAAE;aACV,MAAM,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,QAAQ;AACxC,aAAA,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC;AACxD,aAAA,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,KAChB,IAAI,CAAC,CAAC,CAAE,GAAG,KAAK,CAAC,CAAC,CAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAE,GAAG,KAAK,CAAC,CAAC,CAAE,GAAG,CAAC,GAAG,CAAC,CACzD;QACH,MAAM;AACP,KAAA,CAAC,CACH;AACH;;;;"}

package/lib/core/transform/project/projectMembershipDigest.mjs

@@ -0,0 +1,39 @@
+import { hashText } from '../utils/hashText.mjs';
+import { stableStringify } from '../utils/stableStringify.mjs';
+
+/**
+ * Digest a project's root-file membership: the policy that decides it and every
+ * directory whose subtree currently contains an admitted regular file, with its
+ * membership signature.
+ *
+ * It is the same judgement `sameProjectDirectories` makes. Directories that
+ * contain no admitted regular file are left out, so a bundler filling its
+ * output directory leaves the digest alone, while a program input appearing
+ * anywhere the walk enters changes a signature and with it the digest. The
+ * policy is part of it, since the same directories under another rule are
+ * another membership, and a re-walk must apply the rule the digest was taken
+ * under.
+ *
+ * @param policy The rule the walk applied.
+ * @param directories The walk's directory snapshots.
+ * @evidence contracts/common.md#principled-implementation Relevant directory address/signature pairs and the exact membership policy define the digest; sorting the pairs removes enumeration order without discarding policy arrays or admitted-input meaning.
+ * @evidence contracts/common.md#clear-and-simple-design A projection, lexical sort and shared encoding/hash compose the identity without performing another filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant emitted trees are excluded by the walk's computed relevance, not hardcoded output names; changed policy remains part of the identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain policy inclusion, irrelevant-directory omission and equivalence to the membership comparison; parameter tags name the contributing values.
+ * @evidence contracts/portability.md#os-neutral-implementation Directory addresses and policy path spellings are serialized exactly as recorded by the same native project walk; sorting only removes enumeration order and introduces no independent case or alias equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary pairs and serialization are local to this call; the digest transfers to its caller and no resource is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering scans all D directory records and retains r relevant address/signature pairs. Pair sorting uses O(r log r) path-text comparisons; stable encoding additionally sorts policy record keys and serializes policy arrays and selected path/signature text, then hashes the emitted bytes. Temporary filter/pair arrays, sorted record copies and JSON text follow those populations rather than only the relevant-directory count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The operation hashes caller-supplied values and coordinates no completed or in-flight computation; mutable snapshot arrays and policy do not authorize persistent memoization here.
+ */
+function projectMembershipDigest(policy, directories) {
+    return hashText(stableStringify({
+        directories: directories
+            .filter((directory) => directory.relevant)
+            .map((directory) => [directory.path, directory.signature])
+            .sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0),
+        policy,
+    }));
+}
+
+export { projectMembershipDigest };
+//# sourceMappingURL=projectMembershipDigest.mjs.map

package/lib/core/transform/project/projectMembershipDigest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectMembershipDigest.mjs","sources":["../../../../src/core/transform/project/projectMembershipDigest.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,uBAAuB,CACrC,MAAoC,EACpC,WAAoD,EAAA;IAEpD,OAAO,QAAQ,CACb,eAAe,CAAC;AACd,QAAA,WAAW,EAAE;aACV,MAAM,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,QAAQ;AACxC,aAAA,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC;AACxD,aAAA,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,KAChB,IAAI,CAAC,CAAC,CAAE,GAAG,KAAK,CAAC,CAAC,CAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAE,GAAG,KAAK,CAAC,CAAC,CAAE,GAAG,CAAC,GAAG,CAAC,CACzD;QACH,MAAM;AACP,KAAA,CAAC,CACH;AACH;;;;"}

package/lib/core/transform/project/projectMembershipMatches.d.cts

@@ -0,0 +1,26 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscWatchInputState } from "../watch/TtscWatchInputState.cjs";
+/**
+ * Whether a project's root-file membership still equals what a generation
+ * recorded (samchon/ttsc#1419).
+ *
+ * The project is walked again under the recorded policy, the same walk the
+ * transform proves a generation with, and its digest compared. A walk that
+ * could not observe every directory coherently cannot prove anything, so it
+ * answers `false`: the host re-runs the module, and the transform decides.
+ *
+ * @param root The project root the membership belongs to.
+ * @param state The recorded membership.
+ * @param filesystem The filesystem to walk.
+ * @evidence contracts/common.md#principled-implementation Re-enumeration under the recorded policy must be complete before its membership digest may equal the captured value; an incomplete walk cannot authorize reuse.
+ * @evidence contracts/common.md#clear-and-simple-design The operation delegates enumeration and digest construction to their existing owners and combines only completeness with identity comparison.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A matching partial directory set or quiet watcher is not substituted for a coherent membership observation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state the recorded-policy premise and conservative false result on incomplete observation; parameter tags identify the root, state and filesystem seam.
+ * @evidence contracts/portability.md#os-neutral-implementation The same injected native filesystem view is used for re-enumeration, while recorded policy preserves the compiler's case and root rules; this comparison introduces no separate platform assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Walk results live only through this comparison and no handle, task or historical snapshot is retained here.
+ * @evidence contracts/performance.md#efficient-algorithms One current walk feeds one digest comparison, and incompleteness short-circuits digest construction. Native observations and admission inspect visited directory/entry and path populations; membership lists and final paths are sorted by the walk. Digest construction scans all directory records, sorts relevant address/signature pairs and encodes the policy's keys and text through its shared owner. Walk and serialization collections are temporary to this fallback.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The policy and captured digest are already supplied comparison inputs; this fallback coordinates no completed or in-flight current walk across requests. Mutable directory membership requires current observations, while the calling observer owns condition sharing and any event-authorized omission of the fallback.
+ */
+export declare function projectMembershipMatches(root: string, state: Extract<TtscWatchInputState, {
+    codec: "membership";
+}>, filesystem?: TtscTransformFilesystemOperations): boolean;