@ttsc/unplugin 0.30.4 → 0.31.1

package/lib/core/transform/filesystem/createHostPathIdentityContext.mjs

@@ -0,0 +1,44 @@
+import { createFilesystemPathIdentityContext } from 'ttsc/path-identity';
+import { DEFAULT_FILESYSTEM_OPERATIONS } from './DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+
+/**
+ * Create the path-identity resolver for one filesystem view.
+ *
+ * Identity decides when two spellings name one file: case folding on
+ * case-insensitive volumes, and physical targets behind links. It must be
+ * answered by the same operations that capture and validate a generation, so
+ * the resolver is built from them. Failed realpath observations try the nearest
+ * resolvable ancestor and preserve uncertain missing suffix spelling. If no
+ * ancestor can be resolved, lexical spelling is retained instead of throwing.
+ *
+ * @evidence contracts/common.md#principled-implementation Identity resolution uses the same lstat, listings, realpath, platform, and directory-case view as generation capture and validation, keeping equivalence within one observed filesystem.
+ * @evidence contracts/common.md#clear-and-simple-design The adapter supplies the shared resolver's existing capability interface rather than implementing another realpath or case-folding algorithm.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed realpath retains the unresolved suffix under an observed ancestor, or lexical spelling when no ancestor resolves, rather than fabricating an existing target; no foreign filesystem methods are replaced.
+ * @evidence contracts/common.md#meaningful-documentation The native prose explains filesystem-view consistency and conservative failure semantics before the operation table wiring.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral identity follows actual directory case capability and native aliases through the supplied view, without assuming all Windows directories insensitive or all POSIX volumes sensitive.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Creating the transaction allocates its three empty observation maps;
+ *   later resolution visits missing ancestors and case-probe listings. The
+ *   adapter maps one requested listing to names without an additional native read.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The returned context memoizes path, realpath and case observations for
+ *   repeated questions within one filesystem transaction. Callers must create
+ *   a new context when later filesystem changes can invalidate those observations.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Ownership of the context and its maps transfers to the caller. Retained
+ *   entries grow with queried paths and ancestors and have no internal eviction;
+ *   ending the caller's transaction releases them, without retained descriptors.
+ */
+function createHostPathIdentityContext(filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    return createFilesystemPathIdentityContext({
+        caseSensitive: filesystem.caseSensitive,
+        lstat: filesystem.lstat,
+        platform: filesystem.platform,
+        readdir: (directory) => filesystem.readdir(directory).map((entry) => entry.name),
+        realpath: filesystem.realpath,
+        throwOnRealpathError: false,
+    });
+}
+
+export { createHostPathIdentityContext };
+//# sourceMappingURL=createHostPathIdentityContext.mjs.map

package/lib/core/transform/filesystem/createHostPathIdentityContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHostPathIdentityContext.mjs","sources":["../../../../src/core/transform/filesystem/createHostPathIdentityContext.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACG,SAAU,6BAA6B,CAC3C,UAAA,GAAgD,6BAA6B,EAAA;AAE7E,IAAA,OAAO,mCAAmC,CAAC;QACzC,aAAa,EAAE,UAAU,CAAC,aAAa;QACvC,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,OAAO,EAAE,CAAC,SAAS,KACjB,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC;QAC1D,QAAQ,EAAE,UAAU,CAAC,QAAQ;AAC7B,QAAA,oBAAoB,EAAE,KAAK;AAC5B,KAAA,CAAC;AACJ;;;;"}

package/lib/core/transform/filesystem/normalizeHostInputName.d.cts

@@ -0,0 +1,22 @@
+/**
+ * Fold ASCII letters for a directory watch's coarse name filter.
+ *
+ * Non-ASCII spelling is preserved so the consumer can recognize uncertainty.
+ * Case policy alone does not define native normalization or Windows short-name
+ * aliases; this value cannot prove that a different native spelling is absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Sensitive policy preserves spelling; insensitive policy folds only ASCII letters. Non-ASCII remains visible to consumers that withdraw uncertain lexical filters, while native stat owns existence proof.
+ * @evidence contracts/common.md#clear-and-simple-design One explicit policy parameter controls entry normalization without rereading directory capability or resolving a whole path.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The coarse filter does not substitute JavaScript Unicode folding or guessed short-name syntax for actual native equivalence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state ASCII-only scope and why preserved non-ASCII spelling still requires an uncertainty decision.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller's measured case policy selects coarse ASCII folding; normalization and alternate native names remain separate capabilities that this helper cannot infer.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Sensitive input returns directly; insensitive replacement scans the name
+ *   once with fixed one-character ASCII matches and output bounded by its length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This stateless spelling projection does not coordinate request validity;
+ *   the watch-location owner stores its projected names for the subscription.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function normalizeHostInputName(name: string, caseSensitive: boolean): string;

package/lib/core/transform/filesystem/normalizeHostInputName.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Fold ASCII letters for a directory watch's coarse name filter.
+ *
+ * Non-ASCII spelling is preserved so the consumer can recognize uncertainty.
+ * Case policy alone does not define native normalization or Windows short-name
+ * aliases; this value cannot prove that a different native spelling is absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Sensitive policy preserves spelling; insensitive policy folds only ASCII letters. Non-ASCII remains visible to consumers that withdraw uncertain lexical filters, while native stat owns existence proof.
+ * @evidence contracts/common.md#clear-and-simple-design One explicit policy parameter controls entry normalization without rereading directory capability or resolving a whole path.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The coarse filter does not substitute JavaScript Unicode folding or guessed short-name syntax for actual native equivalence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state ASCII-only scope and why preserved non-ASCII spelling still requires an uncertainty decision.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller's measured case policy selects coarse ASCII folding; normalization and alternate native names remain separate capabilities that this helper cannot infer.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Sensitive input returns directly; insensitive replacement scans the name
+ *   once with fixed one-character ASCII matches and output bounded by its length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This stateless spelling projection does not coordinate request validity;
+ *   the watch-location owner stores its projected names for the subscription.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function normalizeHostInputName(name: string, caseSensitive: boolean): string;

package/lib/core/transform/filesystem/normalizeHostInputName.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Fold ASCII letters for a directory watch's coarse name filter.
+ *
+ * Non-ASCII spelling is preserved so the consumer can recognize uncertainty.
+ * Case policy alone does not define native normalization or Windows short-name
+ * aliases; this value cannot prove that a different native spelling is absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Sensitive policy preserves spelling; insensitive policy folds only ASCII letters. Non-ASCII remains visible to consumers that withdraw uncertain lexical filters, while native stat owns existence proof.
+ * @evidence contracts/common.md#clear-and-simple-design One explicit policy parameter controls entry normalization without rereading directory capability or resolving a whole path.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The coarse filter does not substitute JavaScript Unicode folding or guessed short-name syntax for actual native equivalence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state ASCII-only scope and why preserved non-ASCII spelling still requires an uncertainty decision.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller's measured case policy selects coarse ASCII folding; normalization and alternate native names remain separate capabilities that this helper cannot infer.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Sensitive input returns directly; insensitive replacement scans the name
+ *   once with fixed one-character ASCII matches and output bounded by its length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This stateless spelling projection does not coordinate request validity;
+ *   the watch-location owner stores its projected names for the subscription.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function normalizeHostInputName(name: string, caseSensitive: boolean): string;

package/lib/core/transform/filesystem/normalizeHostInputName.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Fold ASCII letters for a directory watch's coarse name filter.
+ *
+ * Non-ASCII spelling is preserved so the consumer can recognize uncertainty.
+ * Case policy alone does not define native normalization or Windows short-name
+ * aliases; this value cannot prove that a different native spelling is absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Sensitive policy preserves spelling; insensitive policy folds only ASCII letters. Non-ASCII remains visible to consumers that withdraw uncertain lexical filters, while native stat owns existence proof.
+ * @evidence contracts/common.md#clear-and-simple-design One explicit policy parameter controls entry normalization without rereading directory capability or resolving a whole path.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The coarse filter does not substitute JavaScript Unicode folding or guessed short-name syntax for actual native equivalence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state ASCII-only scope and why preserved non-ASCII spelling still requires an uncertainty decision.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller's measured case policy selects coarse ASCII folding; normalization and alternate native names remain separate capabilities that this helper cannot infer.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Sensitive input returns directly; insensitive replacement scans the name
+ *   once with fixed one-character ASCII matches and output bounded by its length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This stateless spelling projection does not coordinate request validity;
+ *   the watch-location owner stores its projected names for the subscription.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function normalizeHostInputName(name, caseSensitive) {
+    return caseSensitive
+        ? name
+        : name.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+
+exports.normalizeHostInputName = normalizeHostInputName;
+//# sourceMappingURL=normalizeHostInputName.js.map

package/lib/core/transform/filesystem/normalizeHostInputName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeHostInputName.js","sources":["../../../../src/core/transform/filesystem/normalizeHostInputName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,sBAAsB,CACpC,IAAY,EACZ,aAAsB,EAAA;AAEtB,IAAA,OAAO;AACL,UAAE;AACF,UAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,MAAM,KAAK,MAAM,CAAC,WAAW,EAAE,CAAC;AAC9D;;;;"}

package/lib/core/transform/filesystem/normalizeHostInputName.mjs

@@ -0,0 +1,29 @@
+/**
+ * Fold ASCII letters for a directory watch's coarse name filter.
+ *
+ * Non-ASCII spelling is preserved so the consumer can recognize uncertainty.
+ * Case policy alone does not define native normalization or Windows short-name
+ * aliases; this value cannot prove that a different native spelling is absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Sensitive policy preserves spelling; insensitive policy folds only ASCII letters. Non-ASCII remains visible to consumers that withdraw uncertain lexical filters, while native stat owns existence proof.
+ * @evidence contracts/common.md#clear-and-simple-design One explicit policy parameter controls entry normalization without rereading directory capability or resolving a whole path.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The coarse filter does not substitute JavaScript Unicode folding or guessed short-name syntax for actual native equivalence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state ASCII-only scope and why preserved non-ASCII spelling still requires an uncertainty decision.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller's measured case policy selects coarse ASCII folding; normalization and alternate native names remain separate capabilities that this helper cannot infer.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Sensitive input returns directly; insensitive replacement scans the name
+ *   once with fixed one-character ASCII matches and output bounded by its length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This stateless spelling projection does not coordinate request validity;
+ *   the watch-location owner stores its projected names for the subscription.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function normalizeHostInputName(name, caseSensitive) {
+    return caseSensitive
+        ? name
+        : name.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+
+export { normalizeHostInputName };
+//# sourceMappingURL=normalizeHostInputName.mjs.map

package/lib/core/transform/filesystem/normalizeHostInputName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeHostInputName.mjs","sources":["../../../../src/core/transform/filesystem/normalizeHostInputName.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,sBAAsB,CACpC,IAAY,EACZ,aAAsB,EAAA;AAEtB,IAAA,OAAO;AACL,UAAE;AACF,UAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,MAAM,KAAK,MAAM,CAAC,WAAW,EAAE,CAAC;AAC9D;;;;"}

package/lib/core/transform/filesystem/normalizePath.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Convert Windows separators to forward slashes.
+ *
+ * Project keys, alias targets, and generated tsconfig paths all use one
+ * separator spelling. This conversion does not establish filesystem identity or
+ * make paths from different native filesystems equivalent.
+ *
+ * @evidence contracts/common.md#principled-implementation The helper converts path separators into the forward-slash representation consumed by project keys and generated compiler paths, without changing case or resolving identity.
+ * @evidence contracts/common.md#clear-and-simple-design One separator conversion owns protocol spelling while native path resolution and physical equivalence remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Separator normalization does not pretend to prove containment, physical identity, or compiler-input freshness.
+ * @evidence contracts/common.md#meaningful-documentation The native comment names the normalized representation's consumers and distinguishes it from filesystem identity.
+ * @evidence contracts/portability.md#os-neutral-implementation The slash conversion serves project keys, alias targets and compiler configuration values; a spelling handed to a filesystem or a bundler is never rewritten, and identity comes from the filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One fixed replacement scans the supplied path spelling in linear time
+ *   and creates at most a same-length result; it performs no filesystem walk.
+ * @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 normalizePath(file: string): string;

package/lib/core/transform/filesystem/normalizePath.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Convert Windows separators to forward slashes.
+ *
+ * Project keys, alias targets, and generated tsconfig paths all use one
+ * separator spelling. This conversion does not establish filesystem identity or
+ * make paths from different native filesystems equivalent.
+ *
+ * @evidence contracts/common.md#principled-implementation The helper converts path separators into the forward-slash representation consumed by project keys and generated compiler paths, without changing case or resolving identity.
+ * @evidence contracts/common.md#clear-and-simple-design One separator conversion owns protocol spelling while native path resolution and physical equivalence remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Separator normalization does not pretend to prove containment, physical identity, or compiler-input freshness.
+ * @evidence contracts/common.md#meaningful-documentation The native comment names the normalized representation's consumers and distinguishes it from filesystem identity.
+ * @evidence contracts/portability.md#os-neutral-implementation The slash conversion serves project keys, alias targets and compiler configuration values; a spelling handed to a filesystem or a bundler is never rewritten, and identity comes from the filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One fixed replacement scans the supplied path spelling in linear time
+ *   and creates at most a same-length result; it performs no filesystem walk.
+ * @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 normalizePath(file: string): string;

package/lib/core/transform/filesystem/normalizePath.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Convert Windows separators to forward slashes.
+ *
+ * Project keys, alias targets, and generated tsconfig paths all use one
+ * separator spelling. This conversion does not establish filesystem identity or
+ * make paths from different native filesystems equivalent.
+ *
+ * @evidence contracts/common.md#principled-implementation The helper converts path separators into the forward-slash representation consumed by project keys and generated compiler paths, without changing case or resolving identity.
+ * @evidence contracts/common.md#clear-and-simple-design One separator conversion owns protocol spelling while native path resolution and physical equivalence remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Separator normalization does not pretend to prove containment, physical identity, or compiler-input freshness.
+ * @evidence contracts/common.md#meaningful-documentation The native comment names the normalized representation's consumers and distinguishes it from filesystem identity.
+ * @evidence contracts/portability.md#os-neutral-implementation The slash conversion serves project keys, alias targets and compiler configuration values; a spelling handed to a filesystem or a bundler is never rewritten, and identity comes from the filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One fixed replacement scans the supplied path spelling in linear time
+ *   and creates at most a same-length result; it performs no filesystem walk.
+ * @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 normalizePath(file: string): string;

package/lib/core/transform/filesystem/normalizePath.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * Convert Windows separators to forward slashes.
+ *
+ * Project keys, alias targets, and generated tsconfig paths all use one
+ * separator spelling. This conversion does not establish filesystem identity or
+ * make paths from different native filesystems equivalent.
+ *
+ * @evidence contracts/common.md#principled-implementation The helper converts path separators into the forward-slash representation consumed by project keys and generated compiler paths, without changing case or resolving identity.
+ * @evidence contracts/common.md#clear-and-simple-design One separator conversion owns protocol spelling while native path resolution and physical equivalence remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Separator normalization does not pretend to prove containment, physical identity, or compiler-input freshness.
+ * @evidence contracts/common.md#meaningful-documentation The native comment names the normalized representation's consumers and distinguishes it from filesystem identity.
+ * @evidence contracts/portability.md#os-neutral-implementation The slash conversion serves project keys, alias targets and compiler configuration values; a spelling handed to a filesystem or a bundler is never rewritten, and identity comes from the filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One fixed replacement scans the supplied path spelling in linear time
+ *   and creates at most a same-length result; it performs no filesystem walk.
+ * @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 normalizePath(file) {
+    return file.replace(/\\/g, "/");
+}
+
+exports.normalizePath = normalizePath;
+//# sourceMappingURL=normalizePath.js.map

package/lib/core/transform/filesystem/normalizePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizePath.js","sources":["../../../../src/core/transform/filesystem/normalizePath.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;AAmBG;AACG,SAAU,aAAa,CAAC,IAAY,EAAA;IACxC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;AACjC;;;;"}

package/lib/core/transform/filesystem/normalizePath.mjs

@@ -0,0 +1,26 @@
+/**
+ * Convert Windows separators to forward slashes.
+ *
+ * Project keys, alias targets, and generated tsconfig paths all use one
+ * separator spelling. This conversion does not establish filesystem identity or
+ * make paths from different native filesystems equivalent.
+ *
+ * @evidence contracts/common.md#principled-implementation The helper converts path separators into the forward-slash representation consumed by project keys and generated compiler paths, without changing case or resolving identity.
+ * @evidence contracts/common.md#clear-and-simple-design One separator conversion owns protocol spelling while native path resolution and physical equivalence remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Separator normalization does not pretend to prove containment, physical identity, or compiler-input freshness.
+ * @evidence contracts/common.md#meaningful-documentation The native comment names the normalized representation's consumers and distinguishes it from filesystem identity.
+ * @evidence contracts/portability.md#os-neutral-implementation The slash conversion serves project keys, alias targets and compiler configuration values; a spelling handed to a filesystem or a bundler is never rewritten, and identity comes from the filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One fixed replacement scans the supplied path spelling in linear time
+ *   and creates at most a same-length result; it performs no filesystem walk.
+ * @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 normalizePath(file) {
+    return file.replace(/\\/g, "/");
+}
+
+export { normalizePath };
+//# sourceMappingURL=normalizePath.mjs.map

package/lib/core/transform/filesystem/normalizePath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizePath.mjs","sources":["../../../../src/core/transform/filesystem/normalizePath.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;AAmBG;AACG,SAAU,aAAa,CAAC,IAAY,EAAA;IACxC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;AACjC;;;;"}

package/lib/core/transform/filesystem/pathIdentityKey.d.cts

@@ -0,0 +1,36 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+/**
+ * Build a comparison key for a path without changing the spelling handed to a
+ * filesystem or bundler. Physical path spelling and the nearest existing
+ * directory's case policy keep case-sensitive files distinct on every OS.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   The shared filesystem resolver expands native aliases and judges missing
+ *   suffix spelling by directory capability; its key represents file identity.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   This wrapper extracts the key from one supplied transaction context rather
+ *   than duplicating native equivalence policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   Case policy and physical spelling come from the resolver, not a blanket
+ *   Windows/macOS lowercase rule or consumer-specific path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose distinguishes comparison from delivered spelling and states
+ *   per-directory case semantics, separated from tags per documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   OS-neutral comparison follows the supplied filesystem identity context's
+ *   native aliases and observed directory case policy. The returned key never
+ *   substitutes for the original path spelling supplied to a host or read.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One resolver query performs native path normalization and, when uncached,
+ *   ancestor and directory-case observations. The wrapper allocates no second
+ *   identity representation or directory traversal beyond that required query.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   A supplied transaction reuses its memoized path, realpath and case answers.
+ *   Omission creates a fresh transaction, so no historical filesystem result
+ *   crosses unrelated calls through a hidden cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller owns a supplied context's lifetime. An implicitly created
+ *   context becomes unreachable after the synchronous return or throw; its
+ *   maps grow only with this resolution's visited paths and ancestors.
+ */
+export declare function pathIdentityKey(file: string, identities?: FilesystemPathIdentityContext): string;

package/lib/core/transform/filesystem/pathIdentityKey.d.mts

@@ -0,0 +1,36 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+/**
+ * Build a comparison key for a path without changing the spelling handed to a
+ * filesystem or bundler. Physical path spelling and the nearest existing
+ * directory's case policy keep case-sensitive files distinct on every OS.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   The shared filesystem resolver expands native aliases and judges missing
+ *   suffix spelling by directory capability; its key represents file identity.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   This wrapper extracts the key from one supplied transaction context rather
+ *   than duplicating native equivalence policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   Case policy and physical spelling come from the resolver, not a blanket
+ *   Windows/macOS lowercase rule or consumer-specific path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose distinguishes comparison from delivered spelling and states
+ *   per-directory case semantics, separated from tags per documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   OS-neutral comparison follows the supplied filesystem identity context's
+ *   native aliases and observed directory case policy. The returned key never
+ *   substitutes for the original path spelling supplied to a host or read.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One resolver query performs native path normalization and, when uncached,
+ *   ancestor and directory-case observations. The wrapper allocates no second
+ *   identity representation or directory traversal beyond that required query.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   A supplied transaction reuses its memoized path, realpath and case answers.
+ *   Omission creates a fresh transaction, so no historical filesystem result
+ *   crosses unrelated calls through a hidden cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller owns a supplied context's lifetime. An implicitly created
+ *   context becomes unreachable after the synchronous return or throw; its
+ *   maps grow only with this resolution's visited paths and ancestors.
+ */
+export declare function pathIdentityKey(file: string, identities?: FilesystemPathIdentityContext): string;

package/lib/core/transform/filesystem/pathIdentityKey.d.ts

@@ -0,0 +1,36 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+/**
+ * Build a comparison key for a path without changing the spelling handed to a
+ * filesystem or bundler. Physical path spelling and the nearest existing
+ * directory's case policy keep case-sensitive files distinct on every OS.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   The shared filesystem resolver expands native aliases and judges missing
+ *   suffix spelling by directory capability; its key represents file identity.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   This wrapper extracts the key from one supplied transaction context rather
+ *   than duplicating native equivalence policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   Case policy and physical spelling come from the resolver, not a blanket
+ *   Windows/macOS lowercase rule or consumer-specific path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose distinguishes comparison from delivered spelling and states
+ *   per-directory case semantics, separated from tags per documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   OS-neutral comparison follows the supplied filesystem identity context's
+ *   native aliases and observed directory case policy. The returned key never
+ *   substitutes for the original path spelling supplied to a host or read.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One resolver query performs native path normalization and, when uncached,
+ *   ancestor and directory-case observations. The wrapper allocates no second
+ *   identity representation or directory traversal beyond that required query.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   A supplied transaction reuses its memoized path, realpath and case answers.
+ *   Omission creates a fresh transaction, so no historical filesystem result
+ *   crosses unrelated calls through a hidden cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller owns a supplied context's lifetime. An implicitly created
+ *   context becomes unreachable after the synchronous return or throw; its
+ *   maps grow only with this resolution's visited paths and ancestors.
+ */
+export declare function pathIdentityKey(file: string, identities?: FilesystemPathIdentityContext): string;

package/lib/core/transform/filesystem/pathIdentityKey.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var createHostPathIdentityContext = require('./createHostPathIdentityContext.js');
+
+/**
+ * Build a comparison key for a path without changing the spelling handed to a
+ * filesystem or bundler. Physical path spelling and the nearest existing
+ * directory's case policy keep case-sensitive files distinct on every OS.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   The shared filesystem resolver expands native aliases and judges missing
+ *   suffix spelling by directory capability; its key represents file identity.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   This wrapper extracts the key from one supplied transaction context rather
+ *   than duplicating native equivalence policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   Case policy and physical spelling come from the resolver, not a blanket
+ *   Windows/macOS lowercase rule or consumer-specific path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose distinguishes comparison from delivered spelling and states
+ *   per-directory case semantics, separated from tags per documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   OS-neutral comparison follows the supplied filesystem identity context's
+ *   native aliases and observed directory case policy. The returned key never
+ *   substitutes for the original path spelling supplied to a host or read.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One resolver query performs native path normalization and, when uncached,
+ *   ancestor and directory-case observations. The wrapper allocates no second
+ *   identity representation or directory traversal beyond that required query.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   A supplied transaction reuses its memoized path, realpath and case answers.
+ *   Omission creates a fresh transaction, so no historical filesystem result
+ *   crosses unrelated calls through a hidden cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller owns a supplied context's lifetime. An implicitly created
+ *   context becomes unreachable after the synchronous return or throw; its
+ *   maps grow only with this resolution's visited paths and ancestors.
+ */
+function pathIdentityKey(file, identities = createHostPathIdentityContext.createHostPathIdentityContext()) {
+    return identities.resolve(file).key;
+}
+
+exports.pathIdentityKey = pathIdentityKey;
+//# sourceMappingURL=pathIdentityKey.js.map

package/lib/core/transform/filesystem/pathIdentityKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathIdentityKey.js","sources":["../../../../src/core/transform/filesystem/pathIdentityKey.ts"],"sourcesContent":[null],"names":["createHostPathIdentityContext"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;SACa,eAAe,CAC7B,IAAY,EACZ,UAAA,GAA4CA,2DAA6B,EAAE,EAAA;IAE3E,OAAO,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG;AACrC;;;;"}

package/lib/core/transform/filesystem/pathIdentityKey.mjs

@@ -0,0 +1,42 @@
+import { createHostPathIdentityContext } from './createHostPathIdentityContext.mjs';
+
+/**
+ * Build a comparison key for a path without changing the spelling handed to a
+ * filesystem or bundler. Physical path spelling and the nearest existing
+ * directory's case policy keep case-sensitive files distinct on every OS.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   The shared filesystem resolver expands native aliases and judges missing
+ *   suffix spelling by directory capability; its key represents file identity.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   This wrapper extracts the key from one supplied transaction context rather
+ *   than duplicating native equivalence policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   Case policy and physical spelling come from the resolver, not a blanket
+ *   Windows/macOS lowercase rule or consumer-specific path exceptions.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Native prose distinguishes comparison from delivered spelling and states
+ *   per-directory case semantics, separated from tags per documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   OS-neutral comparison follows the supplied filesystem identity context's
+ *   native aliases and observed directory case policy. The returned key never
+ *   substitutes for the original path spelling supplied to a host or read.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One resolver query performs native path normalization and, when uncached,
+ *   ancestor and directory-case observations. The wrapper allocates no second
+ *   identity representation or directory traversal beyond that required query.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   A supplied transaction reuses its memoized path, realpath and case answers.
+ *   Omission creates a fresh transaction, so no historical filesystem result
+ *   crosses unrelated calls through a hidden cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The caller owns a supplied context's lifetime. An implicitly created
+ *   context becomes unreachable after the synchronous return or throw; its
+ *   maps grow only with this resolution's visited paths and ancestors.
+ */
+function pathIdentityKey(file, identities = createHostPathIdentityContext()) {
+    return identities.resolve(file).key;
+}
+
+export { pathIdentityKey };
+//# sourceMappingURL=pathIdentityKey.mjs.map

package/lib/core/transform/filesystem/pathIdentityKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathIdentityKey.mjs","sources":["../../../../src/core/transform/filesystem/pathIdentityKey.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;SACa,eAAe,CAC7B,IAAY,EACZ,UAAA,GAA4C,6BAA6B,EAAE,EAAA;IAE3E,OAAO,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG;AACrC;;;;"}

package/lib/core/transform/filesystem/pathIsWithin.d.cts

@@ -0,0 +1,24 @@
+/**
+ * Whether `child` is `parent` itself or lies below it, lexically.
+ *
+ * Decided through `path.relative`, never by string prefix, so a sibling such as
+ * `/repo2` is not inside `/repo` and a path on another drive or share is never
+ * inside anything local. The optional platform selects an observed filesystem's
+ * path grammar; the host platform supplies the default for ordinary native
+ * callers.
+ *
+ * @evidence contracts/common.md#principled-implementation A lexical relative path distinguishes root equality and descendants from parent escapes and unrelated volumes, without confusing siblings sharing a prefix.
+ * @evidence contracts/common.md#clear-and-simple-design One native relative-path calculation supplies the boundary decisions; physical alias resolution belongs to callers that require it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts String-prefix containment and unconditional case folding are absent, and lexical containment does not claim physical ownership.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states lexical scope and explains sibling and cross-root rejection.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral root boundaries use native relative, separator, and absolute-path semantics, including drive/share differences without hardcoded platform roots.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One relative-path normalization examines the two input path lengths;
+ *   boundary checks inspect only that result. No ancestor filesystem walk
+ *   or separate normalized-path collections are needed for lexical containment.
+ * @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 pathIsWithin(child: string, parent: string, platform?: NodeJS.Platform): boolean;

package/lib/core/transform/filesystem/pathIsWithin.d.mts

@@ -0,0 +1,24 @@
+/**
+ * Whether `child` is `parent` itself or lies below it, lexically.
+ *
+ * Decided through `path.relative`, never by string prefix, so a sibling such as
+ * `/repo2` is not inside `/repo` and a path on another drive or share is never
+ * inside anything local. The optional platform selects an observed filesystem's
+ * path grammar; the host platform supplies the default for ordinary native
+ * callers.
+ *
+ * @evidence contracts/common.md#principled-implementation A lexical relative path distinguishes root equality and descendants from parent escapes and unrelated volumes, without confusing siblings sharing a prefix.
+ * @evidence contracts/common.md#clear-and-simple-design One native relative-path calculation supplies the boundary decisions; physical alias resolution belongs to callers that require it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts String-prefix containment and unconditional case folding are absent, and lexical containment does not claim physical ownership.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states lexical scope and explains sibling and cross-root rejection.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral root boundaries use native relative, separator, and absolute-path semantics, including drive/share differences without hardcoded platform roots.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One relative-path normalization examines the two input path lengths;
+ *   boundary checks inspect only that result. No ancestor filesystem walk
+ *   or separate normalized-path collections are needed for lexical containment.
+ * @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 pathIsWithin(child: string, parent: string, platform?: NodeJS.Platform): boolean;

package/lib/core/transform/filesystem/pathIsWithin.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Whether `child` is `parent` itself or lies below it, lexically.
+ *
+ * Decided through `path.relative`, never by string prefix, so a sibling such as
+ * `/repo2` is not inside `/repo` and a path on another drive or share is never
+ * inside anything local. The optional platform selects an observed filesystem's
+ * path grammar; the host platform supplies the default for ordinary native
+ * callers.
+ *
+ * @evidence contracts/common.md#principled-implementation A lexical relative path distinguishes root equality and descendants from parent escapes and unrelated volumes, without confusing siblings sharing a prefix.
+ * @evidence contracts/common.md#clear-and-simple-design One native relative-path calculation supplies the boundary decisions; physical alias resolution belongs to callers that require it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts String-prefix containment and unconditional case folding are absent, and lexical containment does not claim physical ownership.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states lexical scope and explains sibling and cross-root rejection.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral root boundaries use native relative, separator, and absolute-path semantics, including drive/share differences without hardcoded platform roots.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One relative-path normalization examines the two input path lengths;
+ *   boundary checks inspect only that result. No ancestor filesystem walk
+ *   or separate normalized-path collections are needed for lexical containment.
+ * @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 pathIsWithin(child: string, parent: string, platform?: NodeJS.Platform): boolean;