@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,26 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * Whether the project walk skips an entry by its name alone.
+ *
+ * Only a policy whose configuration could not be read needs the name list. A
+ * readable one decides every path through TypeScript-Go's own root-file rules,
+ * whose wildcards never enter package folders or hidden paths, so `.git`,
+ * `.ttsc`, and `node_modules` are already outside it, while a literal entry
+ * that names such a directory is honored exactly as TypeScript-Go honors it.
+ * The walk, `isProjectWalkPath`, and the live mutation tracker all ask this one
+ * question, so the three cannot disagree about a path.
+ *
+ * @evidence contracts/common.md#principled-implementation Name-only fallback applies only when root-file rules are absent; a resolved compiler policy retains its own literal and wildcard semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One condition gates the shared fallback predicate, so walkers and event classifiers do not maintain competing ignore lists.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Readable configurations do not lose explicitly admitted hidden or package entries through an unconditional host-name blacklist.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the fallback premise, literal-entry behavior and the shared consumers that require consistent classification.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares an entry name with the ignored-name predicate; no path is parsed.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @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.
+ */
+export declare function isIgnoredProjectEntry(name: string, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,26 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+/**
+ * Whether the project walk skips an entry by its name alone.
+ *
+ * Only a policy whose configuration could not be read needs the name list. A
+ * readable one decides every path through TypeScript-Go's own root-file rules,
+ * whose wildcards never enter package folders or hidden paths, so `.git`,
+ * `.ttsc`, and `node_modules` are already outside it, while a literal entry
+ * that names such a directory is honored exactly as TypeScript-Go honors it.
+ * The walk, `isProjectWalkPath`, and the live mutation tracker all ask this one
+ * question, so the three cannot disagree about a path.
+ *
+ * @evidence contracts/common.md#principled-implementation Name-only fallback applies only when root-file rules are absent; a resolved compiler policy retains its own literal and wildcard semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One condition gates the shared fallback predicate, so walkers and event classifiers do not maintain competing ignore lists.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Readable configurations do not lose explicitly admitted hidden or package entries through an unconditional host-name blacklist.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the fallback premise, literal-entry behavior and the shared consumers that require consistent classification.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares an entry name with the ignored-name predicate; no path is parsed.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @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.
+ */
+export declare function isIgnoredProjectEntry(name: string, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,26 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * Whether the project walk skips an entry by its name alone.
+ *
+ * Only a policy whose configuration could not be read needs the name list. A
+ * readable one decides every path through TypeScript-Go's own root-file rules,
+ * whose wildcards never enter package folders or hidden paths, so `.git`,
+ * `.ttsc`, and `node_modules` are already outside it, while a literal entry
+ * that names such a directory is honored exactly as TypeScript-Go honors it.
+ * The walk, `isProjectWalkPath`, and the live mutation tracker all ask this one
+ * question, so the three cannot disagree about a path.
+ *
+ * @evidence contracts/common.md#principled-implementation Name-only fallback applies only when root-file rules are absent; a resolved compiler policy retains its own literal and wildcard semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One condition gates the shared fallback predicate, so walkers and event classifiers do not maintain competing ignore lists.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Readable configurations do not lose explicitly admitted hidden or package entries through an unconditional host-name blacklist.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the fallback premise, literal-entry behavior and the shared consumers that require consistent classification.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares an entry name with the ignored-name predicate; no path is parsed.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @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.
+ */
+export declare function isIgnoredProjectEntry(name: string, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,34 @@
+'use strict';
+
+var isIgnoredProjectDirectory = require('../../discovery/isIgnoredProjectDirectory.js');
+
+/**
+ * Whether the project walk skips an entry by its name alone.
+ *
+ * Only a policy whose configuration could not be read needs the name list. A
+ * readable one decides every path through TypeScript-Go's own root-file rules,
+ * whose wildcards never enter package folders or hidden paths, so `.git`,
+ * `.ttsc`, and `node_modules` are already outside it, while a literal entry
+ * that names such a directory is honored exactly as TypeScript-Go honors it.
+ * The walk, `isProjectWalkPath`, and the live mutation tracker all ask this one
+ * question, so the three cannot disagree about a path.
+ *
+ * @evidence contracts/common.md#principled-implementation Name-only fallback applies only when root-file rules are absent; a resolved compiler policy retains its own literal and wildcard semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One condition gates the shared fallback predicate, so walkers and event classifiers do not maintain competing ignore lists.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Readable configurations do not lose explicitly admitted hidden or package entries through an unconditional host-name blacklist.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the fallback premise, literal-entry behavior and the shared consumers that require consistent classification.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares an entry name with the ignored-name predicate; no path is parsed.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @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 isIgnoredProjectEntry(name, policy) {
+    return policy.rootFileSpecs === undefined && isIgnoredProjectDirectory.isIgnoredProjectDirectory(name);
+}
+
+exports.isIgnoredProjectEntry = isIgnoredProjectEntry;
+//# sourceMappingURL=isIgnoredProjectEntry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isIgnoredProjectEntry.js","sources":["../../../../src/core/transform/project/isIgnoredProjectEntry.ts"],"sourcesContent":[null],"names":["isIgnoredProjectDirectory"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,qBAAqB,CACnC,IAAY,EACZ,MAAoC,EAAA;IAEpC,OAAO,MAAM,CAAC,aAAa,KAAK,SAAS,IAAIA,mDAAyB,CAAC,IAAI,CAAC;AAC9E;;;;"}

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

@@ -0,0 +1,32 @@
+import { isIgnoredProjectDirectory } from '../../discovery/isIgnoredProjectDirectory.mjs';
+
+/**
+ * Whether the project walk skips an entry by its name alone.
+ *
+ * Only a policy whose configuration could not be read needs the name list. A
+ * readable one decides every path through TypeScript-Go's own root-file rules,
+ * whose wildcards never enter package folders or hidden paths, so `.git`,
+ * `.ttsc`, and `node_modules` are already outside it, while a literal entry
+ * that names such a directory is honored exactly as TypeScript-Go honors it.
+ * The walk, `isProjectWalkPath`, and the live mutation tracker all ask this one
+ * question, so the three cannot disagree about a path.
+ *
+ * @evidence contracts/common.md#principled-implementation Name-only fallback applies only when root-file rules are absent; a resolved compiler policy retains its own literal and wildcard semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One condition gates the shared fallback predicate, so walkers and event classifiers do not maintain competing ignore lists.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Readable configurations do not lose explicitly admitted hidden or package entries through an unconditional host-name blacklist.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the fallback premise, literal-entry behavior and the shared consumers that require consistent classification.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares an entry name with the ignored-name predicate; no path is parsed.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @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 isIgnoredProjectEntry(name, policy) {
+    return policy.rootFileSpecs === undefined && isIgnoredProjectDirectory(name);
+}
+
+export { isIgnoredProjectEntry };
+//# sourceMappingURL=isIgnoredProjectEntry.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isIgnoredProjectEntry.mjs","sources":["../../../../src/core/transform/project/isIgnoredProjectEntry.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,qBAAqB,CACnC,IAAY,EACZ,MAAoC,EAAA;IAEpC,OAAO,MAAM,CAAC,aAAa,KAAK,SAAS,IAAI,yBAAyB,CAAC,IAAI,CAAC;AAC9E;;;;"}

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

@@ -0,0 +1,29 @@
+import type fs from "node:fs";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * Conservatively select entries that can affect the walk's membership digest.
+ *
+ * A directory always could, since it can hold sources. A file could only if it
+ * carries an extension the resolved configuration admits, which is what makes a
+ * bundle emitted beside the sources invisible to a project that compiles no
+ * JavaScript.
+ *
+ * Non-file entries remain possible without proving that the walk follows them.
+ * Directory admission and actual file hashing are separate decisions of the
+ * walk; this predicate only supplies its membership-digest eligibility.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular files use admitted extensions; non-file entries remain conservatively possible because topology can expose future source inputs.
+ * @evidence contracts/common.md#clear-and-simple-design The Dirent wrapper delegates filename policy to the single helper also used by callers without an entry object.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admitted extensions come from the resolved policy rather than fixture-specific emitted-file names.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains future directory membership and why unadmitted emitted JavaScript does not invalidate a TypeScript-only program.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies the already supplied entry-kind observation and bare filename eligibility; it selects no native backend, path grammar or identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Non-file kinds return before allocating normalized filename text. Regular
+ *   files delegate one lowercase allocation and early-terminating suffix scan;
+ *   cost follows filename length and the supplied extension population/text.
+ * @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.
+ */
+export declare function isPossibleProgramEntry(entry: fs.Dirent, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,29 @@
+import type fs from "node:fs";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+/**
+ * Conservatively select entries that can affect the walk's membership digest.
+ *
+ * A directory always could, since it can hold sources. A file could only if it
+ * carries an extension the resolved configuration admits, which is what makes a
+ * bundle emitted beside the sources invisible to a project that compiles no
+ * JavaScript.
+ *
+ * Non-file entries remain possible without proving that the walk follows them.
+ * Directory admission and actual file hashing are separate decisions of the
+ * walk; this predicate only supplies its membership-digest eligibility.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular files use admitted extensions; non-file entries remain conservatively possible because topology can expose future source inputs.
+ * @evidence contracts/common.md#clear-and-simple-design The Dirent wrapper delegates filename policy to the single helper also used by callers without an entry object.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admitted extensions come from the resolved policy rather than fixture-specific emitted-file names.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains future directory membership and why unadmitted emitted JavaScript does not invalidate a TypeScript-only program.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies the already supplied entry-kind observation and bare filename eligibility; it selects no native backend, path grammar or identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Non-file kinds return before allocating normalized filename text. Regular
+ *   files delegate one lowercase allocation and early-terminating suffix scan;
+ *   cost follows filename length and the supplied extension population/text.
+ * @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.
+ */
+export declare function isPossibleProgramEntry(entry: fs.Dirent, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,29 @@
+import type fs from "node:fs";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * Conservatively select entries that can affect the walk's membership digest.
+ *
+ * A directory always could, since it can hold sources. A file could only if it
+ * carries an extension the resolved configuration admits, which is what makes a
+ * bundle emitted beside the sources invisible to a project that compiles no
+ * JavaScript.
+ *
+ * Non-file entries remain possible without proving that the walk follows them.
+ * Directory admission and actual file hashing are separate decisions of the
+ * walk; this predicate only supplies its membership-digest eligibility.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular files use admitted extensions; non-file entries remain conservatively possible because topology can expose future source inputs.
+ * @evidence contracts/common.md#clear-and-simple-design The Dirent wrapper delegates filename policy to the single helper also used by callers without an entry object.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admitted extensions come from the resolved policy rather than fixture-specific emitted-file names.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains future directory membership and why unadmitted emitted JavaScript does not invalidate a TypeScript-only program.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies the already supplied entry-kind observation and bare filename eligibility; it selects no native backend, path grammar or identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Non-file kinds return before allocating normalized filename text. Regular
+ *   files delegate one lowercase allocation and early-terminating suffix scan;
+ *   cost follows filename length and the supplied extension population/text.
+ * @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.
+ */
+export declare function isPossibleProgramEntry(entry: fs.Dirent, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+var isPossibleProgramFileName = require('./isPossibleProgramFileName.js');
+
+/**
+ * Conservatively select entries that can affect the walk's membership digest.
+ *
+ * A directory always could, since it can hold sources. A file could only if it
+ * carries an extension the resolved configuration admits, which is what makes a
+ * bundle emitted beside the sources invisible to a project that compiles no
+ * JavaScript.
+ *
+ * Non-file entries remain possible without proving that the walk follows them.
+ * Directory admission and actual file hashing are separate decisions of the
+ * walk; this predicate only supplies its membership-digest eligibility.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular files use admitted extensions; non-file entries remain conservatively possible because topology can expose future source inputs.
+ * @evidence contracts/common.md#clear-and-simple-design The Dirent wrapper delegates filename policy to the single helper also used by callers without an entry object.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admitted extensions come from the resolved policy rather than fixture-specific emitted-file names.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains future directory membership and why unadmitted emitted JavaScript does not invalidate a TypeScript-only program.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies the already supplied entry-kind observation and bare filename eligibility; it selects no native backend, path grammar or identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Non-file kinds return before allocating normalized filename text. Regular
+ *   files delegate one lowercase allocation and early-terminating suffix scan;
+ *   cost follows filename length and the supplied extension population/text.
+ * @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 isPossibleProgramEntry(entry, policy) {
+    return entry.isFile() ? isPossibleProgramFileName.isPossibleProgramFileName(entry.name, policy) : true;
+}
+
+exports.isPossibleProgramEntry = isPossibleProgramEntry;
+//# sourceMappingURL=isPossibleProgramEntry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPossibleProgramEntry.js","sources":["../../../../src/core/transform/project/isPossibleProgramEntry.ts"],"sourcesContent":[null],"names":["isPossibleProgramFileName"],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,sBAAsB,CACpC,KAAgB,EAChB,MAAoC,EAAA;AAEpC,IAAA,OAAO,KAAK,CAAC,MAAM,EAAE,GAAGA,mDAAyB,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI;AAC9E;;;;"}

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

@@ -0,0 +1,34 @@
+import { isPossibleProgramFileName } from './isPossibleProgramFileName.mjs';
+
+/**
+ * Conservatively select entries that can affect the walk's membership digest.
+ *
+ * A directory always could, since it can hold sources. A file could only if it
+ * carries an extension the resolved configuration admits, which is what makes a
+ * bundle emitted beside the sources invisible to a project that compiles no
+ * JavaScript.
+ *
+ * Non-file entries remain possible without proving that the walk follows them.
+ * Directory admission and actual file hashing are separate decisions of the
+ * walk; this predicate only supplies its membership-digest eligibility.
+ *
+ * @evidence contracts/common.md#principled-implementation Regular files use admitted extensions; non-file entries remain conservatively possible because topology can expose future source inputs.
+ * @evidence contracts/common.md#clear-and-simple-design The Dirent wrapper delegates filename policy to the single helper also used by callers without an entry object.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Admitted extensions come from the resolved policy rather than fixture-specific emitted-file names.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains future directory membership and why unadmitted emitted JavaScript does not invalidate a TypeScript-only program.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies the already supplied entry-kind observation and bare filename eligibility; it selects no native backend, path grammar or identity policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Non-file kinds return before allocating normalized filename text. Regular
+ *   files delegate one lowercase allocation and early-terminating suffix scan;
+ *   cost follows filename length and the supplied extension population/text.
+ * @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 isPossibleProgramEntry(entry, policy) {
+    return entry.isFile() ? isPossibleProgramFileName(entry.name, policy) : true;
+}
+
+export { isPossibleProgramEntry };
+//# sourceMappingURL=isPossibleProgramEntry.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPossibleProgramEntry.mjs","sources":["../../../../src/core/transform/project/isPossibleProgramEntry.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,sBAAsB,CACpC,KAAgB,EAChB,MAAoC,EAAA;AAEpC,IAAA,OAAO,KAAK,CAAC,MAAM,EAAE,GAAG,yBAAyB,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI;AAC9E;;;;"}

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

@@ -0,0 +1,20 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * Whether a bare filename has an extension admitted by the project policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Case-normalized suffix matching applies the policy's admitted extension list; this is an eligibility approximation, not filesystem path identity.
+ * @evidence contracts/common.md#clear-and-simple-design One lowercased name and an early-terminating suffix scan represent the extension rule without performing filesystem work.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate uses compiler-derived extension policy rather than selected test filenames or bundler output-directory exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states the bare-name input and policy boundary, avoiding an ambiguous reference to another helper's question.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares a lowercased basename suffix with the policy's extensions; it reads no filesystem.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Lowercasing scans the filename and allocates its normalized text once.
+ *   The early-terminating scan checks the supplied extension population, with
+ *   suffix comparison cost following the extension text. No filename or
+ *   extension index is rebuilt inside the scan.
+ * @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.
+ */
+export declare function isPossibleProgramFileName(name: string, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,20 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+/**
+ * Whether a bare filename has an extension admitted by the project policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Case-normalized suffix matching applies the policy's admitted extension list; this is an eligibility approximation, not filesystem path identity.
+ * @evidence contracts/common.md#clear-and-simple-design One lowercased name and an early-terminating suffix scan represent the extension rule without performing filesystem work.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate uses compiler-derived extension policy rather than selected test filenames or bundler output-directory exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states the bare-name input and policy boundary, avoiding an ambiguous reference to another helper's question.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares a lowercased basename suffix with the policy's extensions; it reads no filesystem.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Lowercasing scans the filename and allocates its normalized text once.
+ *   The early-terminating scan checks the supplied extension population, with
+ *   suffix comparison cost following the extension text. No filename or
+ *   extension index is rebuilt inside the scan.
+ * @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.
+ */
+export declare function isPossibleProgramFileName(name: string, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,20 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * Whether a bare filename has an extension admitted by the project policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Case-normalized suffix matching applies the policy's admitted extension list; this is an eligibility approximation, not filesystem path identity.
+ * @evidence contracts/common.md#clear-and-simple-design One lowercased name and an early-terminating suffix scan represent the extension rule without performing filesystem work.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate uses compiler-derived extension policy rather than selected test filenames or bundler output-directory exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states the bare-name input and policy boundary, avoiding an ambiguous reference to another helper's question.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares a lowercased basename suffix with the policy's extensions; it reads no filesystem.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Lowercasing scans the filename and allocates its normalized text once.
+ *   The early-terminating scan checks the supplied extension population, with
+ *   suffix comparison cost following the extension text. No filename or
+ *   extension index is rebuilt inside the scan.
+ * @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.
+ */
+export declare function isPossibleProgramFileName(name: string, policy: ITtscProjectMembershipPolicy): boolean;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Whether a bare filename has an extension admitted by the project policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Case-normalized suffix matching applies the policy's admitted extension list; this is an eligibility approximation, not filesystem path identity.
+ * @evidence contracts/common.md#clear-and-simple-design One lowercased name and an early-terminating suffix scan represent the extension rule without performing filesystem work.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate uses compiler-derived extension policy rather than selected test filenames or bundler output-directory exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states the bare-name input and policy boundary, avoiding an ambiguous reference to another helper's question.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares a lowercased basename suffix with the policy's extensions; it reads no filesystem.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Lowercasing scans the filename and allocates its normalized text once.
+ *   The early-terminating scan checks the supplied extension population, with
+ *   suffix comparison cost following the extension text. No filename or
+ *   extension index is rebuilt inside the scan.
+ * @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 isPossibleProgramFileName(name, policy) {
+    const lowered = name.toLowerCase();
+    return policy.inputExtensions.some((extension) => lowered.endsWith(extension));
+}
+
+exports.isPossibleProgramFileName = isPossibleProgramFileName;
+//# sourceMappingURL=isPossibleProgramFileName.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPossibleProgramFileName.js","sources":["../../../../src/core/transform/project/isPossibleProgramFileName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG,SAAU,yBAAyB,CACvC,IAAY,EACZ,MAAoC,EAAA;AAEpC,IAAA,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE;AAClC,IAAA,OAAO,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,SAAS,KAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAC5B;AACH;;;;"}

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

@@ -0,0 +1,25 @@
+/**
+ * Whether a bare filename has an extension admitted by the project policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Case-normalized suffix matching applies the policy's admitted extension list; this is an eligibility approximation, not filesystem path identity.
+ * @evidence contracts/common.md#clear-and-simple-design One lowercased name and an early-terminating suffix scan represent the extension rule without performing filesystem work.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The predicate uses compiler-derived extension policy rather than selected test filenames or bundler output-directory exceptions.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states the bare-name input and policy boundary, avoiding an ambiguous reference to another helper's question.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares a lowercased basename suffix with the policy's extensions; it reads no filesystem.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Lowercasing scans the filename and allocates its normalized text once.
+ *   The early-terminating scan checks the supplied extension population, with
+ *   suffix comparison cost following the extension text. No filename or
+ *   extension index is rebuilt inside the scan.
+ * @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 isPossibleProgramFileName(name, policy) {
+    const lowered = name.toLowerCase();
+    return policy.inputExtensions.some((extension) => lowered.endsWith(extension));
+}
+
+export { isPossibleProgramFileName };
+//# sourceMappingURL=isPossibleProgramFileName.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPossibleProgramFileName.mjs","sources":["../../../../src/core/transform/project/isPossibleProgramFileName.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG,SAAU,yBAAyB,CACvC,IAAY,EACZ,MAAoC,EAAA;AAEpC,IAAA,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE;AAClC,IAAA,OAAO,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,SAAS,KAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAC5B;AACH;;;;"}

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

@@ -0,0 +1,29 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * 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.
+ */
+export declare function isProjectWalkDirectory(directory: string, policy: ITtscProjectMembershipPolicy, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,29 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.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.
+ */
+export declare function isProjectWalkDirectory(directory: string, policy: ITtscProjectMembershipPolicy, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,29 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * 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.
+ */
+export declare function isProjectWalkDirectory(directory: string, policy: ITtscProjectMembershipPolicy, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+var path = require('node:path');
+var matchesProjectRootFile = require('../../tsconfig/matchesProjectRootFile.js');
+var isExcludedProjectDirectory = require('./isExcludedProjectDirectory.js');
+var isIgnoredProjectEntry = require('./isIgnoredProjectEntry.js');
+
+/**
+ * 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.isIgnoredProjectEntry(pathApi.basename(directory), policy) &&
+        !isExcludedProjectDirectory.isExcludedProjectDirectory(directory, policy, platform) &&
+        matchesProjectRootFile.matchesProjectRootFile(directory, policy, true, platform));
+}
+
+exports.isProjectWalkDirectory = isProjectWalkDirectory;
+//# sourceMappingURL=isProjectWalkDirectory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isProjectWalkDirectory.js","sources":["../../../../src/core/transform/project/isProjectWalkDirectory.ts"],"sourcesContent":[null],"names":["isIgnoredProjectEntry","isExcludedProjectDirectory","matchesProjectRootFile"],"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,CAACA,2CAAqB,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;AAC3D,QAAA,CAACC,qDAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC;QACxDC,6CAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC;AAE7D;;;;"}