@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,144 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { inputMetadataEvidence } from '../inputs/inputMetadataEvidence.mjs';
+import { hashText } from '../utils/hashText.mjs';
+import { toProjectKey } from './toProjectKey.mjs';
+import { walkProjectInputs } from './walkProjectInputs.mjs';
+
+/**
+ * Hash project files and snapshot directory topology in one walk.
+ *
+ * Reuse a recorded hash only when separable metadata still matches its proven
+ * signature. Reads are bracketed by metadata observations; unavailable or
+ * changed signatures mark the snapshot incomplete instead of hiding that
+ * observed instability. A validating caller may restrict hashing to its
+ * declared keys while retaining the whole membership walk. The caller owns the
+ * identity observation lifetime and refreshes native clock references before
+ * relying on separability; this collector does not mint them.
+ *
+ * @evidence contracts/common.md#principled-implementation The snapshot separates directory completeness, file-read stability and attributable failures; only matching separable metadata substitutes for the content read that established a prior hash.
+ * @evidence contracts/common.md#clear-and-simple-design One walk feeds one file pass, with shared metadata and key helpers owning their respective boundaries; returned sets preserve which proof obligations failed.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable or changing files mark incompleteness rather than yielding successful partial hashes, and declared-key filtering does not suppress directory membership proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain metadata-authorized reuse and declared-key restriction; inline comments justify clock separation and failure attribution without mirroring trivial assignments.
+ * @evidence contracts/portability.md#os-neutral-implementation Enumeration and reads use the supplied native filesystem view; identity keys share its case/link policy, and bigint metadata plus filesystem clock separation avoid assuming one timestamp precision on every platform.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation returns caller-owned proof collections and opens no retained handle; generation retention belongs to the consuming cache owner.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   The full membership walk precedes one admitted-file pass. Native project-key
+ *   resolution is required even for a file later excluded by declared keys;
+ *   selected files add metadata/path/bigint formatting and uncached identity
+ *   observations. Qualified hashes skip byte reads; other inputs read/hash B
+ *   bytes and recapture metadata. Walk sorting, directory/entry storage, digest
+ *   text, file proof records and copied failures contribute their populations;
+ *   declared filtering bounds selected reads, not the full walk or its outputs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Proven hashes replace content reads only when the same key retains a matching separable metadata signature; absent or nonseparable evidence forces a fresh bracketed read and clock authority is rechecked.
+ */
+function collectProjectInputSnapshot(
+/** Lexical root whose native membership is fully enumerated. */
+projectRoot, 
+/**
+ * Caller-owned identity context with an appropriate current observation
+ * lifetime.
+ */
+identities, 
+/** Coherent native read/metadata/listing view used by the entire snapshot. */
+filesystem = DEFAULT_FILESYSTEM_OPERATIONS, 
+/**
+ * Prior readable hashes and witnesses qualified against the caller-refreshed
+ * clock.
+ */
+proven, options) {
+    const hashes = {};
+    const notificationUnsafeInputs = new Set();
+    const fileSignatures = {};
+    const provenSignatures = {};
+    const unstableFiles = new Set();
+    let attributed = true;
+    const walked = walkProjectInputs(projectRoot, filesystem, options?.policy);
+    const walkFailures = [...walked.failures];
+    let complete = walked.complete;
+    for (const file of walked.files) {
+        try {
+            const key = toProjectKey(projectRoot, file, identities);
+            // A caller validating a generation compares hashes over that
+            // generation's declared inputs alone (`sameHashes` takes the declared key
+            // set), so reading anything else is work whose result is never consulted.
+            // Skipping it is what keeps a directory full of emitted files from
+            // costing a read per file on the pass that first sees them
+            // (samchon/ttsc#1307). Capture passes supply no restriction and still
+            // record the whole walk.
+            if (options?.declaredKeys !== undefined &&
+                !options.declaredKeys.has(key)) {
+                continue;
+            }
+            const before = inputMetadataEvidence(file, filesystem);
+            if (before?.notificationAuthoritative !== true) {
+                notificationUnsafeInputs.add(key);
+            }
+            // A file whose signature still equals the one captured around the read
+            // that produced the recorded hash carries that content, so the whole
+            // project does not have to be re-read to prove one delivery. Recheck the
+            // clock ordering as well: rollback can make a formerly safe floor unable
+            // to answer for a new write (samchon/ttsc#1344).
+            if (before !== undefined &&
+                before.separable &&
+                proven !== undefined &&
+                proven.signatures[key] === before.signature &&
+                Object.prototype.hasOwnProperty.call(proven.hashes, key)) {
+                hashes[key] = proven.hashes[key];
+                fileSignatures[key] = before.signature;
+                provenSignatures[key] = before.signature;
+                continue;
+            }
+            const contents = filesystem.readFile(file);
+            const after = inputMetadataEvidence(file, filesystem);
+            if (after?.notificationAuthoritative !== true) {
+                notificationUnsafeInputs.add(key);
+            }
+            hashes[key] = hashText(contents);
+            if (before === undefined ||
+                after === undefined ||
+                before.signature !== after.signature) {
+                complete = false;
+                unstableFiles.add(key);
+                walkFailures.push({ kind: "file-changed-during-read", path: file });
+            }
+            else {
+                fileSignatures[key] = after.signature;
+                // Only a signature whose stamp's tick the filesystem's clock provably
+                // left before this read may later stand in for the content comparison
+                // (`stampSeparable`); the raw signature above still participates
+                // in the generation-time stability comparison.
+                if (before.separable) {
+                    provenSignatures[key] = after.signature;
+                }
+            }
+        }
+        catch {
+            // File watchers may observe a transform while another process is moving
+            // or deleting files. The missing key invalidates older cache entries.
+            complete = false;
+            walkFailures.push({ kind: "file-read-failed", path: file });
+            try {
+                unstableFiles.add(toProjectKey(projectRoot, file, identities));
+            }
+            catch {
+                // Without a key the failure cannot be attributed, so it keeps the
+                // whole snapshot incomplete rather than being scoped away.
+                attributed = false;
+            }
+        }
+    }
+    return {
+        complete,
+        directoryComplete: walked.complete && attributed,
+        fileSignatures,
+        hashes,
+        notificationUnsafeInputs,
+        projectDirectories: walked.directories,
+        provenSignatures,
+        unstableFiles,
+        walkFailures,
+    };
+}
+
+export { collectProjectInputSnapshot };
+//# sourceMappingURL=collectProjectInputSnapshot.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectProjectInputSnapshot.mjs","sources":["../../../../src/core/transform/project/collectProjectInputSnapshot.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

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

@@ -0,0 +1,35 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * Whether a path lies inside a directory the configuration excludes.
+ *
+ * Lexical, exactly like the walk and like `isProjectWalkPath`, and for the
+ * reason that predicate states: walk membership is lexical, so resolving a path
+ * to physical identity first would collapse two spellings the walk keeps apart
+ * and claim it covered a subtree it never followed. A junction whose target the
+ * walk hashes under its own name is exactly that, and canonicalizing here would
+ * suppress every event in it.
+ *
+ * `strictly` excludes an exact match, for the case where the excluded entry
+ * names a file rather than a directory: `exclude` accepts one, the walk applies
+ * exclusion to directories alone, so that file is still hashed and its events
+ * must keep counting.
+ *
+ * Path resolution follows the supplied filesystem view, while component
+ * equality follows the compiler's comparison policy. Neither Node's Windows
+ * case-insensitive containment nor a POSIX case-sensitive comparison can
+ * substitute for that independent policy. Literal components also retain
+ * Unicode simple folding, without turning configured names into glob patterns.
+ * Before a compiler report supplies the case answer, the existing prediction
+ * owner may set up and observe its selected native compiler-cache root. This
+ * predicate does not replace that owner's approximation or cache lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Native lexical components compare configured excluded locations under the compiler's case policy without collapsing symlink spellings; strict mode exempts the exact entry under that same policy so directory-only exclusion does not misclassify a file.
+ * @evidence contracts/common.md#clear-and-simple-design An empty-policy fast path and one literal-component prefix scan keep grammar selection, compiler comparison and strict exact-entry handling explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusion follows actual configured locations rather than generic directory-name exceptions or physical normalization that erases unwalked aliases.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical walk membership, exact-file exemption and why compiler comparison policy is independent of native path grammar.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit view-platform Node resolution and native component separators retain root, drive and UNC boundaries; compiler-reported or predicted case policy governs exact and descendant comparison, including Unicode simple folding, without resolving links.
+ * @evidence contracts/performance.md#efficient-algorithms Resolves and splits the queried path once, then short-circuits component prefixes across the configured exclusions. Cold compilation scans excluded path text and escapes literal components; warm component work follows exclusion component/text population, with query components temporary and no glob state expansion. A reported case flag is direct data; otherwise the prediction owner additionally performs native cache-root setup/observations and shares its physical-root answer under its documented assumptions.
+ * @evidence contracts/performance.md#reuse-equivalent-work A WeakMap shares compiled absolute exclusion components for the same immutable policy, selected native grammar and current compiler case answer. Changed configuration replaces the policy; a changed predicted answer selects a separate entry rather than trusting an old comparison policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Weak policy keys do not retain discarded configurations. Each live policy retains at most two grammars times two case answers, with component strings/expressions driven by its exclusion text; per-query components expire on return and no native handle is acquired.
+ */
+export declare function insideExcludedProjectDirectory(location: string, policy: ITtscProjectMembershipPolicy, strictly: boolean, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,35 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+/**
+ * Whether a path lies inside a directory the configuration excludes.
+ *
+ * Lexical, exactly like the walk and like `isProjectWalkPath`, and for the
+ * reason that predicate states: walk membership is lexical, so resolving a path
+ * to physical identity first would collapse two spellings the walk keeps apart
+ * and claim it covered a subtree it never followed. A junction whose target the
+ * walk hashes under its own name is exactly that, and canonicalizing here would
+ * suppress every event in it.
+ *
+ * `strictly` excludes an exact match, for the case where the excluded entry
+ * names a file rather than a directory: `exclude` accepts one, the walk applies
+ * exclusion to directories alone, so that file is still hashed and its events
+ * must keep counting.
+ *
+ * Path resolution follows the supplied filesystem view, while component
+ * equality follows the compiler's comparison policy. Neither Node's Windows
+ * case-insensitive containment nor a POSIX case-sensitive comparison can
+ * substitute for that independent policy. Literal components also retain
+ * Unicode simple folding, without turning configured names into glob patterns.
+ * Before a compiler report supplies the case answer, the existing prediction
+ * owner may set up and observe its selected native compiler-cache root. This
+ * predicate does not replace that owner's approximation or cache lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Native lexical components compare configured excluded locations under the compiler's case policy without collapsing symlink spellings; strict mode exempts the exact entry under that same policy so directory-only exclusion does not misclassify a file.
+ * @evidence contracts/common.md#clear-and-simple-design An empty-policy fast path and one literal-component prefix scan keep grammar selection, compiler comparison and strict exact-entry handling explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusion follows actual configured locations rather than generic directory-name exceptions or physical normalization that erases unwalked aliases.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical walk membership, exact-file exemption and why compiler comparison policy is independent of native path grammar.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit view-platform Node resolution and native component separators retain root, drive and UNC boundaries; compiler-reported or predicted case policy governs exact and descendant comparison, including Unicode simple folding, without resolving links.
+ * @evidence contracts/performance.md#efficient-algorithms Resolves and splits the queried path once, then short-circuits component prefixes across the configured exclusions. Cold compilation scans excluded path text and escapes literal components; warm component work follows exclusion component/text population, with query components temporary and no glob state expansion. A reported case flag is direct data; otherwise the prediction owner additionally performs native cache-root setup/observations and shares its physical-root answer under its documented assumptions.
+ * @evidence contracts/performance.md#reuse-equivalent-work A WeakMap shares compiled absolute exclusion components for the same immutable policy, selected native grammar and current compiler case answer. Changed configuration replaces the policy; a changed predicted answer selects a separate entry rather than trusting an old comparison policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Weak policy keys do not retain discarded configurations. Each live policy retains at most two grammars times two case answers, with component strings/expressions driven by its exclusion text; per-query components expire on return and no native handle is acquired.
+ */
+export declare function insideExcludedProjectDirectory(location: string, policy: ITtscProjectMembershipPolicy, strictly: boolean, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,35 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * Whether a path lies inside a directory the configuration excludes.
+ *
+ * Lexical, exactly like the walk and like `isProjectWalkPath`, and for the
+ * reason that predicate states: walk membership is lexical, so resolving a path
+ * to physical identity first would collapse two spellings the walk keeps apart
+ * and claim it covered a subtree it never followed. A junction whose target the
+ * walk hashes under its own name is exactly that, and canonicalizing here would
+ * suppress every event in it.
+ *
+ * `strictly` excludes an exact match, for the case where the excluded entry
+ * names a file rather than a directory: `exclude` accepts one, the walk applies
+ * exclusion to directories alone, so that file is still hashed and its events
+ * must keep counting.
+ *
+ * Path resolution follows the supplied filesystem view, while component
+ * equality follows the compiler's comparison policy. Neither Node's Windows
+ * case-insensitive containment nor a POSIX case-sensitive comparison can
+ * substitute for that independent policy. Literal components also retain
+ * Unicode simple folding, without turning configured names into glob patterns.
+ * Before a compiler report supplies the case answer, the existing prediction
+ * owner may set up and observe its selected native compiler-cache root. This
+ * predicate does not replace that owner's approximation or cache lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Native lexical components compare configured excluded locations under the compiler's case policy without collapsing symlink spellings; strict mode exempts the exact entry under that same policy so directory-only exclusion does not misclassify a file.
+ * @evidence contracts/common.md#clear-and-simple-design An empty-policy fast path and one literal-component prefix scan keep grammar selection, compiler comparison and strict exact-entry handling explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusion follows actual configured locations rather than generic directory-name exceptions or physical normalization that erases unwalked aliases.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical walk membership, exact-file exemption and why compiler comparison policy is independent of native path grammar.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit view-platform Node resolution and native component separators retain root, drive and UNC boundaries; compiler-reported or predicted case policy governs exact and descendant comparison, including Unicode simple folding, without resolving links.
+ * @evidence contracts/performance.md#efficient-algorithms Resolves and splits the queried path once, then short-circuits component prefixes across the configured exclusions. Cold compilation scans excluded path text and escapes literal components; warm component work follows exclusion component/text population, with query components temporary and no glob state expansion. A reported case flag is direct data; otherwise the prediction owner additionally performs native cache-root setup/observations and shares its physical-root answer under its documented assumptions.
+ * @evidence contracts/performance.md#reuse-equivalent-work A WeakMap shares compiled absolute exclusion components for the same immutable policy, selected native grammar and current compiler case answer. Changed configuration replaces the policy; a changed predicted answer selects a separate entry rather than trusting an old comparison policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Weak policy keys do not retain discarded configurations. Each live policy retains at most two grammars times two case answers, with component strings/expressions driven by its exclusion text; per-query components expire on return and no native handle is acquired.
+ */
+export declare function insideExcludedProjectDirectory(location: string, policy: ITtscProjectMembershipPolicy, strictly: boolean, platform?: NodeJS.Platform): boolean;

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

@@ -0,0 +1,78 @@
+'use strict';
+
+var path = require('node:path');
+var policyUsesCaseSensitiveFileNames = require('../../tsconfig/policyUsesCaseSensitiveFileNames.js');
+
+/**
+ * Whether a path lies inside a directory the configuration excludes.
+ *
+ * Lexical, exactly like the walk and like `isProjectWalkPath`, and for the
+ * reason that predicate states: walk membership is lexical, so resolving a path
+ * to physical identity first would collapse two spellings the walk keeps apart
+ * and claim it covered a subtree it never followed. A junction whose target the
+ * walk hashes under its own name is exactly that, and canonicalizing here would
+ * suppress every event in it.
+ *
+ * `strictly` excludes an exact match, for the case where the excluded entry
+ * names a file rather than a directory: `exclude` accepts one, the walk applies
+ * exclusion to directories alone, so that file is still hashed and its events
+ * must keep counting.
+ *
+ * Path resolution follows the supplied filesystem view, while component
+ * equality follows the compiler's comparison policy. Neither Node's Windows
+ * case-insensitive containment nor a POSIX case-sensitive comparison can
+ * substitute for that independent policy. Literal components also retain
+ * Unicode simple folding, without turning configured names into glob patterns.
+ * Before a compiler report supplies the case answer, the existing prediction
+ * owner may set up and observe its selected native compiler-cache root. This
+ * predicate does not replace that owner's approximation or cache lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Native lexical components compare configured excluded locations under the compiler's case policy without collapsing symlink spellings; strict mode exempts the exact entry under that same policy so directory-only exclusion does not misclassify a file.
+ * @evidence contracts/common.md#clear-and-simple-design An empty-policy fast path and one literal-component prefix scan keep grammar selection, compiler comparison and strict exact-entry handling explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusion follows actual configured locations rather than generic directory-name exceptions or physical normalization that erases unwalked aliases.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical walk membership, exact-file exemption and why compiler comparison policy is independent of native path grammar.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit view-platform Node resolution and native component separators retain root, drive and UNC boundaries; compiler-reported or predicted case policy governs exact and descendant comparison, including Unicode simple folding, without resolving links.
+ * @evidence contracts/performance.md#efficient-algorithms Resolves and splits the queried path once, then short-circuits component prefixes across the configured exclusions. Cold compilation scans excluded path text and escapes literal components; warm component work follows exclusion component/text population, with query components temporary and no glob state expansion. A reported case flag is direct data; otherwise the prediction owner additionally performs native cache-root setup/observations and shares its physical-root answer under its documented assumptions.
+ * @evidence contracts/performance.md#reuse-equivalent-work A WeakMap shares compiled absolute exclusion components for the same immutable policy, selected native grammar and current compiler case answer. Changed configuration replaces the policy; a changed predicted answer selects a separate entry rather than trusting an old comparison policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Weak policy keys do not retain discarded configurations. Each live policy retains at most two grammars times two case answers, with component strings/expressions driven by its exclusion text; per-query components expire on return and no native handle is acquired.
+ */
+function insideExcludedProjectDirectory(location, policy, strictly, platform = process.platform) {
+    if (policy.excludedDirectories.length === 0) {
+        return false;
+    }
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    const resolved = pathApi.resolve(location);
+    const parts = (resolved.endsWith(pathApi.sep) ? resolved.slice(0, -1) : resolved).split(pathApi.sep);
+    const caseSensitive = policyUsesCaseSensitiveFileNames.policyUsesCaseSensitiveFileNames(policy);
+    const key = `${platform === "win32" ? "win32" : "posix"}:${caseSensitive}`;
+    let byComparison = compiled.get(policy);
+    if (byComparison === undefined) {
+        byComparison = new Map();
+        compiled.set(policy, byComparison);
+    }
+    let patterns = byComparison.get(key);
+    if (patterns === undefined) {
+        patterns = policy.excludedDirectories.map((excluded) => {
+            const target = pathApi.resolve(excluded);
+            return (target.endsWith(pathApi.sep) ? target.slice(0, -1) : target)
+                .split(pathApi.sep)
+                .map((part) => caseSensitive
+                ? part
+                : new RegExp(`^${part.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")}(?![\\s\\S])`, "iu"));
+        });
+        byComparison.set(key, patterns);
+    }
+    return patterns.some((components) => {
+        if (components.length > parts.length ||
+            (strictly && components.length === parts.length))
+            return false;
+        return components.every((component, index) => typeof component === "string"
+            ? component === parts[index]
+            : component.test(parts[index]));
+    });
+}
+/** Literal exclusion components owned weakly by immutable membership policy. */
+const compiled = new WeakMap();
+
+exports.insideExcludedProjectDirectory = insideExcludedProjectDirectory;
+//# sourceMappingURL=insideExcludedProjectDirectory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insideExcludedProjectDirectory.js","sources":["../../../../src/core/transform/project/insideExcludedProjectDirectory.ts"],"sourcesContent":[null],"names":["policyUsesCaseSensitiveFileNames"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACG,SAAU,8BAA8B,CAC5C,QAAgB,EAChB,MAAoC,EACpC,QAAiB,EACjB,QAAA,GAA4B,OAAO,CAAC,QAAQ,EAAA;IAE5C,IAAI,MAAM,CAAC,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE;AAC3C,QAAA,OAAO,KAAK;IACd;AACA,IAAA,MAAM,OAAO,GAAG,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;IAC9D,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;AAC1C,IAAA,MAAM,KAAK,GAAG,CACZ,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,QAAQ,EACjE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;AACpB,IAAA,MAAM,aAAa,GAAGA,iEAAgC,CAAC,MAAM,CAAC;AAC9D,IAAA,MAAM,GAAG,GAAG,CAAA,EAAG,QAAQ,KAAK,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA,CAAA,EAAI,aAAa,EAAE;IAC1E,IAAI,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC;AACvC,IAAA,IAAI,YAAY,KAAK,SAAS,EAAE;AAC9B,QAAA,YAAY,GAAG,IAAI,GAAG,EAAE;AACxB,QAAA,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC;IACpC;IACA,IAAI,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC;AACpC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,QAAQ,GAAG,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,QAAQ,KAAI;YACrD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;YACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM;AAChE,iBAAA,KAAK,CAAC,OAAO,CAAC,GAAG;AACjB,iBAAA,GAAG,CAAC,CAAC,IAAI,KACR;AACE,kBAAE;AACF,kBAAE,IAAI,MAAM,CACR,CAAA,CAAA,EAAI,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAA,YAAA,CAAc,EAC7D,IAAI,CACL,CACN;AACL,QAAA,CAAC,CAAC;AACF,QAAA,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC;IACjC;AACA,IAAA,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,UAAU,KAAI;AAClC,QAAA,IACE,UAAU,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM;aAC/B,QAAQ,IAAI,UAAU,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC;AAEhD,YAAA,OAAO,KAAK;AACd,QAAA,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,KAAK,KACvC,OAAO,SAAS,KAAK;AACnB,cAAE,SAAS,KAAK,KAAK,CAAC,KAAK;cACzB,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAE,CAAC,CAClC;AACH,IAAA,CAAC,CAAC;AACJ;AAEA;AACA,MAAM,QAAQ,GAAG,IAAI,OAAO,EAGzB;;;;"}

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

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { policyUsesCaseSensitiveFileNames } from '../../tsconfig/policyUsesCaseSensitiveFileNames.mjs';
+
+/**
+ * Whether a path lies inside a directory the configuration excludes.
+ *
+ * Lexical, exactly like the walk and like `isProjectWalkPath`, and for the
+ * reason that predicate states: walk membership is lexical, so resolving a path
+ * to physical identity first would collapse two spellings the walk keeps apart
+ * and claim it covered a subtree it never followed. A junction whose target the
+ * walk hashes under its own name is exactly that, and canonicalizing here would
+ * suppress every event in it.
+ *
+ * `strictly` excludes an exact match, for the case where the excluded entry
+ * names a file rather than a directory: `exclude` accepts one, the walk applies
+ * exclusion to directories alone, so that file is still hashed and its events
+ * must keep counting.
+ *
+ * Path resolution follows the supplied filesystem view, while component
+ * equality follows the compiler's comparison policy. Neither Node's Windows
+ * case-insensitive containment nor a POSIX case-sensitive comparison can
+ * substitute for that independent policy. Literal components also retain
+ * Unicode simple folding, without turning configured names into glob patterns.
+ * Before a compiler report supplies the case answer, the existing prediction
+ * owner may set up and observe its selected native compiler-cache root. This
+ * predicate does not replace that owner's approximation or cache lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Native lexical components compare configured excluded locations under the compiler's case policy without collapsing symlink spellings; strict mode exempts the exact entry under that same policy so directory-only exclusion does not misclassify a file.
+ * @evidence contracts/common.md#clear-and-simple-design An empty-policy fast path and one literal-component prefix scan keep grammar selection, compiler comparison and strict exact-entry handling explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusion follows actual configured locations rather than generic directory-name exceptions or physical normalization that erases unwalked aliases.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical walk membership, exact-file exemption and why compiler comparison policy is independent of native path grammar.
+ * @evidence contracts/portability.md#os-neutral-implementation Explicit view-platform Node resolution and native component separators retain root, drive and UNC boundaries; compiler-reported or predicted case policy governs exact and descendant comparison, including Unicode simple folding, without resolving links.
+ * @evidence contracts/performance.md#efficient-algorithms Resolves and splits the queried path once, then short-circuits component prefixes across the configured exclusions. Cold compilation scans excluded path text and escapes literal components; warm component work follows exclusion component/text population, with query components temporary and no glob state expansion. A reported case flag is direct data; otherwise the prediction owner additionally performs native cache-root setup/observations and shares its physical-root answer under its documented assumptions.
+ * @evidence contracts/performance.md#reuse-equivalent-work A WeakMap shares compiled absolute exclusion components for the same immutable policy, selected native grammar and current compiler case answer. Changed configuration replaces the policy; a changed predicted answer selects a separate entry rather than trusting an old comparison policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Weak policy keys do not retain discarded configurations. Each live policy retains at most two grammars times two case answers, with component strings/expressions driven by its exclusion text; per-query components expire on return and no native handle is acquired.
+ */
+function insideExcludedProjectDirectory(location, policy, strictly, platform = process.platform) {
+    if (policy.excludedDirectories.length === 0) {
+        return false;
+    }
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    const resolved = pathApi.resolve(location);
+    const parts = (resolved.endsWith(pathApi.sep) ? resolved.slice(0, -1) : resolved).split(pathApi.sep);
+    const caseSensitive = policyUsesCaseSensitiveFileNames(policy);
+    const key = `${platform === "win32" ? "win32" : "posix"}:${caseSensitive}`;
+    let byComparison = compiled.get(policy);
+    if (byComparison === undefined) {
+        byComparison = new Map();
+        compiled.set(policy, byComparison);
+    }
+    let patterns = byComparison.get(key);
+    if (patterns === undefined) {
+        patterns = policy.excludedDirectories.map((excluded) => {
+            const target = pathApi.resolve(excluded);
+            return (target.endsWith(pathApi.sep) ? target.slice(0, -1) : target)
+                .split(pathApi.sep)
+                .map((part) => caseSensitive
+                ? part
+                : new RegExp(`^${part.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")}(?![\\s\\S])`, "iu"));
+        });
+        byComparison.set(key, patterns);
+    }
+    return patterns.some((components) => {
+        if (components.length > parts.length ||
+            (strictly && components.length === parts.length))
+            return false;
+        return components.every((component, index) => typeof component === "string"
+            ? component === parts[index]
+            : component.test(parts[index]));
+    });
+}
+/** Literal exclusion components owned weakly by immutable membership policy. */
+const compiled = new WeakMap();
+
+export { insideExcludedProjectDirectory };
+//# sourceMappingURL=insideExcludedProjectDirectory.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insideExcludedProjectDirectory.mjs","sources":["../../../../src/core/transform/project/insideExcludedProjectDirectory.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACG,SAAU,8BAA8B,CAC5C,QAAgB,EAChB,MAAoC,EACpC,QAAiB,EACjB,QAAA,GAA4B,OAAO,CAAC,QAAQ,EAAA;IAE5C,IAAI,MAAM,CAAC,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE;AAC3C,QAAA,OAAO,KAAK;IACd;AACA,IAAA,MAAM,OAAO,GAAG,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;IAC9D,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;AAC1C,IAAA,MAAM,KAAK,GAAG,CACZ,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,QAAQ,EACjE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;AACpB,IAAA,MAAM,aAAa,GAAG,gCAAgC,CAAC,MAAM,CAAC;AAC9D,IAAA,MAAM,GAAG,GAAG,CAAA,EAAG,QAAQ,KAAK,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA,CAAA,EAAI,aAAa,EAAE;IAC1E,IAAI,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC;AACvC,IAAA,IAAI,YAAY,KAAK,SAAS,EAAE;AAC9B,QAAA,YAAY,GAAG,IAAI,GAAG,EAAE;AACxB,QAAA,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC;IACpC;IACA,IAAI,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC;AACpC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,QAAQ,GAAG,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,QAAQ,KAAI;YACrD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;YACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM;AAChE,iBAAA,KAAK,CAAC,OAAO,CAAC,GAAG;AACjB,iBAAA,GAAG,CAAC,CAAC,IAAI,KACR;AACE,kBAAE;AACF,kBAAE,IAAI,MAAM,CACR,CAAA,CAAA,EAAI,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAA,YAAA,CAAc,EAC7D,IAAI,CACL,CACN;AACL,QAAA,CAAC,CAAC;AACF,QAAA,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC;IACjC;AACA,IAAA,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,UAAU,KAAI;AAClC,QAAA,IACE,UAAU,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM;aAC/B,QAAQ,IAAI,UAAU,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC;AAEhD,YAAA,OAAO,KAAK;AACd,QAAA,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,KAAK,KACvC,OAAO,SAAS,KAAK;AACnB,cAAE,SAAS,KAAK,KAAK,CAAC,KAAK;cACzB,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAE,CAAC,CAClC;AACH,IAAA,CAAC,CAAC;AACJ;AAEA;AACA,MAAM,QAAQ,GAAG,IAAI,OAAO,EAGzB;;;;"}

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

@@ -0,0 +1,27 @@
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * 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.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;;;;"}