@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,27 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+/**
+ * Whether the resolved configuration keeps this directory out of the program.
+ *
+ * Compared by lexical containment rather than by name, so `outDir: "./dist"`
+ * excludes that one directory instead of every directory called `dist` at every
+ * depth, which is the distinction the name list could not draw. The compiler's
+ * case policy governs that containment independently of the supplied filesystem
+ * view's path grammar.
+ *
+ * @evidence contracts/common.md#principled-implementation Directory exclusion delegates lexical configured-path containment under the compiler's comparison policy, with exact matches admitted as excluded directories rather than the strict file-entry exemption.
+ * @evidence contracts/common.md#clear-and-simple-design A named wrapper fixes the non-strict directory interpretation without duplicating containment logic.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A configured output location excludes only its own subtree, not every directory sharing its basename.
+ * @evidence contracts/common.md#meaningful-documentation The native prose names lexical containment and explains the distinction from historical name-only exclusions.
+ * @evidence contracts/portability.md#os-neutral-implementation The explicit filesystem-view platform reaches the containment owner unchanged; native root/separator grammar and compiler case policy remain independent, including the same exact-entry comparison rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixing non-strict interpretation is constant selection, but actual
+ *   containment resolves query text and compares configured component
+ *   populations. Cold policy compilation processes exclusion text; absent
+ *   compiler reports also pay the case-prediction owner's native setup and
+ *   observations. Delegation does not make that query work constant.
+ * @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 isExcludedProjectDirectory(directory: string, policy: ITtscProjectMembershipPolicy, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,27 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * Whether the resolved configuration keeps this directory out of the program.
+ *
+ * Compared by lexical containment rather than by name, so `outDir: "./dist"`
+ * excludes that one directory instead of every directory called `dist` at every
+ * depth, which is the distinction the name list could not draw. The compiler's
+ * case policy governs that containment independently of the supplied filesystem
+ * view's path grammar.
+ *
+ * @evidence contracts/common.md#principled-implementation Directory exclusion delegates lexical configured-path containment under the compiler's comparison policy, with exact matches admitted as excluded directories rather than the strict file-entry exemption.
+ * @evidence contracts/common.md#clear-and-simple-design A named wrapper fixes the non-strict directory interpretation without duplicating containment logic.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A configured output location excludes only its own subtree, not every directory sharing its basename.
+ * @evidence contracts/common.md#meaningful-documentation The native prose names lexical containment and explains the distinction from historical name-only exclusions.
+ * @evidence contracts/portability.md#os-neutral-implementation The explicit filesystem-view platform reaches the containment owner unchanged; native root/separator grammar and compiler case policy remain independent, including the same exact-entry comparison rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixing non-strict interpretation is constant selection, but actual
+ *   containment resolves query text and compares configured component
+ *   populations. Cold policy compilation processes exclusion text; absent
+ *   compiler reports also pay the case-prediction owner's native setup and
+ *   observations. Delegation does not make that query work constant.
+ * @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 isExcludedProjectDirectory(directory: string, policy: ITtscProjectMembershipPolicy, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,35 @@
+'use strict';
+
+var insideExcludedProjectDirectory = require('./insideExcludedProjectDirectory.js');
+
+/**
+ * Whether the resolved configuration keeps this directory out of the program.
+ *
+ * Compared by lexical containment rather than by name, so `outDir: "./dist"`
+ * excludes that one directory instead of every directory called `dist` at every
+ * depth, which is the distinction the name list could not draw. The compiler's
+ * case policy governs that containment independently of the supplied filesystem
+ * view's path grammar.
+ *
+ * @evidence contracts/common.md#principled-implementation Directory exclusion delegates lexical configured-path containment under the compiler's comparison policy, with exact matches admitted as excluded directories rather than the strict file-entry exemption.
+ * @evidence contracts/common.md#clear-and-simple-design A named wrapper fixes the non-strict directory interpretation without duplicating containment logic.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A configured output location excludes only its own subtree, not every directory sharing its basename.
+ * @evidence contracts/common.md#meaningful-documentation The native prose names lexical containment and explains the distinction from historical name-only exclusions.
+ * @evidence contracts/portability.md#os-neutral-implementation The explicit filesystem-view platform reaches the containment owner unchanged; native root/separator grammar and compiler case policy remain independent, including the same exact-entry comparison rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixing non-strict interpretation is constant selection, but actual
+ *   containment resolves query text and compares configured component
+ *   populations. Cold policy compilation processes exclusion text; absent
+ *   compiler reports also pay the case-prediction owner's native setup and
+ *   observations. Delegation does not make that query work constant.
+ * @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 isExcludedProjectDirectory(directory, policy, platform = process.platform) {
+    return insideExcludedProjectDirectory.insideExcludedProjectDirectory(directory, policy, false, platform);
+}
+
+exports.isExcludedProjectDirectory = isExcludedProjectDirectory;
+//# sourceMappingURL=isExcludedProjectDirectory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isExcludedProjectDirectory.js","sources":["../../../../src/core/transform/project/isExcludedProjectDirectory.ts"],"sourcesContent":[null],"names":["insideExcludedProjectDirectory"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,0BAA0B,CACxC,SAAiB,EACjB,MAAoC,EACpC,QAAA,GAA4B,OAAO,CAAC,QAAQ,EAAA;IAE5C,OAAOA,6DAA8B,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC;AAC3E;;;;"}

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

@@ -0,0 +1,33 @@
+import { insideExcludedProjectDirectory } from './insideExcludedProjectDirectory.mjs';
+
+/**
+ * Whether the resolved configuration keeps this directory out of the program.
+ *
+ * Compared by lexical containment rather than by name, so `outDir: "./dist"`
+ * excludes that one directory instead of every directory called `dist` at every
+ * depth, which is the distinction the name list could not draw. The compiler's
+ * case policy governs that containment independently of the supplied filesystem
+ * view's path grammar.
+ *
+ * @evidence contracts/common.md#principled-implementation Directory exclusion delegates lexical configured-path containment under the compiler's comparison policy, with exact matches admitted as excluded directories rather than the strict file-entry exemption.
+ * @evidence contracts/common.md#clear-and-simple-design A named wrapper fixes the non-strict directory interpretation without duplicating containment logic.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A configured output location excludes only its own subtree, not every directory sharing its basename.
+ * @evidence contracts/common.md#meaningful-documentation The native prose names lexical containment and explains the distinction from historical name-only exclusions.
+ * @evidence contracts/portability.md#os-neutral-implementation The explicit filesystem-view platform reaches the containment owner unchanged; native root/separator grammar and compiler case policy remain independent, including the same exact-entry comparison rule.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixing non-strict interpretation is constant selection, but actual
+ *   containment resolves query text and compares configured component
+ *   populations. Cold policy compilation processes exclusion text; absent
+ *   compiler reports also pay the case-prediction owner's native setup and
+ *   observations. Delegation does not make that query work constant.
+ * @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 isExcludedProjectDirectory(directory, policy, platform = process.platform) {
+    return insideExcludedProjectDirectory(directory, policy, false, platform);
+}
+
+export { isExcludedProjectDirectory };
+//# sourceMappingURL=isExcludedProjectDirectory.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isExcludedProjectDirectory.mjs","sources":["../../../../src/core/transform/project/isExcludedProjectDirectory.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,0BAA0B,CACxC,SAAiB,EACjB,MAAoC,EACpC,QAAA,GAA4B,OAAO,CAAC,QAAQ,EAAA;IAE5C,OAAO,8BAA8B,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC;AAC3E;;;;"}

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;;;;"}