@ttsc/unplugin 0.30.4 → 0.31.1

package/lib/core/transform/inputs/compilerAccessibleEntries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerAccessibleEntries.js","sources":["../../../../src/core/transform/inputs/compilerAccessibleEntries.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,yBAAyB,CACvC,SAAiB,EACjB,UAA6C,EAAA;IAI7C,MAAM,WAAW,GAAa,EAAE;IAChC,MAAM,KAAK,GAAa,EAAE;AAC1B,IAAA,MAAM,OAAO,GACX,CAAC,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,MAAM;UAC1C,IAAI,CAAC;AACP,UAAE,IAAI,CAAC,KAAK;AAChB,IAAA,IAAI,OAAoB;AACxB,IAAA,IAAI;AACF,QAAA,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC;IACzC;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE;IAC/B;AACA,IAAA,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;AAC3B,QAAA,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE;AACvB,YAAA,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAC5B;QACF;AACA,QAAA,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE;AAClB,YAAA,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YACtB;QACF;AACA,QAAA,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE;YAAE;AAC7B,QAAA,IAAI;AACF,YAAA,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACnE,IAAI,MAAM,CAAC,WAAW,EAAE;AAAE,gBAAA,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;iBACjD,IAAI,MAAM,CAAC,MAAM,EAAE;AAAE,gBAAA,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;QAClD;AAAE,QAAA,MAAM;;QAER;IACF;IACA,OAAO;AACL,QAAA,WAAW,EAAE,iBAAiB,CAAC,WAAW,CAAC;AAC3C,QAAA,KAAK,EAAE,iBAAiB,CAAC,KAAK,CAAC;KAChC;AACH;AAEA;AACA,SAAS,iBAAiB,CAAC,KAAe,EAAA;AACxC,IAAA,OAAO;SACJ,GAAG,CAAC,CAAC,IAAI,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC;SAC5D,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,KAAK,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;SACjE,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;AAC5B;;;;"}

package/lib/core/transform/inputs/compilerAccessibleEntries.mjs

@@ -0,0 +1,71 @@
+import path from 'node:path';
+
+/**
+ * Replay the compiler's accessible child-name observation. Regular files and
+ * directories are recorded separately; links are classified by their targets.
+ * Failed reads and inaccessible links contribute no entries, as in the compiler
+ * filesystem.
+ *
+ * Names use UTF-8 byte ordering, matching Go's directory enumeration rather
+ * than JavaScript's UTF-16 ordering for supplementary Unicode characters. The
+ * supplied filesystem selects the path grammar used for linked children.
+ *
+ * @evidence contracts/common.md#principled-implementation Native entry kinds and followed link targets produce the compiler's separate directory and regular-file lists, with Go-compatible UTF-8 ordering and failed-read semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One shared observer serves graph predicate replay and frozen watch baseline capture, so both obtain the same membership representation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Inaccessible links and unsupported entry kinds remain omitted according to the compiler operation rather than inferred from names or replaced by fabricated membership.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs specify link following, failure semantics, ordering and supplied path grammar, with prose separated from acknowledgment tags as the documentation guidance requires.
+ * @evidence contracts/portability.md#os-neutral-implementation Native kinds come from the supplied readdir and following stat operations; the supplied platform chooses win32 or posix child joining without guessing filesystem case policy from the OS.
+ * @evidence contracts/performance.md#efficient-algorithms One enumeration examines E entries and follows only links through native child resolution. Each selected name is UTF-8 encoded once; encoding and retained buffers scale with total name bytes, while two sorts perform O(E log E) comparisons whose cost follows the compared byte prefixes. Temporary arrays grow with selected names and no source content is read.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This observes current directory membership once; graph and baseline owners establish whether their captured result can be shared across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Entry lists and sort buffers are observation-local and the synchronous operations retain no descriptor, watcher or task.
+ */
+function compilerAccessibleEntries(directory, filesystem) {
+    const directories = [];
+    const files = [];
+    const pathApi = (filesystem.platform ?? process.platform) === "win32"
+        ? path.win32
+        : path.posix;
+    let entries;
+    try {
+        entries = filesystem.readdir(directory);
+    }
+    catch {
+        return { directories, files };
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            directories.push(entry.name);
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(entry.name);
+            continue;
+        }
+        if (!entry.isSymbolicLink())
+            continue;
+        try {
+            const target = filesystem.stat(pathApi.join(directory, entry.name));
+            if (target.isDirectory())
+                directories.push(entry.name);
+            else if (target.isFile())
+                files.push(entry.name);
+        }
+        catch {
+            // TypeScript-Go omits inaccessible and broken linked entries.
+        }
+    }
+    return {
+        directories: sortCompilerNames(directories),
+        files: sortCompilerNames(files),
+    };
+}
+/** Encode each name once for the compiler's bytewise lexical ordering. */
+function sortCompilerNames(names) {
+    return names
+        .map((name) => ({ name, encoded: Buffer.from(name, "utf8") }))
+        .sort((left, right) => Buffer.compare(left.encoded, right.encoded))
+        .map(({ name }) => name);
+}
+
+export { compilerAccessibleEntries };
+//# sourceMappingURL=compilerAccessibleEntries.mjs.map

package/lib/core/transform/inputs/compilerAccessibleEntries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerAccessibleEntries.mjs","sources":["../../../../src/core/transform/inputs/compilerAccessibleEntries.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAMA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,yBAAyB,CACvC,SAAiB,EACjB,UAA6C,EAAA;IAI7C,MAAM,WAAW,GAAa,EAAE;IAChC,MAAM,KAAK,GAAa,EAAE;AAC1B,IAAA,MAAM,OAAO,GACX,CAAC,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,MAAM;UAC1C,IAAI,CAAC;AACP,UAAE,IAAI,CAAC,KAAK;AAChB,IAAA,IAAI,OAAoB;AACxB,IAAA,IAAI;AACF,QAAA,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC;IACzC;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE;IAC/B;AACA,IAAA,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;AAC3B,QAAA,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE;AACvB,YAAA,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAC5B;QACF;AACA,QAAA,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE;AAClB,YAAA,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YACtB;QACF;AACA,QAAA,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE;YAAE;AAC7B,QAAA,IAAI;AACF,YAAA,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACnE,IAAI,MAAM,CAAC,WAAW,EAAE;AAAE,gBAAA,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;iBACjD,IAAI,MAAM,CAAC,MAAM,EAAE;AAAE,gBAAA,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;QAClD;AAAE,QAAA,MAAM;;QAER;IACF;IACA,OAAO;AACL,QAAA,WAAW,EAAE,iBAAiB,CAAC,WAAW,CAAC;AAC3C,QAAA,KAAK,EAAE,iBAAiB,CAAC,KAAK,CAAC;KAChC;AACH;AAEA;AACA,SAAS,iBAAiB,CAAC,KAAe,EAAA;AACxC,IAAA,OAAO;SACJ,GAAG,CAAC,CAAC,IAAI,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC;SAC5D,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,KAAK,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;SACjE,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;AAC5B;;;;"}

package/lib/core/transform/inputs/compilerInputRealpathObservation.d.cts

@@ -0,0 +1,17 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Replay the compiler's realpath observation. An empty resolver result is
+ * unsuccessful; a thrown native resolution uses the compiler's cleaned lexical
+ * fallback instead of becoming a missing-input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation Empty results and thrown resolution remain distinct because the compiler records an empty result as failed but cleans the input spelling on native resolution failure.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter maps resolver output into the envelope's realpath observation; identity comparison remains with its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The lexical fallback reproduces the compiler filesystem contract rather than fabricating successful physical resolution for a known input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes empty, successful and fallback results; a blank comment line separates acknowledgments under the documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied resolver and explicit path dialect through resolveFilesystemPath; the cleaned fallback does not claim native alias or case equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This fixed protocol adapter maps one supplied realpath result or exception into an observation. Native resolution and lexical path cleanup retain their component/link and text-length costs in the respective owners; one call is not a constant native-work guarantee.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It replays the compiler's observation against the filesystem now by design, so nothing is shared.
+ */
+export declare function compilerInputRealpathObservation(file: string, filesystem: TtscTransformFilesystemOperations): NonNullable<ITtscCompilerTransformation.IInputObservation["realpath"]>;

package/lib/core/transform/inputs/compilerInputRealpathObservation.d.mts

@@ -0,0 +1,17 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Replay the compiler's realpath observation. An empty resolver result is
+ * unsuccessful; a thrown native resolution uses the compiler's cleaned lexical
+ * fallback instead of becoming a missing-input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation Empty results and thrown resolution remain distinct because the compiler records an empty result as failed but cleans the input spelling on native resolution failure.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter maps resolver output into the envelope's realpath observation; identity comparison remains with its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The lexical fallback reproduces the compiler filesystem contract rather than fabricating successful physical resolution for a known input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes empty, successful and fallback results; a blank comment line separates acknowledgments under the documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied resolver and explicit path dialect through resolveFilesystemPath; the cleaned fallback does not claim native alias or case equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This fixed protocol adapter maps one supplied realpath result or exception into an observation. Native resolution and lexical path cleanup retain their component/link and text-length costs in the respective owners; one call is not a constant native-work guarantee.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It replays the compiler's observation against the filesystem now by design, so nothing is shared.
+ */
+export declare function compilerInputRealpathObservation(file: string, filesystem: TtscTransformFilesystemOperations): NonNullable<ITtscCompilerTransformation.IInputObservation["realpath"]>;

package/lib/core/transform/inputs/compilerInputRealpathObservation.d.ts

@@ -0,0 +1,17 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Replay the compiler's realpath observation. An empty resolver result is
+ * unsuccessful; a thrown native resolution uses the compiler's cleaned lexical
+ * fallback instead of becoming a missing-input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation Empty results and thrown resolution remain distinct because the compiler records an empty result as failed but cleans the input spelling on native resolution failure.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter maps resolver output into the envelope's realpath observation; identity comparison remains with its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The lexical fallback reproduces the compiler filesystem contract rather than fabricating successful physical resolution for a known input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes empty, successful and fallback results; a blank comment line separates acknowledgments under the documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied resolver and explicit path dialect through resolveFilesystemPath; the cleaned fallback does not claim native alias or case equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This fixed protocol adapter maps one supplied realpath result or exception into an observation. Native resolution and lexical path cleanup retain their component/link and text-length costs in the respective owners; one call is not a constant native-work guarantee.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It replays the compiler's observation against the filesystem now by design, so nothing is shared.
+ */
+export declare function compilerInputRealpathObservation(file: string, filesystem: TtscTransformFilesystemOperations): NonNullable<ITtscCompilerTransformation.IInputObservation["realpath"]>;

package/lib/core/transform/inputs/compilerInputRealpathObservation.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var pathIdentity = require('ttsc/path-identity');
+
+/**
+ * Replay the compiler's realpath observation. An empty resolver result is
+ * unsuccessful; a thrown native resolution uses the compiler's cleaned lexical
+ * fallback instead of becoming a missing-input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation Empty results and thrown resolution remain distinct because the compiler records an empty result as failed but cleans the input spelling on native resolution failure.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter maps resolver output into the envelope's realpath observation; identity comparison remains with its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The lexical fallback reproduces the compiler filesystem contract rather than fabricating successful physical resolution for a known input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes empty, successful and fallback results; a blank comment line separates acknowledgments under the documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied resolver and explicit path dialect through resolveFilesystemPath; the cleaned fallback does not claim native alias or case equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This fixed protocol adapter maps one supplied realpath result or exception into an observation. Native resolution and lexical path cleanup retain their component/link and text-length costs in the respective owners; one call is not a constant native-work guarantee.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It replays the compiler's observation against the filesystem now by design, so nothing is shared.
+ */
+function compilerInputRealpathObservation(file, filesystem) {
+    try {
+        const realpath = filesystem.realpath(file);
+        return realpath.length === 0
+            ? { ok: false }
+            : {
+                ok: true,
+                path: pathIdentity.resolveFilesystemPath(realpath, filesystem.platform),
+            };
+    }
+    catch {
+        // TypeScript-Go's OS and io filesystems return the cleaned input spelling
+        // when native realpath resolution fails; they do not expose the failure.
+        return {
+            ok: true,
+            path: pathIdentity.resolveFilesystemPath(file, filesystem.platform),
+        };
+    }
+}
+
+exports.compilerInputRealpathObservation = compilerInputRealpathObservation;
+//# sourceMappingURL=compilerInputRealpathObservation.js.map

package/lib/core/transform/inputs/compilerInputRealpathObservation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerInputRealpathObservation.js","sources":["../../../../src/core/transform/inputs/compilerInputRealpathObservation.ts"],"sourcesContent":[null],"names":["resolveFilesystemPath"],"mappings":";;;;AAKA;;;;;;;;;;;;;AAaG;AACG,SAAU,gCAAgC,CAC9C,IAAY,EACZ,UAA6C,EAAA;AAE7C,IAAA,IAAI;QACF,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;AAC1C,QAAA,OAAO,QAAQ,CAAC,MAAM,KAAK;AACzB,cAAE,EAAE,EAAE,EAAE,KAAK;AACb,cAAE;AACE,gBAAA,EAAE,EAAE,IAAI;gBACR,IAAI,EAAEA,kCAAqB,CAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC;aAC3D;IACP;AAAE,IAAA,MAAM;;;QAGN,OAAO;AACL,YAAA,EAAE,EAAE,IAAI;YACR,IAAI,EAAEA,kCAAqB,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC;SACvD;IACH;AACF;;;;"}

package/lib/core/transform/inputs/compilerInputRealpathObservation.mjs

@@ -0,0 +1,38 @@
+import { resolveFilesystemPath } from 'ttsc/path-identity';
+
+/**
+ * Replay the compiler's realpath observation. An empty resolver result is
+ * unsuccessful; a thrown native resolution uses the compiler's cleaned lexical
+ * fallback instead of becoming a missing-input proof.
+ *
+ * @evidence contracts/common.md#principled-implementation Empty results and thrown resolution remain distinct because the compiler records an empty result as failed but cleans the input spelling on native resolution failure.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter maps resolver output into the envelope's realpath observation; identity comparison remains with its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The lexical fallback reproduces the compiler filesystem contract rather than fabricating successful physical resolution for a known input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes empty, successful and fallback results; a blank comment line separates acknowledgments under the documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied resolver and explicit path dialect through resolveFilesystemPath; the cleaned fallback does not claim native alias or case equivalence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This fixed protocol adapter maps one supplied realpath result or exception into an observation. Native resolution and lexical path cleanup retain their component/link and text-length costs in the respective owners; one call is not a constant native-work guarantee.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It replays the compiler's observation against the filesystem now by design, so nothing is shared.
+ */
+function compilerInputRealpathObservation(file, filesystem) {
+    try {
+        const realpath = filesystem.realpath(file);
+        return realpath.length === 0
+            ? { ok: false }
+            : {
+                ok: true,
+                path: resolveFilesystemPath(realpath, filesystem.platform),
+            };
+    }
+    catch {
+        // TypeScript-Go's OS and io filesystems return the cleaned input spelling
+        // when native realpath resolution fails; they do not expose the failure.
+        return {
+            ok: true,
+            path: resolveFilesystemPath(file, filesystem.platform),
+        };
+    }
+}
+
+export { compilerInputRealpathObservation };
+//# sourceMappingURL=compilerInputRealpathObservation.mjs.map

package/lib/core/transform/inputs/compilerInputRealpathObservation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerInputRealpathObservation.mjs","sources":["../../../../src/core/transform/inputs/compilerInputRealpathObservation.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;AAaG;AACG,SAAU,gCAAgC,CAC9C,IAAY,EACZ,UAA6C,EAAA;AAE7C,IAAA,IAAI;QACF,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;AAC1C,QAAA,OAAO,QAAQ,CAAC,MAAM,KAAK;AACzB,cAAE,EAAE,EAAE,EAAE,KAAK;AACb,cAAE;AACE,gBAAA,EAAE,EAAE,IAAI;gBACR,IAAI,EAAE,qBAAqB,CAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC;aAC3D;IACP;AAAE,IAAA,MAAM;;;QAGN,OAAO;AACL,YAAA,EAAE,EAAE,IAAI;YACR,IAAI,EAAE,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC;SACvD;IACH;AACF;;;;"}

package/lib/core/transform/inputs/compilerInputTextHash.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Hash one observed byte buffer under the compiler's BOM decoding rules. UTF-16
+ * omits an incomplete trailing unit and big-endian decoding copies its slice
+ * before swapping; raw host hashing can still consume the original bytes.
+ *
+ * @evidence contracts/common.md#principled-implementation Compiler text decoding removes UTF BOMs and preserves the existing incomplete UTF-16 unit rule before hashing.
+ * @evidence contracts/common.md#clear-and-simple-design One byte-to-text hash owner lets a current observation share its actual read across compiler and host codecs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied observed bytes determine the hash; no expected digest or stale filesystem reading substitutes for them.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains decoding and the original buffer's continued raw-byte availability.
+ * @evidence contracts/portability.md#os-neutral-implementation Encoding comes from observed BOM bytes, independently of platform defaults; big-endian decoding copies before swapping and leaves raw input unchanged.
+ * @evidence contracts/performance.md#efficient-algorithms Decoding and hashing scan B bytes; UTF-8 slices share storage, while UTF-16 decoding allocates proportional text and big-endian input requires a copy.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can derive both codecs from one current read; this pure decoder retains no cross-observation cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the digest escapes; temporary decoded text and copied bytes remain call-local.
+ */
+export declare function compilerInputTextHash(bytes: Buffer): string;

package/lib/core/transform/inputs/compilerInputTextHash.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Hash one observed byte buffer under the compiler's BOM decoding rules. UTF-16
+ * omits an incomplete trailing unit and big-endian decoding copies its slice
+ * before swapping; raw host hashing can still consume the original bytes.
+ *
+ * @evidence contracts/common.md#principled-implementation Compiler text decoding removes UTF BOMs and preserves the existing incomplete UTF-16 unit rule before hashing.
+ * @evidence contracts/common.md#clear-and-simple-design One byte-to-text hash owner lets a current observation share its actual read across compiler and host codecs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied observed bytes determine the hash; no expected digest or stale filesystem reading substitutes for them.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains decoding and the original buffer's continued raw-byte availability.
+ * @evidence contracts/portability.md#os-neutral-implementation Encoding comes from observed BOM bytes, independently of platform defaults; big-endian decoding copies before swapping and leaves raw input unchanged.
+ * @evidence contracts/performance.md#efficient-algorithms Decoding and hashing scan B bytes; UTF-8 slices share storage, while UTF-16 decoding allocates proportional text and big-endian input requires a copy.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can derive both codecs from one current read; this pure decoder retains no cross-observation cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the digest escapes; temporary decoded text and copied bytes remain call-local.
+ */
+export declare function compilerInputTextHash(bytes: Buffer): string;

package/lib/core/transform/inputs/compilerInputTextHash.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hash one observed byte buffer under the compiler's BOM decoding rules. UTF-16
+ * omits an incomplete trailing unit and big-endian decoding copies its slice
+ * before swapping; raw host hashing can still consume the original bytes.
+ *
+ * @evidence contracts/common.md#principled-implementation Compiler text decoding removes UTF BOMs and preserves the existing incomplete UTF-16 unit rule before hashing.
+ * @evidence contracts/common.md#clear-and-simple-design One byte-to-text hash owner lets a current observation share its actual read across compiler and host codecs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied observed bytes determine the hash; no expected digest or stale filesystem reading substitutes for them.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains decoding and the original buffer's continued raw-byte availability.
+ * @evidence contracts/portability.md#os-neutral-implementation Encoding comes from observed BOM bytes, independently of platform defaults; big-endian decoding copies before swapping and leaves raw input unchanged.
+ * @evidence contracts/performance.md#efficient-algorithms Decoding and hashing scan B bytes; UTF-8 slices share storage, while UTF-16 decoding allocates proportional text and big-endian input requires a copy.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can derive both codecs from one current read; this pure decoder retains no cross-observation cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the digest escapes; temporary decoded text and copied bytes remain call-local.
+ */
+export declare function compilerInputTextHash(bytes: Buffer): string;

package/lib/core/transform/inputs/compilerInputTextHash.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var hashText = require('../utils/hashText.js');
+
+/**
+ * Hash one observed byte buffer under the compiler's BOM decoding rules. UTF-16
+ * omits an incomplete trailing unit and big-endian decoding copies its slice
+ * before swapping; raw host hashing can still consume the original bytes.
+ *
+ * @evidence contracts/common.md#principled-implementation Compiler text decoding removes UTF BOMs and preserves the existing incomplete UTF-16 unit rule before hashing.
+ * @evidence contracts/common.md#clear-and-simple-design One byte-to-text hash owner lets a current observation share its actual read across compiler and host codecs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied observed bytes determine the hash; no expected digest or stale filesystem reading substitutes for them.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains decoding and the original buffer's continued raw-byte availability.
+ * @evidence contracts/portability.md#os-neutral-implementation Encoding comes from observed BOM bytes, independently of platform defaults; big-endian decoding copies before swapping and leaves raw input unchanged.
+ * @evidence contracts/performance.md#efficient-algorithms Decoding and hashing scan B bytes; UTF-8 slices share storage, while UTF-16 decoding allocates proportional text and big-endian input requires a copy.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can derive both codecs from one current read; this pure decoder retains no cross-observation cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the digest escapes; temporary decoded text and copied bytes remain call-local.
+ */
+function compilerInputTextHash(bytes) {
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        const even = bytes.subarray(2, 2 + Math.floor((bytes.length - 2) / 2) * 2);
+        return hashText.hashText(Buffer.from(even.toString("utf16le"), "utf8"));
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        const even = Buffer.from(bytes.subarray(2, 2 + Math.floor((bytes.length - 2) / 2) * 2));
+        even.swap16();
+        return hashText.hashText(Buffer.from(even.toString("utf16le"), "utf8"));
+    }
+    return hashText.hashText(bytes.length >= 3 &&
+        bytes[0] === 0xef &&
+        bytes[1] === 0xbb &&
+        bytes[2] === 0xbf
+        ? bytes.subarray(3)
+        : bytes);
+}
+
+exports.compilerInputTextHash = compilerInputTextHash;
+//# sourceMappingURL=compilerInputTextHash.js.map

package/lib/core/transform/inputs/compilerInputTextHash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerInputTextHash.js","sources":["../../../../src/core/transform/inputs/compilerInputTextHash.ts"],"sourcesContent":[null],"names":["hashText"],"mappings":";;;;AAEA;;;;;;;;;;;;;AAaG;AACG,SAAU,qBAAqB,CAAC,KAAa,EAAA;IACjD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;QAC/D,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAC1E,QAAA,OAAOA,iBAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;IAChE;IACA,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;AAC/D,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CACtB,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAC9D;QACD,IAAI,CAAC,MAAM,EAAE;AACb,QAAA,OAAOA,iBAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;IAChE;AACA,IAAA,OAAOA,iBAAQ,CACb,KAAK,CAAC,MAAM,IAAI,CAAC;AACf,QAAA,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;AACjB,QAAA,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;AACjB,QAAA,KAAK,CAAC,CAAC,CAAC,KAAK;AACb,UAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;UAChB,KAAK,CACV;AACH;;;;"}

package/lib/core/transform/inputs/compilerInputTextHash.mjs

@@ -0,0 +1,36 @@
+import { hashText } from '../utils/hashText.mjs';
+
+/**
+ * Hash one observed byte buffer under the compiler's BOM decoding rules. UTF-16
+ * omits an incomplete trailing unit and big-endian decoding copies its slice
+ * before swapping; raw host hashing can still consume the original bytes.
+ *
+ * @evidence contracts/common.md#principled-implementation Compiler text decoding removes UTF BOMs and preserves the existing incomplete UTF-16 unit rule before hashing.
+ * @evidence contracts/common.md#clear-and-simple-design One byte-to-text hash owner lets a current observation share its actual read across compiler and host codecs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied observed bytes determine the hash; no expected digest or stale filesystem reading substitutes for them.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains decoding and the original buffer's continued raw-byte availability.
+ * @evidence contracts/portability.md#os-neutral-implementation Encoding comes from observed BOM bytes, independently of platform defaults; big-endian decoding copies before swapping and leaves raw input unchanged.
+ * @evidence contracts/performance.md#efficient-algorithms Decoding and hashing scan B bytes; UTF-8 slices share storage, while UTF-16 decoding allocates proportional text and big-endian input requires a copy.
+ * @evidence contracts/performance.md#reuse-equivalent-work The caller can derive both codecs from one current read; this pure decoder retains no cross-observation cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the digest escapes; temporary decoded text and copied bytes remain call-local.
+ */
+function compilerInputTextHash(bytes) {
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        const even = bytes.subarray(2, 2 + Math.floor((bytes.length - 2) / 2) * 2);
+        return hashText(Buffer.from(even.toString("utf16le"), "utf8"));
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        const even = Buffer.from(bytes.subarray(2, 2 + Math.floor((bytes.length - 2) / 2) * 2));
+        even.swap16();
+        return hashText(Buffer.from(even.toString("utf16le"), "utf8"));
+    }
+    return hashText(bytes.length >= 3 &&
+        bytes[0] === 0xef &&
+        bytes[1] === 0xbb &&
+        bytes[2] === 0xbf
+        ? bytes.subarray(3)
+        : bytes);
+}
+
+export { compilerInputTextHash };
+//# sourceMappingURL=compilerInputTextHash.mjs.map

package/lib/core/transform/inputs/compilerInputTextHash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerInputTextHash.mjs","sources":["../../../../src/core/transform/inputs/compilerInputTextHash.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;AAaG;AACG,SAAU,qBAAqB,CAAC,KAAa,EAAA;IACjD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;QAC/D,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAC1E,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;IAChE;IACA,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;AAC/D,QAAA,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CACtB,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAC9D;QACD,IAAI,CAAC,MAAM,EAAE;AACb,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;IAChE;AACA,IAAA,OAAO,QAAQ,CACb,KAAK,CAAC,MAAM,IAAI,CAAC;AACf,QAAA,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;AACjB,QAAA,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;AACjB,QAAA,KAAK,CAAC,CAAC,CAAC,KAAK;AACb,UAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;UAChB,KAAK,CACV;AACH;;;;"}

package/lib/core/transform/inputs/compilerStatKind.d.cts

@@ -0,0 +1,16 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Classify a following stat as the compiler does: directories retain their
+ * kind, every other successful stat is a file, and a failed stat is missing.
+ * This classification does not establish readable content.
+ *
+ * @evidence contracts/common.md#principled-implementation The three results preserve the compiler's directory-versus-other stat semantics and failure result; isFile is intentionally not a separate prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design One following stat owns classification without mixing byte reads or lexical existence checks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Classification derives from observed metadata rather than extensions, recorded expectations or a patched stat implementation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-directory success and the readability boundary, with a separated acknowledgment block following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral kind observation uses the supplied filesystem's following stat and native directory predicate; special non-directory nodes follow compiler semantics rather than host-specific guesses.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed scalar adapter classifies one supplied following stat and chooses no population-processing strategy. Native component/link resolution cost remains with that filesystem operation; one call does not certify constant native work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It classifies the filesystem now by design, so nothing is shared.
+ */
+export declare function compilerStatKind(file: string, filesystem: TtscTransformFilesystemOperations): "directory" | "file" | "missing";

package/lib/core/transform/inputs/compilerStatKind.d.mts

@@ -0,0 +1,16 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Classify a following stat as the compiler does: directories retain their
+ * kind, every other successful stat is a file, and a failed stat is missing.
+ * This classification does not establish readable content.
+ *
+ * @evidence contracts/common.md#principled-implementation The three results preserve the compiler's directory-versus-other stat semantics and failure result; isFile is intentionally not a separate prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design One following stat owns classification without mixing byte reads or lexical existence checks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Classification derives from observed metadata rather than extensions, recorded expectations or a patched stat implementation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-directory success and the readability boundary, with a separated acknowledgment block following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral kind observation uses the supplied filesystem's following stat and native directory predicate; special non-directory nodes follow compiler semantics rather than host-specific guesses.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed scalar adapter classifies one supplied following stat and chooses no population-processing strategy. Native component/link resolution cost remains with that filesystem operation; one call does not certify constant native work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It classifies the filesystem now by design, so nothing is shared.
+ */
+export declare function compilerStatKind(file: string, filesystem: TtscTransformFilesystemOperations): "directory" | "file" | "missing";

package/lib/core/transform/inputs/compilerStatKind.d.ts

@@ -0,0 +1,16 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Classify a following stat as the compiler does: directories retain their
+ * kind, every other successful stat is a file, and a failed stat is missing.
+ * This classification does not establish readable content.
+ *
+ * @evidence contracts/common.md#principled-implementation The three results preserve the compiler's directory-versus-other stat semantics and failure result; isFile is intentionally not a separate prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design One following stat owns classification without mixing byte reads or lexical existence checks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Classification derives from observed metadata rather than extensions, recorded expectations or a patched stat implementation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-directory success and the readability boundary, with a separated acknowledgment block following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral kind observation uses the supplied filesystem's following stat and native directory predicate; special non-directory nodes follow compiler semantics rather than host-specific guesses.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed scalar adapter classifies one supplied following stat and chooses no population-processing strategy. Native component/link resolution cost remains with that filesystem operation; one call does not certify constant native work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It classifies the filesystem now by design, so nothing is shared.
+ */
+export declare function compilerStatKind(file: string, filesystem: TtscTransformFilesystemOperations): "directory" | "file" | "missing";

package/lib/core/transform/inputs/compilerStatKind.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Classify a following stat as the compiler does: directories retain their
+ * kind, every other successful stat is a file, and a failed stat is missing.
+ * This classification does not establish readable content.
+ *
+ * @evidence contracts/common.md#principled-implementation The three results preserve the compiler's directory-versus-other stat semantics and failure result; isFile is intentionally not a separate prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design One following stat owns classification without mixing byte reads or lexical existence checks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Classification derives from observed metadata rather than extensions, recorded expectations or a patched stat implementation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-directory success and the readability boundary, with a separated acknowledgment block following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral kind observation uses the supplied filesystem's following stat and native directory predicate; special non-directory nodes follow compiler semantics rather than host-specific guesses.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed scalar adapter classifies one supplied following stat and chooses no population-processing strategy. Native component/link resolution cost remains with that filesystem operation; one call does not certify constant native work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It classifies the filesystem now by design, so nothing is shared.
+ */
+function compilerStatKind(file, filesystem) {
+    try {
+        return filesystem.stat(file).isDirectory() ? "directory" : "file";
+    }
+    catch {
+        return "missing";
+    }
+}
+
+exports.compilerStatKind = compilerStatKind;
+//# sourceMappingURL=compilerStatKind.js.map

package/lib/core/transform/inputs/compilerStatKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerStatKind.js","sources":["../../../../src/core/transform/inputs/compilerStatKind.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;AAaG;AACG,SAAU,gBAAgB,CAC9B,IAAY,EACZ,UAA6C,EAAA;AAE7C,IAAA,IAAI;AACF,QAAA,OAAO,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,GAAG,WAAW,GAAG,MAAM;IACnE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;;;;"}

package/lib/core/transform/inputs/compilerStatKind.mjs

@@ -0,0 +1,25 @@
+/**
+ * Classify a following stat as the compiler does: directories retain their
+ * kind, every other successful stat is a file, and a failed stat is missing.
+ * This classification does not establish readable content.
+ *
+ * @evidence contracts/common.md#principled-implementation The three results preserve the compiler's directory-versus-other stat semantics and failure result; isFile is intentionally not a separate prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design One following stat owns classification without mixing byte reads or lexical existence checks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Classification derives from observed metadata rather than extensions, recorded expectations or a patched stat implementation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-directory success and the readability boundary, with a separated acknowledgment block following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral kind observation uses the supplied filesystem's following stat and native directory predicate; special non-directory nodes follow compiler semantics rather than host-specific guesses.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns before the function does; no handle is retained.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed scalar adapter classifies one supplied following stat and chooses no population-processing strategy. Native component/link resolution cost remains with that filesystem operation; one call does not certify constant native work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It classifies the filesystem now by design, so nothing is shared.
+ */
+function compilerStatKind(file, filesystem) {
+    try {
+        return filesystem.stat(file).isDirectory() ? "directory" : "file";
+    }
+    catch {
+        return "missing";
+    }
+}
+
+export { compilerStatKind };
+//# sourceMappingURL=compilerStatKind.mjs.map

package/lib/core/transform/inputs/compilerStatKind.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerStatKind.mjs","sources":["../../../../src/core/transform/inputs/compilerStatKind.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;AAaG;AACG,SAAU,gBAAgB,CAC9B,IAAY,EACZ,UAA6C,EAAA;AAE7C,IAAA,IAAI;AACF,QAAA,OAAO,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,GAAG,WAAW,GAAG,MAAM;IACnE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;;;;"}

package/lib/core/transform/inputs/graphInputObservationFailures.d.cts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Replay the predicates recorded for one compiler-input spelling and collect
+ * every mismatch. Only recorded predicates are observed; one following stat is
+ * shared by kind, existence and read checks. Directory listings preserve sorted
+ * compiler entry names, while realpaths compare through filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Each present predicate compares its recorded result with compiler-compatible replay, preserving read failure, native kind, listing order and realpath identity as separate observations.
+ * @evidence contracts/common.md#clear-and-simple-design The collector owns mismatch names and delegates stat, text normalization and physical equivalence to their single-purpose observers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unrecorded predicates are not invented, and read or resolution failure is compared against recorded failure instead of replaced by a convenient cache match.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states full collection, absent-predicate behavior and shared observations, with separated acknowledgment tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied filesystem and identity context; accessible-entry joining selects that view's path dialect and realpath equality follows actual case capabilities.
+ * @evidence contracts/performance.md#efficient-algorithms One kind stat serves existence, kind and read checks; native listing/link/identity operations retain their path costs. Selected listings encode name bytes, sort E names by compared UTF-8 prefixes and serialize current/recorded names for equality; text decoding/hashing scans B read bytes. Temporary storage follows listing names/encodings/serialized text, read buffers and supplied identity observations; the returned failure list has the six compiler predicate names plus one name per supplied native predicate. Absent listing/read predicates perform neither operation.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This collects one current replay; the generation owner decides whether an earlier replay remains valid across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Entry arrays and failure names are observation-local, with no persistent cache, descriptor or running task owned by the collector.
+ */
+export declare function graphInputObservationFailures(file: string, observation: ITtscCompilerTransformation.IInputObservation, filesystem: TtscTransformFilesystemOperations, identities: FilesystemPathIdentityContext): string[];

package/lib/core/transform/inputs/graphInputObservationFailures.d.mts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Replay the predicates recorded for one compiler-input spelling and collect
+ * every mismatch. Only recorded predicates are observed; one following stat is
+ * shared by kind, existence and read checks. Directory listings preserve sorted
+ * compiler entry names, while realpaths compare through filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Each present predicate compares its recorded result with compiler-compatible replay, preserving read failure, native kind, listing order and realpath identity as separate observations.
+ * @evidence contracts/common.md#clear-and-simple-design The collector owns mismatch names and delegates stat, text normalization and physical equivalence to their single-purpose observers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unrecorded predicates are not invented, and read or resolution failure is compared against recorded failure instead of replaced by a convenient cache match.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states full collection, absent-predicate behavior and shared observations, with separated acknowledgment tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied filesystem and identity context; accessible-entry joining selects that view's path dialect and realpath equality follows actual case capabilities.
+ * @evidence contracts/performance.md#efficient-algorithms One kind stat serves existence, kind and read checks; native listing/link/identity operations retain their path costs. Selected listings encode name bytes, sort E names by compared UTF-8 prefixes and serialize current/recorded names for equality; text decoding/hashing scans B read bytes. Temporary storage follows listing names/encodings/serialized text, read buffers and supplied identity observations; the returned failure list has the six compiler predicate names plus one name per supplied native predicate. Absent listing/read predicates perform neither operation.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This collects one current replay; the generation owner decides whether an earlier replay remains valid across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Entry arrays and failure names are observation-local, with no persistent cache, descriptor or running task owned by the collector.
+ */
+export declare function graphInputObservationFailures(file: string, observation: ITtscCompilerTransformation.IInputObservation, filesystem: TtscTransformFilesystemOperations, identities: FilesystemPathIdentityContext): string[];

package/lib/core/transform/inputs/graphInputObservationFailures.d.ts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Replay the predicates recorded for one compiler-input spelling and collect
+ * every mismatch. Only recorded predicates are observed; one following stat is
+ * shared by kind, existence and read checks. Directory listings preserve sorted
+ * compiler entry names, while realpaths compare through filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Each present predicate compares its recorded result with compiler-compatible replay, preserving read failure, native kind, listing order and realpath identity as separate observations.
+ * @evidence contracts/common.md#clear-and-simple-design The collector owns mismatch names and delegates stat, text normalization and physical equivalence to their single-purpose observers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unrecorded predicates are not invented, and read or resolution failure is compared against recorded failure instead of replaced by a convenient cache match.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states full collection, absent-predicate behavior and shared observations, with separated acknowledgment tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral replay uses the supplied filesystem and identity context; accessible-entry joining selects that view's path dialect and realpath equality follows actual case capabilities.
+ * @evidence contracts/performance.md#efficient-algorithms One kind stat serves existence, kind and read checks; native listing/link/identity operations retain their path costs. Selected listings encode name bytes, sort E names by compared UTF-8 prefixes and serialize current/recorded names for equality; text decoding/hashing scans B read bytes. Temporary storage follows listing names/encodings/serialized text, read buffers and supplied identity observations; the returned failure list has the six compiler predicate names plus one name per supplied native predicate. Absent listing/read predicates perform neither operation.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This collects one current replay; the generation owner decides whether an earlier replay remains valid across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Entry arrays and failure names are observation-local, with no persistent cache, descriptor or running task owned by the collector.
+ */
+export declare function graphInputObservationFailures(file: string, observation: ITtscCompilerTransformation.IInputObservation, filesystem: TtscTransformFilesystemOperations, identities: FilesystemPathIdentityContext): string[];